@microsoft/omnichannel-chat-widget 1.8.4-main.cbab5fc → 1.8.4-main.cd79f08

package/lib/esm/components/webchatcontainerstateful/webchatcontroller/middlewares/renderingmiddlewares/activities/LazyLoadActivity.js

@@ -43,10 +43,6 @@ import { createTimer } from "../../../../../../common/utils";
 import dispatchCustomEvent from "../../../../../../common/utils/dispatchCustomEvent";
 import SecureEventBus from "../../../../../../common/utils/SecureEventBus";
 
-/*
- * Interface defining the state of a scroll operation
- * Used to track and verify scroll actions for reliability
- */
 /**
  * LazyLoadHandler - Static class managing all lazy loading functionality
  * 
@@ -83,8 +79,10 @@ let LazyLoadHandler = /*#__PURE__*/function () {
     // Temporary disable flag
     // The intersection observer instance
 
-    // Scroll operation state
-    // Current scroll operation tracking
+    // Scroll anchoring state (height-delta approach)
+    // scrollHeight before content loads
+    // scrollTop before content loads
+    // Tracks if the first batch has loaded
     // Prevents concurrent scroll operations (public for event handlers)
 
     // Timeout and queue management
@@ -128,6 +126,7 @@ let LazyLoadHandler = /*#__PURE__*/function () {
     key: "directReset",
     value: function directReset() {
       LazyLoadHandler.resetPending = true;
+      LazyLoadHandler.initialLoadComplete = false; // New session — next batch is an initial load
       LazyLoadHandler.setHasMoreHistoryAvailable(true);
       LazyLoadHandler.unmount();
     }
@@ -431,16 +430,15 @@ let LazyLoadHandler = /*#__PURE__*/function () {
 
     /**
      * Main lazy load trigger handler
-     * 
+     *
      * This is the core method that executes when the trigger element becomes visible.
      * It coordinates the entire lazy loading process:
-     * 
+     *
      * 1. Sets flags to prevent concurrent operations
-     * 2. Dispatches event to fetch more chat history
-     * 3. Waits for content to load
-     * 4. Executes scroll adjustment to maintain user position
-     * 
-     * Timing: Uses 300ms delay to allow content loading before scroll adjustment
+     * 2. Captures scroll state BEFORE content loads (for height-delta anchoring)
+     * 3. Dispatches event to fetch more chat history
+     *
+     * Scroll anchoring is triggered by HISTORY_BATCH_LOADED event (not a blind timeout).
      */
   }, {
     key: "handleLazyLoadTrigger",
@@ -454,138 +452,60 @@ let LazyLoadHandler = /*#__PURE__*/function () {
       LazyLoadHandler.pendingScrollAction = true; // Block new scroll actions
       LazyLoadHandler.paused = true; // Pause intersection observer
 
+      // Capture scroll geometry BEFORE new content loads — used for height-delta anchoring
+      const {
+        container,
+        isScrollable
+      } = LazyLoadHandler.findScrollContainer();
+      if (container && isScrollable) {
+        LazyLoadHandler.preLoadScrollHeight = container.scrollHeight;
+        LazyLoadHandler.preLoadScrollTop = container.scrollTop;
+      }
+      LazyLoadHandler.logLifecycleEvent(TelemetryEvent.LCWLazyLoadTriggerFired, "Lazy load trigger fired — fetching history");
+
       // Dispatch custom event to trigger chat history fetching
-      // This event is handled by other parts of the chat system
       dispatchCustomEvent(ChatWidgetEvents.FETCH_PERSISTENT_CHAT_HISTORY);
-
-      // Wait for content to load before performing scroll adjustment
-      // 200ms provides good balance between responsiveness and content loading
-      const timeoutId = window.setTimeout(() => {
-        LazyLoadHandler.retryTimeouts.delete(timeoutId);
-        LazyLoadHandler.executeReliableScroll();
-      }, 200); // Reduced from 300ms to 200ms for faster response
-      LazyLoadHandler.retryTimeouts.add(timeoutId);
     }
 
     /**
-     * Executes reliable scroll with validation and retry logic
-     * 
-     * This method implements a robust scroll system that:
-     * 1. Finds and validates the scroll container
-     * 2. Calculates target scroll position (current + 35px)
-     * 3. Sets up scroll state for tracking and retries
-     * 4. Initiates the scroll attempt process
-     * 
-     * If no suitable container is found, schedules a retry.
+     * Applies height-delta scroll anchoring after new history content is prepended.
+     *
+     * When content is added above the viewport, the browser keeps scrollTop constant
+     * but the content shifts down — making the viewport drift upward.
+     * Fix: scrollTop = savedScrollTop + (newScrollHeight - savedScrollHeight)
+     * This keeps the user looking at the same content they had before.
      */
   }, {
-    key: "executeReliableScroll",
-    value: function executeReliableScroll() {
-      // Guard: Don't execute scroll if no more history is available
-      if (!LazyLoadHandler.hasMoreHistoryAvailable) {
-        LazyLoadHandler.finishScrollAction();
-        return;
-      }
-
-      // Find container using multiple fallback strategies
+    key: "applyScrollAnchor",
+    value: function applyScrollAnchor() {
       const {
         container,
         isScrollable
       } = LazyLoadHandler.findScrollContainer();
       if (!container || !isScrollable) {
-        LazyLoadHandler.scheduleScrollRetry();
-        return;
-      }
-
-      // Calculate scroll positions
-      const initialScrollTop = container.scrollTop;
-      const targetScrollTop = initialScrollTop + 35; // 35px down to maintain position
-
-      // Set up scroll state for tracking and retries
-      LazyLoadHandler.scrollState = {
-        container,
-        initialScrollTop,
-        targetScrollTop,
-        attemptCount: 0,
-        maxAttempts: 5 // Allow up to 5 retry attempts
-      };
-
-      // Begin the scroll attempt process
-      LazyLoadHandler.attemptScroll();
-    }
-
-    /**
-     * Attempts to perform scroll with verification and retry logic
-     * 
-     * This method implements a sophisticated scroll system:
-     * 
-     * 1. Uses requestAnimationFrame for smooth execution
-     * 2. Performs the scroll operation
-     * 3. Verifies scroll actually occurred (5px tolerance)
-     * 4. Retries with exponential backoff if failed
-     * 5. Continues operation after max attempts
-     * 
-     * The two-frame approach ensures scroll is applied and then verified
-     * after the browser has had time to process the scroll change.
-     */
-  }, {
-    key: "attemptScroll",
-    value: function attemptScroll() {
-      // Guard: Don't attempt scroll if no more history is available
-      if (!LazyLoadHandler.hasMoreHistoryAvailable) {
         LazyLoadHandler.finishScrollAction();
         return;
       }
-      if (!LazyLoadHandler.scrollState) {
-        LazyLoadHandler.finishScrollAction();
-        return;
+      const newScrollHeight = container.scrollHeight;
+      const heightDelta = newScrollHeight - LazyLoadHandler.preLoadScrollHeight;
+      if (heightDelta > 0) {
+        container.scrollTop = LazyLoadHandler.preLoadScrollTop + heightDelta;
       }
-
-      // Extract current scroll state
-      const {
-        container,
-        targetScrollTop,
-        attemptCount,
-        maxAttempts
-      } = LazyLoadHandler.scrollState;
-      LazyLoadHandler.scrollState.attemptCount++;
-
-      // Perform scroll using requestAnimationFrame for smooth execution
-      // Frame 1: Apply the scroll
-      requestAnimationFrame(() => {
-        // Double-check history availability before applying scroll
-        if (!LazyLoadHandler.hasMoreHistoryAvailable) {
-          LazyLoadHandler.finishScrollAction();
-          return;
-        }
-        if (container) {
-          container.scrollTop = targetScrollTop;
-        }
-
-        // Frame 2: Verify scroll occurred after browser has processed the change
-        requestAnimationFrame(() => {
-          // Triple-check history availability before verification
-          if (!LazyLoadHandler.hasMoreHistoryAvailable) {
-            LazyLoadHandler.finishScrollAction();
-            return;
-          }
-          const actualScrollTop = container ? container.scrollTop : 0;
-          const scrollSucceeded = Math.abs(actualScrollTop - targetScrollTop) < 5; // 5px tolerance for success
-
-          if (scrollSucceeded) {
-            LazyLoadHandler.finishScrollAction();
-          } else if (attemptCount < maxAttempts) {
-            // Retry with exponential backoff (100ms * attempt number)
-            const timeoutId = window.setTimeout(() => {
-              LazyLoadHandler.retryTimeouts.delete(timeoutId);
-              LazyLoadHandler.attemptScroll();
-            }, 100 * attemptCount); // Exponential backoff
-            LazyLoadHandler.retryTimeouts.add(timeoutId);
-          } else {
-            LazyLoadHandler.finishScrollAction();
+      try {
+        TelemetryHelper.logActionEvent(LogLevel.INFO, {
+          Event: TelemetryEvent.LCWLazyLoadScrollAnchorApplied,
+          Description: "Scroll anchor applied after history batch",
+          CustomProperties: {
+            heightDelta,
+            preLoadScrollHeight: LazyLoadHandler.preLoadScrollHeight,
+            newScrollHeight,
+            newScrollTop: container.scrollTop
           }
         });
-      });
+      } catch {
+        // Silent fail — don't break scroll anchoring for telemetry issues
+      }
+      LazyLoadHandler.finishScrollAction();
     }
 
     /**
@@ -599,7 +519,6 @@ let LazyLoadHandler = /*#__PURE__*/function () {
     key: "finishScrollAction",
     value: function finishScrollAction() {
       // Clean up scroll tracking state
-      LazyLoadHandler.scrollState = null;
       LazyLoadHandler.pendingScrollAction = false;
 
       // Schedule unpause and reset with delay for content stabilization
@@ -611,33 +530,9 @@ let LazyLoadHandler = /*#__PURE__*/function () {
       LazyLoadHandler.retryTimeouts.add(timeoutId);
     }
 
-    /**
-     * Schedules retry for failed scroll operations
-     * 
-     * Used when scroll container is not available or scrollable.
-     * Provides a longer delay to allow container to become ready.
-     */
-  }, {
-    key: "scheduleScrollRetry",
-    value: function scheduleScrollRetry() {
-      // Don't schedule retry if no more history is available
-      if (!LazyLoadHandler.hasMoreHistoryAvailable) {
-        LazyLoadHandler.finishScrollAction();
-        return;
-      }
-      const timeoutId = window.setTimeout(() => {
-        LazyLoadHandler.retryTimeouts.delete(timeoutId);
-        // Only retry if we're still in a pending scroll action state and have more history
-        if (LazyLoadHandler.pendingScrollAction && LazyLoadHandler.hasMoreHistoryAvailable) {
-          LazyLoadHandler.executeReliableScroll();
-        }
-      }, 1000); // 1 second delay for container readiness
-      LazyLoadHandler.retryTimeouts.add(timeoutId);
-    }
-
     /**
      * Schedules observer reset for next lazy load cycle
-     * 
+     *
      * After a lazy load operation completes, the observer needs to be reset
      * to detect the next time the user scrolls to the top.
      */
@@ -755,7 +650,7 @@ let LazyLoadHandler = /*#__PURE__*/function () {
   }, {
     key: "moveScrollDown",
     value: function moveScrollDown() {
-      LazyLoadHandler.executeReliableScroll();
+      LazyLoadHandler.applyScrollAnchor();
     }
 
     /**
@@ -795,6 +690,9 @@ let LazyLoadHandler = /*#__PURE__*/function () {
   }, {
     key: "handleNoMoreHistoryAvailable",
     value: function handleNoMoreHistoryAvailable() {
+      if (!LazyLoadHandler.initialLoadComplete) {
+        LazyLoadHandler.initialLoadComplete = true;
+      }
       LazyLoadHandler.setHasMoreHistoryAvailable(false);
       LazyLoadHandler.paused = true;
       LazyLoadHandler.pendingScrollAction = false; // Reset this to prevent stuck states
@@ -812,9 +710,6 @@ let LazyLoadHandler = /*#__PURE__*/function () {
         LazyLoadHandler.observer.disconnect();
         LazyLoadHandler.observer = null;
       }
-
-      // Clear scroll state
-      LazyLoadHandler.scrollState = null;
     }
 
     /**
@@ -836,6 +731,8 @@ let LazyLoadHandler = /*#__PURE__*/function () {
       LazyLoadHandler.setHasMoreHistoryAvailable(true); // Reset history availability flag
       LazyLoadHandler.initializationQueue = []; // Clear action queue
       LazyLoadHandler.resetPending = false; // Clear pending reset flag
+      // Note: initialLoadComplete is NOT reset here — it persists across observer cycles.
+      // It's only reset on new chat sessions (directReset / PersistentConversationReset).
 
       // Reinitialize with faster timing for better responsiveness
       const timeoutId = window.setTimeout(() => {
@@ -875,8 +772,9 @@ let LazyLoadHandler = /*#__PURE__*/function () {
       LazyLoadHandler.initialized = false;
       LazyLoadHandler.paused = false;
       LazyLoadHandler.pendingScrollAction = false;
-      LazyLoadHandler.scrollState = null;
       LazyLoadHandler.isReady = false;
+      LazyLoadHandler.preLoadScrollHeight = 0;
+      LazyLoadHandler.preLoadScrollTop = 0;
       LazyLoadHandler.initializationQueue = [];
       // Note: Don't reset resetPending here as it needs to persist across unmount/mount cycles
     }
@@ -925,7 +823,9 @@ _defineProperty(LazyLoadHandler, "targetId", "lazy-load-trigger-element");
 _defineProperty(LazyLoadHandler, "initialized", false);
 _defineProperty(LazyLoadHandler, "paused", false);
 _defineProperty(LazyLoadHandler, "observer", null);
-_defineProperty(LazyLoadHandler, "scrollState", null);
+_defineProperty(LazyLoadHandler, "preLoadScrollHeight", 0);
+_defineProperty(LazyLoadHandler, "preLoadScrollTop", 0);
+_defineProperty(LazyLoadHandler, "initialLoadComplete", false);
 _defineProperty(LazyLoadHandler, "pendingScrollAction", false);
 _defineProperty(LazyLoadHandler, "retryTimeouts", new Set());
 _defineProperty(LazyLoadHandler, "resetPending", false);
@@ -933,6 +833,7 @@ _defineProperty(LazyLoadHandler, "initTimer", createTimer());
 _defineProperty(LazyLoadHandler, "resetEventListener", BroadcastService.getMessageByEventName(BroadcastEvent.PersistentConversationReset).subscribe(() => {
   LazyLoadHandler.logLifecycleEvent(TelemetryEvent.LCWLazyLoadReset, "LazyLoad reset triggered");
   LazyLoadHandler.resetPending = true;
+  LazyLoadHandler.initialLoadComplete = false; // New session — next batch is an initial load
   LazyLoadHandler.setHasMoreHistoryAvailable(true); // Reset this immediately so activityMiddleware doesn't block rendering
   LazyLoadHandler.unmount(); // Clean up current state immediately
 }));
@@ -956,19 +857,11 @@ const LazyLoadActivity = props => {
       setHasMoreHistory(false);
     };
 
-    // Event listener for HISTORY_LOAD_ERROR - hides banner temporarily without disabling future loads
+    // Event listener for HISTORY_LOAD_ERROR — dismiss banner on any error
     const handleHistoryLoadError = () => {
-      // Temporarily hide the banner by pausing, but keep hasMoreHistory true to allow retry
-      LazyLoadHandler.paused = true;
-      LazyLoadHandler.pendingScrollAction = false;
-
-      // Re-enable after a delay to allow retry on next scroll
-      // Note: This timeout is intentionally not tracked as it's scoped to the component lifecycle
-      window.setTimeout(() => {
-        LazyLoadHandler.paused = false;
-      }, 2000); // 2 second delay before allowing retry
-
-      LazyLoadHandler.logLifecycleEvent(TelemetryEvent.LCWLazyLoadHistoryError, "History load error - will retry on next scroll");
+      LazyLoadHandler.logLifecycleEvent(TelemetryEvent.LCWLazyLoadHistoryError, `History load error - dismissing banner. initialLoadComplete: ${LazyLoadHandler.initialLoadComplete}`);
+      LazyLoadHandler.handleNoMoreHistoryAvailable();
+      setHasMoreHistory(false);
     };
 
     // Event listener for PersistentConversationReset to sync React state
@@ -979,6 +872,97 @@ const LazyLoadActivity = props => {
       setHasMoreHistory(true);
     };
 
+    // Event listener for HISTORY_BATCH_LOADED — applies scroll anchoring after batch is processed
+    const handleBatchLoaded = () => {
+      LazyLoadHandler.logLifecycleEvent(TelemetryEvent.LCWLazyLoadBatchReceived, `Batch received — initialLoadComplete: ${LazyLoadHandler.initialLoadComplete}`);
+      if (!LazyLoadHandler.initialLoadComplete) {
+        // Initial load: use the same height-delta scroll anchoring as subsequent loads.
+        // This keeps the user at their current position while history is prepended above.
+        LazyLoadHandler.initialLoadComplete = true;
+        LazyLoadHandler.pendingScrollAction = false;
+        try {
+          const {
+            container
+          } = LazyLoadHandler.findScrollContainer();
+          if (container) {
+            const savedScrollTop = container.scrollTop;
+            const savedScrollHeight = container.scrollHeight;
+
+            // Freeze viewport while React renders new content above
+            container.style.overflow = "hidden";
+            let framesRemaining = 6;
+            const anchorScroll = () => {
+              const newScrollHeight = container.scrollHeight;
+              const heightDelta = newScrollHeight - savedScrollHeight;
+              if (heightDelta > 0) {
+                container.scrollTop = savedScrollTop + heightDelta;
+              }
+              framesRemaining--;
+              if (framesRemaining > 0) {
+                requestAnimationFrame(anchorScroll);
+              } else {
+                container.style.overflow = "";
+                LazyLoadHandler.paused = false;
+                LazyLoadHandler.scheduleReset();
+              }
+            };
+            requestAnimationFrame(anchorScroll);
+          } else {
+            LazyLoadHandler.paused = false;
+            LazyLoadHandler.scheduleReset();
+          }
+        } catch {
+          LazyLoadHandler.paused = false;
+          LazyLoadHandler.scheduleReset();
+        }
+        LazyLoadHandler.logLifecycleEvent(TelemetryEvent.LCWLazyLoadInitialLoadComplete, "Initial history load complete — scroll anchored to current position");
+        return;
+      }
+      // Pagination: apply height-delta scroll anchoring repeatedly across frames.
+      //
+      // react-scroll-to-bottom uses useEffect + rAF to auto-scroll to bottom when new content
+      // arrives. This fires at unpredictable timing relative to our callbacks, so a single
+      // scrollTop assignment gets overridden intermittently.
+      //
+      // Fix: re-apply the correct scrollTop across several animation frames. After a few frames,
+      // react-scroll-to-bottom detects the user is NOT at the bottom (sticky=false) and stops
+      // auto-scrolling. We also temporarily freeze overflow to prevent visible flicker.
+      try {
+        const {
+          container
+        } = LazyLoadHandler.findScrollContainer();
+        if (container) {
+          // Re-capture scrollTop — user may have scrolled during the API fetch
+          const savedScrollTop = container.scrollTop;
+          const savedScrollHeight = LazyLoadHandler.preLoadScrollHeight;
+
+          // Freeze viewport to prevent visible flicker between competing scroll positions
+          container.style.overflow = "hidden";
+          let framesRemaining = 6; // ~100ms at 60fps — enough for react-scroll-to-bottom to settle
+          const anchorScroll = () => {
+            const newScrollHeight = container.scrollHeight;
+            const heightDelta = newScrollHeight - savedScrollHeight;
+            if (heightDelta > 0) {
+              container.scrollTop = savedScrollTop + heightDelta;
+            }
+            framesRemaining--;
+            if (framesRemaining > 0) {
+              requestAnimationFrame(anchorScroll);
+            } else {
+              // All frames applied — restore overflow and finish
+              container.style.overflow = "";
+              LazyLoadHandler.finishScrollAction();
+            }
+          };
+          requestAnimationFrame(anchorScroll);
+        } else {
+          LazyLoadHandler.finishScrollAction();
+        }
+      } catch {
+        LazyLoadHandler.finishScrollAction();
+      }
+    };
+
     // Add secure event listener for no more history signal
     const eventBus = SecureEventBus.getInstance();
     const unsubscribeNoMoreHistory = eventBus.subscribe(ChatWidgetEvents.NO_MORE_HISTORY_AVAILABLE, handleNoMoreHistory);
@@ -986,6 +970,9 @@ const LazyLoadActivity = props => {
     // Add event listener for history load errors
     const unsubscribeHistoryError = eventBus.subscribe(ChatWidgetEvents.HISTORY_LOAD_ERROR, handleHistoryLoadError);
 
+    // Add event listener for history batch loaded
+    const unsubscribeBatchLoaded = eventBus.subscribe(ChatWidgetEvents.HISTORY_BATCH_LOADED, handleBatchLoaded);
+
     // Add event listener for persistent conversation reset
     const resetSubscription = BroadcastService.getMessageByEventName(BroadcastEvent.PersistentConversationReset).subscribe(handlePersistentConversationReset);
 
@@ -1003,6 +990,7 @@ const LazyLoadActivity = props => {
       return () => {
         unsubscribeNoMoreHistory();
         unsubscribeHistoryError();
+        unsubscribeBatchLoaded();
         resetSubscription.unsubscribe();
       };
     }
@@ -1056,6 +1044,7 @@ const LazyLoadActivity = props => {
       // Remove event listeners
       unsubscribeNoMoreHistory();
       unsubscribeHistoryError();
+      unsubscribeBatchLoaded();
       resetSubscription.unsubscribe();
       if (container) {
         container.removeEventListener("scroll", handleScroll);

package/lib/esm/components/webchatcontainerstateful/webchatcontroller/middlewares/renderingmiddlewares/activityMiddleware.js

@@ -124,7 +124,7 @@ export const createActivityMiddleware = (renderMarkdown, systemMessageStyleProps
     if (isTagIncluded(card, Constants.conversationDividerTag)) {
       const conversationDividerLabel = (localizedTexts === null || localizedTexts === void 0 ? void 0 : localizedTexts.CONVERSATION_DIVIDER_ARIA_LABEL) || defaultMiddlewareLocalizedTexts.CONVERSATION_DIVIDER_ARIA_LABEL;
       // Pass the computed localized text to the divider component
-      return /*#__PURE__*/React.createElement(ConversationDividerActivity, {
+      return () => /*#__PURE__*/React.createElement(ConversationDividerActivity, {
         dividerActivityAriaLabel: conversationDividerLabel
       });
     }

package/lib/esm/components/webchatcontainerstateful/webchatcontroller/middlewares/renderingmiddlewares/timestamps/NotDeliveredTimestamp.js

@@ -1,3 +1,5 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
 import React, { useCallback, useEffect, useRef } from "react";
 import { KeyCodes } from "../../../../../../common/KeyCodes";
 import { Stack } from "@fluentui/react";

package/lib/esm/components/webchatcontainerstateful/webchatcontroller/middlewares/storemiddlewares/channelDataMiddleware.js

@@ -7,6 +7,7 @@
 import { Constants } from "../../../../../common/Constants";
 import { DeliveryMode } from "@microsoft/omnichannel-chat-sdk";
 import { WebChatActionType } from "../../enums/WebChatActionType";
+
 // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unused-vars
 const channelDataMiddleware = addConversationalSurveyTagsCallback => _ref => {
   let {

package/lib/esm/contexts/common/LiveChatWidgetActionType.js

@@ -50,4 +50,5 @@ export let LiveChatWidgetActionType;
   LiveChatWidgetActionType[LiveChatWidgetActionType["SET_CONVERSATIONAL_SURVEY_DISPLAY"] = 47] = "SET_CONVERSATIONAL_SURVEY_DISPLAY";
   LiveChatWidgetActionType[LiveChatWidgetActionType["GET_IN_MEMORY_STATE"] = 48] = "GET_IN_MEMORY_STATE";
   LiveChatWidgetActionType[LiveChatWidgetActionType["SET_BOT_AVATAR_INITIALS"] = 49] = "SET_BOT_AVATAR_INITIALS";
+  LiveChatWidgetActionType[LiveChatWidgetActionType["SET_USER_AUTHENTICATED"] = 50] = "SET_USER_AUTHENTICATED";
 })(LiveChatWidgetActionType || (LiveChatWidgetActionType = {}));

package/lib/esm/contexts/common/LiveChatWidgetContextInitialState.js

@@ -38,6 +38,10 @@ export const getLiveChatWidgetContextInitialState = props => {
     if (!initialStateFromCache.domainStates.botAvatarInitials) {
       initialStateFromCache.domainStates.botAvatarInitials = defaultWebChatStyles.botAvatarInitials;
     }
+    // Default isUserAuthenticated to false if not present in cache
+    if (initialStateFromCache.appStates.isUserAuthenticated === undefined) {
+      initialStateFromCache.appStates.isUserAuthenticated = false;
+    }
     return initialStateFromCache;
   }
   const LiveChatWidgetContextInitialState = {
@@ -87,7 +91,8 @@ export const getLiveChatWidgetContextInitialState = props => {
       selectedSurveyMode: null,
       postChatParticipantType: undefined,
       isConversationalSurvey: false,
-      isConversationalSurveyEnabled: false
+      isConversationalSurveyEnabled: false,
+      isUserAuthenticated: false
     },
     uiStates: {
       showConfirmationPane: false,

package/lib/esm/contexts/createReducer.js

@@ -708,6 +708,21 @@ const reducer = (state, action) => {
           isConversationalSurvey: action.payload
         }
       };
+    case LiveChatWidgetActionType.SET_USER_AUTHENTICATED:
+      inMemory = {
+        ...inMemory,
+        appStates: {
+          ...inMemory.appStates,
+          isUserAuthenticated: action.payload
+        }
+      };
+      return {
+        ...state,
+        appStates: {
+          ...state.appStates,
+          isUserAuthenticated: action.payload
+        }
+      };
     case LiveChatWidgetActionType.GET_IN_MEMORY_STATE:
       return inMemory;
     default:

package/lib/esm/controller/componentController.js

@@ -1,4 +1,5 @@
 import { ConversationState } from "../contexts/common/ConversationState";
+import { shouldLoadPersistentChatHistory } from "../components/livechatwidget/common/liveChatConfigUtils";
 export const shouldShowChatButton = state => {
   var _state$appStates;
   return (state.appStates.isMinimized || state.appStates.conversationState === ConversationState.Closed) && (state === null || state === void 0 ? void 0 : (_state$appStates = state.appStates) === null || _state$appStates === void 0 ? void 0 : _state$appStates.hideStartChatButton) === false; // Do not show chat button in case of popout
@@ -17,7 +18,18 @@ export const shouldShowEmailTranscriptPane = state => {
   return state.uiStates.showEmailTranscriptPane;
 };
 export const shouldShowWebChatContainer = state => {
-  return !state.appStates.isMinimized && state.appStates.conversationState === ConversationState.Active || state.appStates.conversationState === ConversationState.InActive || state.appStates.conversationState === ConversationState.Postchat && state.appStates.isConversationalSurveyEnabled && state.appStates.isConversationalSurvey;
+  var _state$domainStates;
+  const extendedChatConfig = state === null || state === void 0 ? void 0 : (_state$domainStates = state.domainStates) === null || _state$domainStates === void 0 ? void 0 : _state$domainStates.liveChatConfig;
+  const persistentHistoryEnabled = shouldLoadPersistentChatHistory(extendedChatConfig);
+  const isActiveOrInactive = state.appStates.conversationState === ConversationState.Active || state.appStates.conversationState === ConversationState.InActive;
+  const isPostchatSurvey = state.appStates.conversationState === ConversationState.Postchat && state.appStates.isConversationalSurveyEnabled && state.appStates.isConversationalSurvey;
+  if (persistentHistoryEnabled) {
+    // Keep WebChat in DOM even when minimized (CSS hides it via visibility)
+    // This preserves scroll position across minimize/maximize cycles
+    return isActiveOrInactive || isPostchatSurvey;
+  }
+  // Original behavior - hide WebChat when minimized
+  return !state.appStates.isMinimized && (isActiveOrInactive || isPostchatSurvey);
 };
 export const shouldShowLoadingPane = state => {
   return !state.appStates.isMinimized && state.appStates.conversationState === ConversationState.Loading;

package/lib/esm/plugins/newMessageEventHandler.js

@@ -14,6 +14,8 @@ export const createOnNewAdapterActivityHandler = (chatId, userId, startTime) =>
   // this is a workaround for the fact that we dont have a way to identify if a message is history or new, and it will provide consistency across different scenarios
 
   let isHistoryMessageReceivedEventRaised = false;
+  let isInQueue = false;
+  let agentJoinLogged = false;
   const onNewAdapterActivityHandler = activity => {
     raiseMessageEvent(activity);
   };
@@ -35,9 +37,14 @@ export const createOnNewAdapterActivityHandler = (chatId, userId, startTime) =>
     });
   };
   const systemMessageStrategy = activity => {
-    var _TelemetryManager$Int3;
+    var _activity$channelData, _activity$channelData2, _TelemetryManager$Int3;
     const payload = buildMessagePayload(activity, userId);
     payload.messageType = Constants.systemMessageTag;
+
+    // Track queue entry for agent-join detection
+    if (activity !== null && activity !== void 0 && (_activity$channelData = activity.channelData) !== null && _activity$channelData !== void 0 && (_activity$channelData2 = _activity$channelData.tags) !== null && _activity$channelData2 !== void 0 && _activity$channelData2.includes(Constants.queuePositionMessageTag)) {
+      isInQueue = true;
+    }
     if (isHistoryMessage(activity, startTime)) {
       var _TelemetryManager$Int2;
       historyMessageStrategy(polyfillMessagePayloadForEvent(activity, payload, (_TelemetryManager$Int2 = TelemetryManager.InternalTelemetryData) === null || _TelemetryManager$Int2 === void 0 ? void 0 : _TelemetryManager$Int2.conversationId));
@@ -70,11 +77,11 @@ export const createOnNewAdapterActivityHandler = (chatId, userId, startTime) =>
     }
   };
   const isValidMessage = activity => {
-    var _activity$channelData, _activity$channelData2, _activity$channelData3;
+    var _activity$channelData3, _activity$channelData4, _activity$channelData5;
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const messageHasNoText = !(activity !== null && activity !== void 0 && activity.text);
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const messageHasNoTags = !(activity !== null && activity !== void 0 && activity.channelData) || !(activity !== null && activity !== void 0 && (_activity$channelData = activity.channelData) !== null && _activity$channelData !== void 0 && _activity$channelData.tags) || (activity === null || activity === void 0 ? void 0 : (_activity$channelData2 = activity.channelData) === null || _activity$channelData2 === void 0 ? void 0 : (_activity$channelData3 = _activity$channelData2.tags) === null || _activity$channelData3 === void 0 ? void 0 : _activity$channelData3.length) === 0;
+    const messageHasNoTags = !(activity !== null && activity !== void 0 && activity.channelData) || !(activity !== null && activity !== void 0 && (_activity$channelData3 = activity.channelData) !== null && _activity$channelData3 !== void 0 && _activity$channelData3.tags) || (activity === null || activity === void 0 ? void 0 : (_activity$channelData4 = activity.channelData) === null || _activity$channelData4 === void 0 ? void 0 : (_activity$channelData5 = _activity$channelData4.tags) === null || _activity$channelData5 === void 0 ? void 0 : _activity$channelData5.length) === 0;
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const messageHasNoAttachments = !(activity !== null && activity !== void 0 && activity.attachments) || (activity === null || activity === void 0 ? void 0 : activity.attachments.length) === 0;
     if (messageHasNoTags && messageHasNoText && messageHasNoAttachments) {
@@ -96,6 +103,16 @@ export const createOnNewAdapterActivityHandler = (chatId, userId, startTime) =>
       historyMessageStrategy(polyfillMessagePayloadForEvent(activity, payload, (_TelemetryManager$Int4 = TelemetryManager.InternalTelemetryData) === null || _TelemetryManager$Int4 === void 0 ? void 0 : _TelemetryManager$Int4.conversationId));
       return;
     }
+
+    // Log agent joining when first non-history message is received after queue
+    if (isInQueue && !agentJoinLogged) {
+      agentJoinLogged = true;
+      isInQueue = false;
+      TelemetryHelper.logActionEvent(LogLevel.INFO, {
+        Event: TelemetryEvent.AgentJoinedConversation,
+        Description: "First message received from agent after queue"
+      });
+    }
     firstResponseLatencyTracker.stopClock(payload);
     const newMessageReceivedEvent = {
       eventName: BroadcastEvent.NewMessageReceived,

package/lib/types/common/Constants.d.ts

@@ -58,6 +58,8 @@ export declare class Constants {
     static readonly videoMediaRegex: RegExp;
     static readonly chromeSupportedInlineMediaRegex: RegExp;
     static readonly firefoxSupportedInlineMediaRegex: RegExp;
+    static readonly AdaptiveCardType = "adaptivecard";
+    static readonly SuggestedActionsType = "suggestedactions";
     static readonly CallAdded = "callAdded";
     static readonly LocalVideoStreamAdded = "localVideoStreamAdded";
     static readonly LocalVideoStreamRemoved = "localVideoStreamRemoved";