@memori.ai/memori-react 8.41.0 → 8.41.2

package/src/components/MemoriWidget/MemoriWidget.tsx

@@ -91,6 +91,10 @@ import {
   NatsDialogResponseEvent,
   NatsErrorEvent,
 } from '../../helpers/nats/useNatsSession';
+import {
+  isSessionExpiredNatsError,
+  isSessionExpiredNatsResponse,
+} from '../../helpers/nats/isSessionExpiredError';
 
 // Widget utilities and helpers
 const getMemoriState = (integrationId?: string): object | null => {
@@ -646,11 +650,21 @@ const MemoriWidget = ({
   const [memoriTyping, setMemoriTyping] = useState<boolean>(false);
   const [typingText, setTypingText] = useState<string>();
 
-  type PendingEnterText = {
-    msg?: string;
+  type EnterTextRetryParams = {
+    text?: string;
+    media?: Medium[];
+    translate?: boolean;
+    translatedText?: string;
+    hidden?: boolean;
     typingText?: string;
     useLoaderTextAsMsg?: boolean;
     hasBatchQueued?: boolean;
+    expiredSessionID?: string;
+    continueFromChatLogID?: string;
+  };
+
+  type PendingEnterText = EnterTextRetryParams & {
+    msg?: string;
     waitForResponse?: {
       resolve: (event: NatsDialogResponseEvent) => void;
       reject: (error: Error) => void;
@@ -893,6 +907,7 @@ const MemoriWidget = ({
    * @param typingText Optional custom typing indicator text
    * @param useLoaderTextAsMsg Whether to use the loader text as the message (default false)
    * @param hasBatchQueued Whether there are more messages queued to be sent (default false)
+   * @param skipHistoryPush Skip adding the user message to history (e.g. session-expired retry)
    */
   const sendMessage = async (
     text: string,
@@ -903,7 +918,8 @@ const MemoriWidget = ({
     hidden: boolean = false,
     typingText?: string,
     useLoaderTextAsMsg = false,
-    hasBatchQueued = false
+    hasBatchQueued = false,
+    skipHistoryPush = false
   ) => {
     // Get the session ID from params or global state
     const sessionID =
@@ -970,7 +986,7 @@ const MemoriWidget = ({
     }
 
     // Add user message to chat history if not hidden
-    if (!hidden)
+    if (!hidden && !skipHistoryPush)
       pushMessage({
         text: text,
         translatedText,
@@ -998,6 +1014,11 @@ const MemoriWidget = ({
       if (response.resultCode === 0 && correlationID) {
         registerPendingEnterText(correlationID, {
           msg,
+          text,
+          media,
+          translate,
+          translatedText,
+          hidden,
           typingText,
           useLoaderTextAsMsg,
           hasBatchQueued,
@@ -1007,34 +1028,17 @@ const MemoriWidget = ({
       } else if (response.resultCode === 0) {
         logWidgetError('enter-text missing correlationID', response);
       } else if (response.resultCode === 404) {
-        // Handle expired session
-        // remove last sent message, will set it as initial
-        setHistory(h => [...h.slice(0, h.length - 1)]);
-
-        reopenSession(
-          true,
-          memoriPwd || memori.secretToken,
-          memoriTokens,
-          undefined,
-          undefined,
-          {
-            LANG: userLang,
-            PATHNAME: window.location.pathname,
-            ROUTE: window.location.pathname?.split('/')?.pop() || '',
-            ...(initialContextVars || {}),
-          },
-          initialQuestion,
-          undefined,
-          undefined,
-          undefined,
-          undefined,
-          true // isSessionExpired
-        ).then(state => {
-          if (state?.sessionID) {
-            setTimeout(() => {
-              sendMessage(text, media, state?.sessionID);
-            }, 500);
-          }
+        retryAfterExpiredSessionRef.current({
+          text,
+          media,
+          translate,
+          translatedText,
+          hidden,
+          typingText,
+          useLoaderTextAsMsg,
+          hasBatchQueued,
+          expiredSessionID: sessionID,
+          continueFromChatLogID: chatLogID,
         });
       } else if (response.resultCode === 500 && response.resultMessage) {
         setHistory(h => [
@@ -1487,7 +1491,8 @@ const MemoriWidget = ({
     additionalInfoProp?: { [key: string]: string | undefined },
     continueFromChatLogID?: string,
     continueFromSessionID?: string,
-    isSessionExpired?: boolean
+    isSessionExpired?: boolean,
+    suppressHistoryUpdate?: boolean
   ) => {
     // Set loading state while reopening session
     setLoading(true);
@@ -1577,12 +1582,28 @@ const MemoriWidget = ({
         if (updateDialogState) {
           setCurrentDialogState(currentState);
 
-          if (currentState.emission) {
+          const sessionExpiredStatus =
+            isSessionExpired && history.length > 1
+              ? t('sessionExpiredReopening')
+              : null;
+
+          if (sessionExpiredStatus && suppressHistoryUpdate) {
+            pushMessage({
+              text: '',
+              emitter: 'system',
+              fromUser: false,
+              initial: sessionExpiredStatus as any,
+              contextVars: {},
+              date: new Date().toISOString(),
+            });
+          }
+
+          if (currentState.emission && !suppressHistoryUpdate) {
             // Determine initial status message based on context
             // Show status message only if session expired and there's existing history
             const initialStatus =
-              isSessionExpired && history.length > 1
-                ? 'Session Expired, reopening session'
+              sessionExpiredStatus
+                ? sessionExpiredStatus
                 : history.length <= 1
                 ? true
                 : undefined;
@@ -1661,6 +1682,94 @@ const MemoriWidget = ({
     return null;
   };
 
+  const retryAfterExpiredSessionRef = useRef<
+    (params: EnterTextRetryParams) => ReturnType<typeof reopenSession>
+  >(() => Promise.resolve(null));
+
+  retryAfterExpiredSessionRef.current = (params: EnterTextRetryParams) => {
+    const {
+      text,
+      media,
+      translate = true,
+      translatedText,
+      hidden = false,
+      typingText,
+      useLoaderTextAsMsg = false,
+      hasBatchQueued = false,
+      expiredSessionID,
+      continueFromChatLogID: continueFromChatLogIDParam,
+    } = params;
+
+    const continueFromSessionID = expiredSessionID ?? sessionId;
+    const continueFromChatLogID = continueFromChatLogIDParam ?? chatLogID;
+
+    const reopenAfterExpiry = () =>
+      reopenSession(
+        true,
+        memoriPwd || memori.secretToken,
+        memoriTokens,
+        undefined,
+        undefined,
+        {
+          LANG: userLang,
+          PATHNAME: window.location.pathname,
+          ROUTE: window.location.pathname?.split('/')?.pop() || '',
+          ...(initialContextVars || {}),
+        },
+        initialQuestion,
+        undefined,
+        undefined,
+        continueFromChatLogID,
+        continueFromSessionID,
+        true,
+        true
+      );
+
+    const scheduleRetry = (newSessionID: string) => {
+      setTimeout(() => {
+        sendMessage(
+          text!,
+          media,
+          newSessionID,
+          translate,
+          translatedText,
+          hidden,
+          typingText,
+          useLoaderTextAsMsg,
+          hasBatchQueued,
+          true
+        );
+      }, 500);
+    };
+
+    const handleReopenFailure = (state: Awaited<ReturnType<typeof reopenSession>>) => {
+      setMemoriTyping(false);
+      setTypingText(undefined);
+      // `null` = explicit failure; `undefined` = auth/age modal opened (message kept in history)
+      if (state === null && text && !hidden) {
+        toast.error(t('errors.SESSION_EXPIRED'));
+      }
+    };
+
+    if (!text) {
+      return reopenAfterExpiry().then(state => {
+        if (!state?.sessionID) {
+          handleReopenFailure(state);
+        }
+        return state;
+      });
+    }
+
+    return reopenAfterExpiry().then(state => {
+      if (state?.sessionID) {
+        scheduleRetry(state.sessionID);
+      } else {
+        handleReopenFailure(state);
+      }
+      return state;
+    });
+  };
+
   const changeTag = async (
     memoriId: string,
     sessionId: string,
@@ -1990,6 +2099,24 @@ const MemoriWidget = ({
       const currentState = event.currentState;
 
       if (event.resultCode !== 0 || !currentState) {
+        if (isSessionExpiredNatsResponse(event) && pending.text) {
+          setMemoriTyping(false);
+          setTypingText(undefined);
+          retryAfterExpiredSessionRef.current({
+            text: pending.text,
+            media: pending.media,
+            translate: pending.translate,
+            translatedText: pending.translatedText,
+            hidden: pending.hidden,
+            typingText: pending.typingText,
+            useLoaderTextAsMsg: pending.useLoaderTextAsMsg,
+            hasBatchQueued: pending.hasBatchQueued,
+            expiredSessionID: sessionId,
+            continueFromChatLogID: chatLogID,
+          });
+          return;
+        }
+
         if (event.resultCode === 500 && event.resultMessage) {
           setHistory(h => [
             ...h,
@@ -2083,6 +2210,38 @@ const MemoriWidget = ({
   const deliverEnterTextNatsError = useCallback(
     (event: NatsErrorEvent) => {
       const correlationID = event.correlationID;
+      let pending: PendingEnterText | undefined;
+
+      if (correlationID) {
+        pending = pendingEnterTextRef.current.get(correlationID);
+        if (pending) {
+          clearEnterTextPending(correlationID, pending);
+          pending.waitForResponse?.reject(
+            new Error(
+              event.errorMessage ?? String(event.errorCode ?? 'NATS error')
+            )
+          );
+        }
+      }
+
+      if (isSessionExpiredNatsError(event) && pending?.text) {
+        setMemoriTyping(false);
+        setTypingText(undefined);
+        retryAfterExpiredSessionRef.current({
+          text: pending.text,
+          media: pending.media,
+          translate: pending.translate,
+          translatedText: pending.translatedText,
+          hidden: pending.hidden,
+          typingText: pending.typingText,
+          useLoaderTextAsMsg: pending.useLoaderTextAsMsg,
+          hasBatchQueued: pending.hasBatchQueued,
+          expiredSessionID: sessionId,
+          continueFromChatLogID: chatLogID,
+        });
+        return;
+      }
+
       const errorText = event.errorMessage
         ? `Error: ${event.errorMessage}`
         : event.errorCode
@@ -2098,16 +2257,6 @@ const MemoriWidget = ({
         date: new Date().toISOString(),
       });
 
-      if (correlationID) {
-        const pending = pendingEnterTextRef.current.get(correlationID);
-        if (pending) {
-          clearEnterTextPending(correlationID, pending);
-          pending.waitForResponse?.reject(
-            new Error(event.errorMessage ?? String(event.errorCode ?? 'NATS error'))
-          );
-        }
-      }
-
       setMemoriTyping(false);
       setTypingText(undefined);
     },

package/src/components/layouts/website-assistant.css

@@ -397,7 +397,8 @@
     transform: none !important;
 }
 
-.memori-layout-website_assistant.memori--avatar-readyplayerme-full .memori--avatar-wrapper > div {
+.memori-layout-website_assistant.memori--avatar-readyplayerme-full .memori--avatar-wrapper > div,
+.memori-layout-website_assistant.memori--avatar-avatar-configurator .memori--avatar-wrapper > div {
     transform: scale(1.7) translate(0px, 10vh);
 }
 

package/src/helpers/nats/isSessionExpiredError.test.ts

@@ -0,0 +1,38 @@
+import {
+  isSessionExpiredNatsError,
+  isSessionExpiredNatsResponse,
+} from './isSessionExpiredError';
+
+describe('isSessionExpiredNatsError', () => {
+  it('detects session not found from EnterTextAsync NATS error', () => {
+    expect(
+      isSessionExpiredNatsError({
+        eventType: 'error',
+        errorCode: 'EnterTextAsync Error',
+        errorMessage:
+          'Session with ID "c681a10b-37c1-4783-af3b-ecb592b93036" not found',
+        correlationID: 'f85a6882-92e1-4e18-9fb7-29d3bc06fd7b',
+      })
+    ).toBe(true);
+  });
+
+  it('detects SESSION_EXPIRED result code on dialog response', () => {
+    expect(
+      isSessionExpiredNatsResponse({
+        eventType: 'dialog_text_entered_response',
+        resultCode: -103,
+        correlationID: 'abc',
+      })
+    ).toBe(true);
+  });
+
+  it('ignores unrelated NATS errors', () => {
+    expect(
+      isSessionExpiredNatsError({
+        eventType: 'error',
+        errorCode: 'SomeOtherError',
+        errorMessage: 'Something went wrong',
+      })
+    ).toBe(false);
+  });
+});

package/src/helpers/nats/isSessionExpiredError.ts

@@ -0,0 +1,51 @@
+import type {
+  NatsDialogResponseEvent,
+  NatsErrorEvent,
+} from './useNatsSession';
+
+/** Backend result codes for missing / expired sessions. */
+const SESSION_NOT_FOUND = -101;
+const SESSION_EXPIRED = -103;
+
+const SESSION_NOT_FOUND_MESSAGE =
+  /session\s+with\s+id\s+["']?[^"']+["']?\s+not\s+found/i;
+
+function isExpiredResultCode(resultCode?: number): boolean {
+  return (
+    resultCode === 404 ||
+    resultCode === SESSION_EXPIRED ||
+    resultCode === SESSION_NOT_FOUND
+  );
+}
+
+function isExpiredErrorMessage(message?: string): boolean {
+  if (!message) return false;
+  return SESSION_NOT_FOUND_MESSAGE.test(message);
+}
+
+/** True when a NATS `error` event indicates the active session is gone or expired. */
+export function isSessionExpiredNatsError(event: NatsErrorEvent): boolean {
+  if (isExpiredResultCode(event.errorCode as number | undefined)) {
+    return true;
+  }
+
+  if (typeof event.errorCode === 'string') {
+    const code = event.errorCode.toUpperCase();
+    if (code.includes('SESSION_EXPIRED') || code.includes('SESSION_NOT_FOUND')) {
+      return true;
+    }
+  }
+
+  return isExpiredErrorMessage(event.errorMessage);
+}
+
+/** True when a NATS dialog response reports a missing or expired session. */
+export function isSessionExpiredNatsResponse(
+  event: NatsDialogResponseEvent
+): boolean {
+  if (isExpiredResultCode(event.resultCode)) {
+    return true;
+  }
+
+  return isExpiredErrorMessage(event.resultMessage);
+}

package/src/index.stories.tsx

@@ -202,3 +202,19 @@ WithLocalNats.args = {
   spokenLang: 'IT',
   integrationID: 'ee1c3d98-7819-4506-ba28-818e79ba86cb',
 };
+
+export const WithFunctionalities = Template.bind({});
+WithFunctionalities.args = {
+  memoriName: 'test324',
+  ownerUserName: 'andrea.patini',
+  memoriID: 'd661a9ca-e907-4396-a986-5095ccd582d6',
+  ownerUserID: '69fcc557-9cb6-4e5e-b8ab-140cff975492',
+  tenantID: 'localhost:3000',
+  engineURL: 'http://localhost:7778/memori/v2',
+  apiURL: 'http://localhost:7778/api/v2',
+  baseURL: 'http://localhost:3000',
+  layout: 'FULLPAGE',
+  uiLang: 'IT',
+  spokenLang: 'IT',
+  integrationID: 'ee1c3d98-7819-4506-ba28-818e79ba86cb',
+};

package/src/locales/de.json

@@ -75,6 +75,7 @@
   "errorFetchingSession": "Fehler beim Laden der Sitzung",
   "errorGettingReferralURL": "Fehler beim Laden des Referrals",
   "errorReopeningSession": "Fehler beim erneuten Öffnen der Sitzung",
+  "sessionExpiredReopening": "Sitzung abgelaufen, Sitzung wird neu geöffnet",
   "ageVerification": "Altersüberprüfung",
   "ageVerificationText": "Um mit diesem Zwilling interagieren zu können, müssen Sie mindestens sein {{minAge}} Jahre alt.",
   "nsfw": "NSFW: Dieser Agent enthält Inhalte für Erwachsene",

package/src/locales/en.json

@@ -77,6 +77,7 @@
   "errorFetchingSession": "Error during session loading",
   "errorGettingReferralURL": "Error during referral loading",
   "errorReopeningSession": "Error during session reopening",
+  "sessionExpiredReopening": "Session expired, reopening session",
   "ageVerification": "Age verification",
   "ageVerificationText": "To interact with this agent, you must be at least {{minAge}} years old.",
   "nsfw": "NSFW: This agent contains adult contents",

package/src/locales/es.json

@@ -75,6 +75,7 @@
   "errorFetchingSession": "Error durante el cargamento de la sesión",
   "errorGettingReferralURL": "Error durante el cargamento del référent",
   "errorReopeningSession": "Error durante el re-abrir la sesión",
+  "sessionExpiredReopening": "Sesión expirada, reabriendo sesión",
   "ageVerification": "Verificación de edad",
   "ageVerificationText": "Para interactuar con este Gemelo, debes tener al menos {{minAge}} años.",
   "nsfw": "NSFW: Este gemelo contiene contenido para adultos",

package/src/locales/fr.json

@@ -74,6 +74,7 @@
   "errorFetchingSession": "Erreur lors du chargement de la session",
   "errorGettingReferralURL": "Erreur lors du chargement du référent",
   "errorReopeningSession": "Erreur lors de la re-ouverture de la session",
+  "sessionExpiredReopening": "Session expirée, réouverture en cours",
   "ageVerification": "Vérification de l'âge",
   "ageVerificationText": "Pour interagir avec ce Agent, vous devez être au minimum {{minAge}} ans.",
   "nsfw": "NSFW : Ce jumeau contient du contenu pour adultes",

package/src/locales/it.json

@@ -78,6 +78,7 @@
   "errorFetchingSession": "Errore durante il caricamento della sessione",
   "errorGettingReferralURL": "Errore durante il caricamento del riferimento",
   "errorReopeningSession": "Errore durante il riapertura della sessione",
+  "sessionExpiredReopening": "Sessione scaduta, riapertura in corso",
   "ageVerification": "Verifica dell'età",
   "ageVerificationText": "Per interagire con questo agente, devi aver almeno {{minAge}} anni.",
   "nsfw": "NSFW: Questo agente contiene contenuti per adulti",

package/src/types/integration.test.ts

@@ -0,0 +1,32 @@
+import {
+  is3dAvatarWithUrl,
+  usesRpmAvatarView,
+} from './integration';
+
+describe('integration avatar helpers', () => {
+  const avatarURL = 'https://example.com/avatar.glb';
+
+  describe('is3dAvatarWithUrl', () => {
+    it('returns true for avatar-configurator with avatarURL', () => {
+      expect(is3dAvatarWithUrl('avatar-configurator', avatarURL)).toBe(true);
+    });
+
+    it('returns false for avatar-configurator without avatarURL', () => {
+      expect(is3dAvatarWithUrl('avatar-configurator', undefined)).toBe(false);
+    });
+  });
+
+  describe('usesRpmAvatarView', () => {
+    it('returns true for avatar-configurator', () => {
+      expect(usesRpmAvatarView('avatar-configurator')).toBe(true);
+    });
+
+    it('returns true for readyplayerme-full', () => {
+      expect(usesRpmAvatarView('readyplayerme-full')).toBe(true);
+    });
+
+    it('returns false for customglb', () => {
+      expect(usesRpmAvatarView('customglb')).toBe(false);
+    });
+  });
+});

package/src/types/integration.ts

@@ -0,0 +1,31 @@
+/**
+ * Avatar mode stored in integration.customData.avatar.
+ * `avatar-configurator` is used in admin/editor UI; at runtime it renders like `readyplayerme-full`.
+ */
+export type AvatarMode =
+  | 'readyplayerme'
+  | 'readyplayerme-full'
+  | 'customglb'
+  | 'customrpm'
+  | 'userAvatar'
+  | 'avatar-configurator';
+
+export const is3dAvatarWithUrl = (
+  avatar: AvatarMode | string | undefined,
+  avatarURL: string | undefined
+): boolean =>
+  !!avatarURL &&
+  (avatar === 'readyplayerme' ||
+    avatar === 'readyplayerme-full' ||
+    avatar === 'customglb' ||
+    avatar === 'customrpm' ||
+    avatar === 'avatar-configurator');
+
+/** RPM-based 3D avatar view (ContainerAvatarView), including avatar-configurator exports. */
+export const usesRpmAvatarView = (
+  avatar: AvatarMode | string | undefined
+): boolean =>
+  avatar === 'readyplayerme' ||
+  avatar === 'readyplayerme-full' ||
+  avatar === 'customrpm' ||
+  avatar === 'avatar-configurator';

package/src/version.ts

@@ -1,2 +1,2 @@
 // This file is auto-generated. Do not edit manually.
-export const version = '8.41.0';
+export const version = '8.41.2';