@microsoft/omnichannel-chat-widget 1.8.2-main.5199342 → 1.8.2-main.d82a79b

package/lib/esm/firstresponselatency/FirstMessageTrackerFromBot.js

@@ -7,54 +7,96 @@ import { createTrackingMessage } from "./util";
 //  with different timeline, therefore this is a functional approach to track the events, instead of a class based approach
 export const createTrackingForFirstMessage = () => {
   // Reset the tracking variables
-  let startTracking = false;
-  let stopTracking = false;
+  let isTracking = false;
   let startTime = 0;
   let stopTime = 0;
-  let stopTrackingMessage;
+  let stopTrackingMessage = null;
   let flag = false;
+  let trackingTimeoutId;
+
+  /**
+   * Checks if the message payload is from a valid sender (not an agent).
+   * Returns false if the message is from an agent (tag 'public'), true otherwise.
+   */
   const isMessageFromValidSender = payload => {
     var _payload$tags;
-    // agent scenario
     if (payload !== null && payload !== void 0 && (_payload$tags = payload.tags) !== null && _payload$tags !== void 0 && _payload$tags.includes("public")) {
       return false;
     }
     return true;
   };
+
+  /**
+   * Listener for widget load completion event.
+   * Starts tracking the time for the first bot message after widget loads.
+   * Sets a 5-second timeout to auto-reset if no bot message is received.
+   */
   const widgetLoadListener = BroadcastService.getMessageByEventName(TelemetryEvent.WidgetLoadComplete).subscribe(() => {
-    if (startTracking) return;
-    startTracking = true;
+    if (isTracking) return;
+    isTracking = true;
     startTime = new Date().getTime();
+    // Start a 5-second timeout to auto-stop tracking if not stopped
+    if (trackingTimeoutId) {
+      clearTimeout(trackingTimeoutId);
+    }
+    trackingTimeoutId = setTimeout(() => {
+      if (isTracking) {
+        // Reset state and disengage, no telemetry or FMLTrackingCompleted
+        isTracking = false;
+        startTime = 0;
+        stopTime = 0;
+        stopTrackingMessage = null;
+        trackingTimeoutId = undefined;
+        disconnectListener();
+      }
+    }, 10000); //adding more time since it meassures from widget load complete till message received
   });
+
+  /**
+   * Listener for new bot message event.
+   * If a valid bot message is received, stops tracking and logs telemetry.
+   * If the message is invalid, resets and disengages listeners.
+   */
   const newMessageListener = BroadcastService.getMessageByEventName(BroadcastEvent.NewMessageReceived).subscribe(message => {
     const payload = message.payload;
-
-    // we only care for bot, so we need to check if the message is from the bot
-    // pending to add typing message indicator signal detection
-
-    if (isMessageFromValidSender(payload)) {
-      if (startTracking && !stopTracking) {
-        stopTime = new Date().getTime();
-        const elapsedTime = stopTime - startTime;
-        stopTracking = true;
-        stopTrackingMessage = createTrackingMessage(payload, "botMessage");
-        notifyFMLTrackingCompleted();
-        TelemetryHelper.logActionEvent(LogLevel.INFO, {
-          Event: TelemetryEvent.BotFirstMessageLapTrack,
-          Description: "First Message from Bot latency tracking",
-          CustomProperties: {
-            elapsedTime,
-            widgetLoadedAt: startTime,
-            botMessage: stopTrackingMessage
-          }
-        });
+    if (!isMessageFromValidSender(payload)) {
+      // If not valid, stop everything and clean up
+      isTracking = false;
+      if (trackingTimeoutId) {
+        clearTimeout(trackingTimeoutId);
+        trackingTimeoutId = undefined;
       }
+      disconnectListener();
+      return;
+    }
+    if (isTracking) {
+      isTracking = false;
+      // Clear the timeout if it exists
+      if (trackingTimeoutId) {
+        clearTimeout(trackingTimeoutId);
+        trackingTimeoutId = undefined;
+      }
+      stopTime = new Date().getTime();
+      const elapsedTime = stopTime - startTime;
+      stopTrackingMessage = createTrackingMessage(payload, "botMessage");
+      notifyFMLTrackingCompleted();
+      TelemetryHelper.logActionEvent(LogLevel.INFO, {
+        Event: TelemetryEvent.BotFirstMessageLapTrack,
+        Description: "First Message from Bot latency tracking",
+        CustomProperties: {
+          elapsedTime,
+          widgetLoadedAt: startTime,
+          botMessage: stopTrackingMessage
+        }
+      });
+      disconnectListener();
     }
-
-    // this track only first message, if coming from the bot or not
-    // the only difference is that it logs only those from bot
-    disconnectListener();
   });
+
+  /**
+   * Notifies that FML (First Message Latency) tracking is completed.
+   * Retries sending the completion event until acknowledged.
+   */
   const notifyFMLTrackingCompleted = () => {
     ackListener();
     // Retry sending until flag is true, but do not block the main thread
@@ -69,6 +111,11 @@ export const createTrackingForFirstMessage = () => {
       }
     }, 100);
   };
+
+  /**
+   * Listener for FMLTrackingCompletedAck event.
+   * Sets the flag to true when acknowledgment is received.
+   */
   const ackListener = () => {
     const listen = BroadcastService.getMessageByEventName(BroadcastEvent.FMLTrackingCompletedAck).subscribe(() => {
       flag = true;
@@ -78,22 +125,32 @@ export const createTrackingForFirstMessage = () => {
 
   // Rehydrate message is received when the widget is reloaded, this is to ensure that we are not tracking messages that are not part of the current conversation
   // No need to keep listerning for tracking, enforcing disconnection for the listners
+  /**
+   * Listener for widget rehydration event.
+   * Resets tracking and disconnects listeners when widget is reloaded.
+   */
   const rehydrateListener = BroadcastService.getMessageByEventName(TelemetryEvent.RehydrateMessageReceived).subscribe(() => {
-    startTracking = false;
-    stopTracking = false;
+    isTracking = false;
     disconnectListener();
   });
 
   // Rehydrate message is received when the widget is reloaded, this is to ensure that we are not tracking messages that are not part of the current conversation
   // No need to keep listerning for tracking, enforcing disconnection for the listners
+  /**
+   * Listener for history message event.
+   * Resets tracking and disconnects listeners when history is loaded.
+   */
   const historyListener = BroadcastService.getMessageByEventName(BroadcastEvent.HistoryMessageReceived).subscribe(() => {
-    startTracking = false;
-    stopTracking = false;
+    isTracking = false;
     disconnectListener();
   });
+
+  /**
+   * Listener for network disconnection event.
+   * Resets tracking, disconnects listeners, and logs a telemetry error.
+   */
   const offlineNetworkListener = BroadcastService.getMessageByEventName(TelemetryEvent.NetworkDisconnected).subscribe(() => {
-    startTracking = false;
-    stopTracking = false;
+    isTracking = false;
     disconnectListener();
     TelemetryHelper.logActionEvent(LogLevel.INFO, {
       Event: TelemetryEvent.BotFirstMessageLapTrackError,
@@ -102,7 +159,15 @@ export const createTrackingForFirstMessage = () => {
   });
 
   // this is to ensure that we are not tracking messages that are not part of the current conversation
+  /**
+   * Disconnects all listeners and clears the tracking timeout.
+   * Used for cleanup when tracking is stopped or reset.
+   */
   const disconnectListener = () => {
+    if (trackingTimeoutId) {
+      clearTimeout(trackingTimeoutId);
+      trackingTimeoutId = undefined;
+    }
     historyListener.unsubscribe();
     rehydrateListener.unsubscribe();
     newMessageListener.unsubscribe();

package/lib/esm/firstresponselatency/FirstResponseLatencyTracker.js

@@ -11,14 +11,13 @@ export let FirstResponseLatencyTracker = /*#__PURE__*/function () {
   function FirstResponseLatencyTracker() {
     _classCallCheck(this, FirstResponseLatencyTracker);
     _defineProperty(this, "isABotConversation", false);
-    _defineProperty(this, "isStarted", false);
-    _defineProperty(this, "isEnded", false);
+    _defineProperty(this, "isTracking", false);
     _defineProperty(this, "startTrackingMessage", void 0);
     _defineProperty(this, "stopTrackingMessage", void 0);
     _defineProperty(this, "isReady", false);
+    _defineProperty(this, "trackingTimeoutId", void 0);
     _defineProperty(this, "offlineNetworkListener", BroadcastService.getMessageByEventName(TelemetryEvent.NetworkDisconnected).subscribe(() => {
-      this.isStarted = false;
-      this.isEnded = false;
+      this.isTracking = false;
       TelemetryHelper.logActionEvent(LogLevel.INFO, {
         Event: TelemetryEvent.MessageStopLapTrackError,
         Description: "Tracker Stopped due to network disconnection"
@@ -66,7 +65,7 @@ export let FirstResponseLatencyTracker = /*#__PURE__*/function () {
     value: function startTracking(payload) {
       if (!this.isReady) return;
       //  this prevents to initiate tracking for multiple incoming messages
-      if (this.isStarted) {
+      if (this.isTracking) {
         return;
       }
       // this is to ensure we track only messages where bot is engaged
@@ -74,10 +73,24 @@ export let FirstResponseLatencyTracker = /*#__PURE__*/function () {
         return;
       }
       // control of states to prevent clashing of messages
-      this.isStarted = true;
-      this.isEnded = false;
+      this.isTracking = true;
       // The idea  of using types is to enrich telemetry data 
       this.startTrackingMessage = this.createTrackingMessage(payload, "userMessage");
+
+      // Start a 5-second timeout to auto-stop tracking if not stopped
+      if (this.trackingTimeoutId) {
+        clearTimeout(this.trackingTimeoutId);
+      }
+      this.trackingTimeoutId = setTimeout(() => {
+        // this means the start process is in progress, but the end wasn't called within the time limit
+        if (this.isTracking) {
+          // Reset state variables and skip stopTracking
+          this.isTracking = false;
+          this.startTrackingMessage = undefined;
+          this.stopTrackingMessage = undefined;
+          this.trackingTimeoutId = undefined;
+        }
+      }, 5000);
     }
   }, {
     key: "handleAgentMessage",
@@ -93,13 +106,16 @@ export let FirstResponseLatencyTracker = /*#__PURE__*/function () {
     value: function stopTracking(payload) {
       var _this$stopTrackingMes, _this$startTrackingMe;
       // this prevents execution for multiple incoming messages from the bot.
-      if (this.isEnded && !this.isStarted) {
+      if (!this.isTracking) {
         return;
       }
-
+      // Clear the timeout if it exists
+      if (this.trackingTimeoutId) {
+        clearTimeout(this.trackingTimeoutId);
+        this.trackingTimeoutId = undefined;
+      }
       // control of states to prevent clashing of messages
-      this.isEnded = true;
-      this.isStarted = false;
+      this.isTracking = false;
 
       // The idea  of using types is to enrich telemetry data 
       this.stopTrackingMessage = this.createTrackingMessage(payload, "botMessage");
@@ -154,12 +170,16 @@ export let FirstResponseLatencyTracker = /*#__PURE__*/function () {
         if (!payload || !payload.Id) {
           throw new Error("Invalid payload");
         }
-        if (!this.isMessageFromValidSender(payload)) return;
-        if (this.isABotConversation && this.isStarted) {
+
+        // Only allow stopTracking if sender is valid and tracking is active
+        if (!this.isMessageFromValidSender(payload)) {
+          // Do not change isTracking or stopTrackingMessage
+          return;
+        }
+        if (this.isABotConversation && this.isTracking) {
           this.stopTracking(payload);
         }
       } catch (e) {
-        console.error("FRL : error while trying to stop the tracker", e);
         TelemetryHelper.logActionEvent(LogLevel.ERROR, {
           Event: TelemetryEvent.MessageStopLapTrackError,
           Description: "Error while stopping the clock",
@@ -168,11 +188,6 @@ export let FirstResponseLatencyTracker = /*#__PURE__*/function () {
             payload: payload
           }
         });
-        //reset state
-        this.startTrackingMessage = undefined;
-        this.stopTrackingMessage = undefined;
-        this.isStarted = false;
-        this.isEnded = false;
       }
     }
   }, {
@@ -180,10 +195,13 @@ export let FirstResponseLatencyTracker = /*#__PURE__*/function () {
     value: function deregister() {
       // Reset State
       this.isABotConversation = false;
-      this.isStarted = false;
-      this.isEnded = false;
+      this.isTracking = false;
       this.startTrackingMessage = undefined;
       this.stopTrackingMessage = undefined;
+      if (this.trackingTimeoutId) {
+        clearTimeout(this.trackingTimeoutId);
+        this.trackingTimeoutId = undefined;
+      }
       this.offlineNetworkListener.unsubscribe();
       this.fmltrackingListener.unsubscribe();
       this.rehydrateListener.unsubscribe();

package/lib/esm/firstresponselatency/util.js

@@ -1,38 +1,66 @@
 import { ScenarioType } from "./Constants";
 import { Constants } from "../common/Constants";
+const DELTA_WITHIN_LIMITS_IN_MS = 250;
+
+/**
+ * Determines whether a given activity is a historical message.
+ * 
+ * This function checks if the activity is a message type and uses a combination
+ * of legacy tags and timestamp-based logic to determine if the message is historical.
+ * 
+ * @param {IActivity} activity - The activity object to evaluate.
+ * @param {number} startTime - The start time (in milliseconds since epoch) to compare against.
+ * @returns {boolean} - Returns true if the activity is a historical message, false otherwise.
+ * 
+ * Logic:
+ * - If the activity type is not a message, it is not historical.
+ * - If the activity contains a legacy history message tag, it is considered historical.
+ * - Otherwise, the function extracts a timestamp from the activity ID using `extractTimestampFromId`.
+ *   - If the ID is valid and the timestamp is older than the start time, the message is historical.
+ */
 export const isHistoryMessage = (activity, startTime) => {
-  try {
-    if ((activity === null || activity === void 0 ? void 0 : activity.type) === Constants.message) {
-      var _activity$channelData, _activity$channelData2;
-      // this is an old piece of code, probably no longer relevant
-      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.historyMessageTag)) return true;
+  var _activity$channelData;
+  // Only process message activities
+  if ((activity === null || activity === void 0 ? void 0 : activity.type) !== Constants.message) {
+    return false;
+  }
 
-      // Id is an epoch time in milliseconds , in utc format, for some reason is in a string format
-      if (activity !== null && activity !== void 0 && activity.id) {
-        /// activity.id is an string that contains epoch time in milliseconds
-        const activityId = parseInt(activity === null || activity === void 0 ? void 0 : activity.id);
+  // Prioritize legacy history tag
+  if (activity !== null && activity !== void 0 && (_activity$channelData = activity.channelData) !== null && _activity$channelData !== void 0 && _activity$channelData.tags && activity.channelData.tags.includes(Constants.historyMessageTag)) {
+    return true;
+  }
+  const activityId = extractTimestampFromId(activity);
+  const isValidId = !isNaN(activityId) && activityId > 0;
+  const difference = startTime - activityId;
+  // Only consider historical if activityId < startTime and difference >= DELTA_WITHIN_LIMITS_IN_MS
+  const isOlderThanStartTime = activityId < startTime && difference >= DELTA_WITHIN_LIMITS_IN_MS;
+  const isHistoryById = isValidId && isOlderThanStartTime;
+  return isHistoryById;
+};
+export const extractTimestampFromId = activity => {
+  const id = (activity === null || activity === void 0 ? void 0 : activity.id) ?? "";
 
-        // if the activity id is not a number, we default to new message
-        if (isNaN(activityId)) {
-          return false;
-        }
+  // Helper function to get timestamp fallback
+  const getTimestampFallback = () => {
+    const timestamp = new Date((activity === null || activity === void 0 ? void 0 : activity.timestamp) ?? "").getTime();
+    return isNaN(timestamp) ? 0 : timestamp;
+  };
 
-        // if the activity id is less than the start time, it means that the message is a history message
-        if (activityId < startTime) {
-          return true;
-        }
-      }
-      // anything else will be considered a new message
-      return false;
-    }
-  } catch (e) {
-    // if there is an error in parsing the activity id, we will consider it a new message
-    console.error("Error in parsing activity id: ", e);
+  // Check if ID looks like a UUID (contains dashes or is very long)
+  const UUID_LENGTH_THRESHOLD = 13; // Threshold to distinguish UUIDs from epoch timestamps
+  if (id.includes("-") || id.length > UUID_LENGTH_THRESHOLD) {
+    // Likely UUID, use timestamp instead
+    return getTimestampFallback();
+  }
+  const activityId = parseInt(id);
+  // if activity id is not a number, then we use timestamp field
+  if (isNaN(activityId)) {
+    return getTimestampFallback();
   }
-  return false;
+  return activityId;
 };
 export const buildMessagePayload = (activity, userId) => {
-  var _text, _text2, _activity$channelData3, _activity$from;
+  var _text, _text2, _activity$channelData2, _activity$from;
   return {
     // To identify hidden contents vs empty content
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -40,7 +68,7 @@ export const buildMessagePayload = (activity, userId) => {
     type: activity === null || activity === void 0 ? void 0 : activity.type,
     timestamp: activity === null || activity === void 0 ? void 0 : activity.timestamp,
     userId: userId,
-    tags: activity === null || activity === void 0 ? void 0 : (_activity$channelData3 = activity.channelData) === null || _activity$channelData3 === void 0 ? void 0 : _activity$channelData3.tags,
+    tags: (activity === null || activity === void 0 ? void 0 : (_activity$channelData2 = activity.channelData) === null || _activity$channelData2 === void 0 ? void 0 : _activity$channelData2.tags) || [],
     messageType: "",
     Id: activity === null || activity === void 0 ? void 0 : activity.id,
     role: activity === null || activity === void 0 ? void 0 : (_activity$from = activity.from) === null || _activity$from === void 0 ? void 0 : _activity$from.role,
@@ -64,9 +92,9 @@ export const polyfillMessagePayloadForEvent = (activity, payload, conversationId
   };
 };
 export const getScenarioType = activity => {
-  var _activity$from3, _activity$channelData4;
+  var _activity$from3, _activity$channelData3;
   const role = activity === null || activity === void 0 ? void 0 : (_activity$from3 = activity.from) === null || _activity$from3 === void 0 ? void 0 : _activity$from3.role;
-  const tags = activity === null || activity === void 0 ? void 0 : (_activity$channelData4 = activity.channelData) === null || _activity$channelData4 === void 0 ? void 0 : _activity$channelData4.tags;
+  const tags = activity === null || activity === void 0 ? void 0 : (_activity$channelData3 = activity.channelData) === null || _activity$channelData3 === void 0 ? void 0 : _activity$channelData3.tags;
   if (role === Constants.userMessageTag) {
     return ScenarioType.UserSendMessageStrategy;
   }

package/lib/esm/plugins/newMessageEventHandler.js

@@ -6,13 +6,13 @@ import { Constants } from "../common/Constants";
 import { FirstResponseLatencyTracker } from "../firstresponselatency/FirstResponseLatencyTracker";
 import { TelemetryHelper } from "../common/telemetry/TelemetryHelper";
 import { TelemetryManager } from "../common/telemetry/TelemetryManager";
-export const createOnNewAdapterActivityHandler = (chatId, userId) => {
+export const createOnNewAdapterActivityHandler = (chatId, userId, startTime) => {
   // Hooking the message tracker in the listener, a bit invasive but easier to control.
   const firstResponseLatencyTracker = new FirstResponseLatencyTracker();
   // epoch time in utc for when start to listen.
   // We dont longer have a mechanism to know if a message is history or new, so any message older than the time we start listening will be considered a history message.
   // 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
-  const startTime = new Date().getTime();
+
   let isHistoryMessageReceivedEventRaised = false;
   const onNewAdapterActivityHandler = activity => {
     raiseMessageEvent(activity);
@@ -35,6 +35,7 @@ export const createOnNewAdapterActivityHandler = (chatId, userId) => {
     });
   };
   const systemMessageStrategy = activity => {
+    var _TelemetryManager$Int3;
     const payload = buildMessagePayload(activity, userId);
     payload.messageType = Constants.systemMessageTag;
     if (isHistoryMessage(activity, startTime)) {
@@ -42,6 +43,11 @@ export const createOnNewAdapterActivityHandler = (chatId, userId) => {
       historyMessageStrategy(polyfillMessagePayloadForEvent(activity, payload, (_TelemetryManager$Int2 = TelemetryManager.InternalTelemetryData) === null || _TelemetryManager$Int2 === void 0 ? void 0 : _TelemetryManager$Int2.conversationId));
       return;
     }
+    const newMessageReceivedEvent = {
+      eventName: BroadcastEvent.NewMessageReceived,
+      payload: polyfillMessagePayloadForEvent(activity, payload, (_TelemetryManager$Int3 = TelemetryManager.InternalTelemetryData) === null || _TelemetryManager$Int3 === void 0 ? void 0 : _TelemetryManager$Int3.conversationId)
+    };
+    BroadcastService.postMessage(newMessageReceivedEvent);
     TelemetryHelper.logActionEventToAllTelemetry(LogLevel.INFO, {
       Event: TelemetryEvent.SystemMessageReceived,
       Description: "System message received"
@@ -77,20 +83,20 @@ export const createOnNewAdapterActivityHandler = (chatId, userId) => {
     return true;
   };
   const receivedMessageStrategy = activity => {
-    var _TelemetryManager$Int4;
+    var _TelemetryManager$Int5;
     if (!isValidMessage(activity)) return;
     const isHistoryMessageReceived = isHistoryMessage(activity, startTime);
     const payload = buildMessagePayload(activity, userId);
     payload.messageType = Constants.userMessageTag;
     if (isHistoryMessageReceived) {
-      var _TelemetryManager$Int3;
-      historyMessageStrategy(polyfillMessagePayloadForEvent(activity, payload, (_TelemetryManager$Int3 = TelemetryManager.InternalTelemetryData) === null || _TelemetryManager$Int3 === void 0 ? void 0 : _TelemetryManager$Int3.conversationId));
+      var _TelemetryManager$Int4;
+      historyMessageStrategy(polyfillMessagePayloadForEvent(activity, payload, (_TelemetryManager$Int4 = TelemetryManager.InternalTelemetryData) === null || _TelemetryManager$Int4 === void 0 ? void 0 : _TelemetryManager$Int4.conversationId));
       return;
     }
     firstResponseLatencyTracker.stopClock(payload);
     const newMessageReceivedEvent = {
       eventName: BroadcastEvent.NewMessageReceived,
-      payload: polyfillMessagePayloadForEvent(activity, payload, (_TelemetryManager$Int4 = TelemetryManager.InternalTelemetryData) === null || _TelemetryManager$Int4 === void 0 ? void 0 : _TelemetryManager$Int4.conversationId)
+      payload: polyfillMessagePayloadForEvent(activity, payload, (_TelemetryManager$Int5 = TelemetryManager.InternalTelemetryData) === null || _TelemetryManager$Int5 === void 0 ? void 0 : _TelemetryManager$Int5.conversationId)
     };
     BroadcastService.postMessage(newMessageReceivedEvent);
     TelemetryHelper.logActionEventToAllTelemetry(LogLevel.INFO, {

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

@@ -7,6 +7,9 @@ export declare class Constants {
     static readonly historyMessageTag = "history";
     static readonly agentEndConversationMessageTag = "agentendconversation";
     static readonly supervisorForceCloseMessageTag = "supervisorforceclosedconversation";
+    static readonly endConversationalSurveyMessageTag = "endconversationalsurvey";
+    static readonly startConversationalSurveyMessageTag = "startconversationalsurvey";
+    static readonly c2ConversationalSurveyMessageTag = "c2conversationalsurvey";
     static readonly receivedMessageClassName = "ms_lcw_webchat_received_message";
     static readonly sentMessageClassName = "ms_lcw_webchat_sent_message";
     static readonly webchatChannelId = "webchat";
@@ -80,8 +83,7 @@ export declare class Constants {
     static readonly TargetRelationship = "rel";
     static readonly TargetRelationshipAttributes = "noopener noreferrer";
     static readonly OpenLinkIconCssClass = "webchat__render-markdown__external-link-icon";
-    static readonly internetConnectionTestUrl = "https://ocsdk-prod.azureedge.net/public/connecttest.txt";
-    static readonly internetConnectionTestUrlText = "Omnichannel Connect Test";
+    static readonly internetConnectionTestPath = "/livechatwidget/version.txt";
     static readonly ChatWidgetStateChangedPrefix = "ChatWidgetStateChanged";
     static readonly PostChatLoadingDurationInMs = 2000;
     static readonly BrowserUnloadConfirmationMessage = "Do you want to leave chat?";
@@ -94,6 +96,7 @@ export declare class Constants {
     static readonly OCOriginalMessageId = "OriginalMessageId";
     static readonly WebchatSequenceIdAttribute = "webchat:sequence-id";
     static readonly MessageSequenceIdOverride = "MessageSequenceIdOverride";
+    static readonly EndConversationDueToOverflow = "endconversationduetooverflow";
 }
 export declare const Regex: {
     new (): {};
@@ -180,6 +183,9 @@ export declare enum ConversationMode {
     Regular = "192350000",
     Persistent = "192350001"
 }
+export declare enum SurveyProvider {
+    MicrosoftCopilotStudio = "600990001"
+}
 export declare enum LiveWorkItemState {
     Active = "Active",
     Closed = "Closed",

package/lib/types/common/telemetry/TelemetryConstants.d.ts

@@ -172,6 +172,7 @@ export declare enum TelemetryEvent {
     BotAuthActivityUndefinedSignInId = "BotAuthActivityUndefinedSignInId",
     ThirdPartyCookiesBlocked = "ThirdPartyCookiesBlocked",
     ParticipantsRemovedEvent = "ParticipantsRemovedEvent",
+    QueueOverflowEvent = "QueueOverflowEvent",
     ProcessingHTMLTextMiddlewareFailed = "ProcessingHTMLTextMiddlewareFailed",
     ProcessingSanitizationMiddlewareFailed = "ProcessingSanitizationMiddlewareFailed",
     FormatTagsMiddlewareJSONStringifyFailed = "FormatTagsMiddlewareJSONStringifyFailed",

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

@@ -47,3 +47,8 @@ export declare const formatTemplateString: (templateMessage: string, values: any
 export declare const parseLowerCaseString: (property: string | boolean | undefined) => string;
 export declare const setOcUserAgent: (chatSDK: any) => void;
 export declare function getDeviceType(): string;
+export declare function isEndConversationDueToOverflowActivity(activity: {
+    channelData?: {
+        tags?: string[];
+    };
+}): boolean | undefined;

package/lib/types/components/livechatwidget/common/liveChatConfigUtils.d.ts

@@ -1,3 +1,4 @@
 import { FacadeChatSDK } from "../../../common/facades/FacadeChatSDK";
 export declare const isPostChatSurveyEnabled: (facadeChatSDK: FacadeChatSDK) => Promise<boolean>;
+export declare const getPostChatSurveyConfig: (facadeChatSDK: FacadeChatSDK) => Promise<any>;
 export declare const isPersistentChatEnabled: (conversationMode: string | undefined) => boolean;

package/lib/types/components/webchatcontainerstateful/webchatcontroller/middlewares/storemiddlewares/channelDataMiddleware.d.ts

@@ -4,7 +4,7 @@
  * Adds necessary tags if not present so that the rendering middlewares can process them later.
  ******/
 import { IWebChatAction } from "../../../interfaces/IWebChatAction";
-declare const channelDataMiddleware: ({ dispatch }: {
+declare const channelDataMiddleware: (addConversationalSurveyTagsCallback: any) => ({ dispatch }: {
     dispatch: any;
 }) => (next: any) => (action: IWebChatAction) => any;
 export default channelDataMiddleware;

package/lib/types/components/webchatcontainerstateful/webchatcontroller/middlewares/storemiddlewares/conversationEndMiddleware.d.ts

@@ -5,7 +5,7 @@
  * The callback is then invoked to hide the send box (by default).
  ******/
 import { IWebChatAction } from "../../../interfaces/IWebChatAction";
-declare const createConversationEndMiddleware: (conversationEndCallback: any) => ({ dispatch }: {
+declare const createConversationEndMiddleware: (conversationEndCallback: any, startConversationalSurveyCallback: any, endConversationalSurveyCallback: any) => ({ dispatch }: {
     dispatch: any;
 }) => (next: any) => (action: IWebChatAction) => any;
 export default createConversationEndMiddleware;

package/lib/types/components/webchatcontainerstateful/webchatcontroller/middlewares/storemiddlewares/queueOverflowHandlerMiddleware.d.ts

@@ -0,0 +1,5 @@
+import { IWebChatAction } from "../../../interfaces/IWebChatAction";
+import { ILiveChatWidgetContext } from "../../../../../contexts/common/ILiveChatWidgetContext";
+import { Dispatch } from "react";
+import { ILiveChatWidgetAction } from "../../../../../contexts/common/ILiveChatWidgetAction";
+export declare const createQueueOverflowMiddleware: (state: ILiveChatWidgetContext, dispatch: Dispatch<ILiveChatWidgetAction>) => () => (next: (action: IWebChatAction) => void) => (action: IWebChatAction) => void;

package/lib/types/contexts/common/ILiveChatWidgetContext.d.ts

@@ -48,6 +48,8 @@ export interface ILiveChatWidgetContext {
         chatDisconnectEventReceived: boolean;
         selectedSurveyMode: string | null;
         postChatParticipantType: undefined | ParticipantType;
+        isConversationalSurvey: boolean;
+        isConversationalSurveyEnabled: boolean;
     };
     uiStates: {
         showConfirmationPane: boolean;

package/lib/types/contexts/common/LiveChatWidgetActionType.d.ts

@@ -44,5 +44,7 @@ export declare enum LiveChatWidgetActionType {
     SET_SURVEY_MODE = 42,
     SET_CONFIRMATION_STATE = 43,
     SET_POST_CHAT_PARTICIPANT_TYPE = 44,
-    GET_IN_MEMORY_STATE = 45
+    SET_CONVERSATIONAL_SURVEY_ENABLED = 45,
+    SET_CONVERSATIONAL_SURVEY_DISPLAY = 46,
+    GET_IN_MEMORY_STATE = 47
 }

package/lib/types/firstresponselatency/FirstResponseLatencyTracker.d.ts

@@ -1,11 +1,11 @@
 import { MessagePayload } from "./Constants";
 export declare class FirstResponseLatencyTracker {
     private isABotConversation;
-    private isStarted;
-    private isEnded;
+    private isTracking;
     private startTrackingMessage?;
     private stopTrackingMessage?;
     private isReady;
+    private trackingTimeoutId?;
     constructor();
     private createTrackingMessage;
     private startTracking;

package/lib/types/firstresponselatency/util.d.ts

@@ -1,6 +1,23 @@
 import { MessagePayload, ScenarioType, TrackingMessage } from "./Constants";
 import { IActivity } from "botframework-directlinejs";
+/**
+ * Determines whether a given activity is a historical message.
+ *
+ * This function checks if the activity is a message type and uses a combination
+ * of legacy tags and timestamp-based logic to determine if the message is historical.
+ *
+ * @param {IActivity} activity - The activity object to evaluate.
+ * @param {number} startTime - The start time (in milliseconds since epoch) to compare against.
+ * @returns {boolean} - Returns true if the activity is a historical message, false otherwise.
+ *
+ * Logic:
+ * - If the activity type is not a message, it is not historical.
+ * - If the activity contains a legacy history message tag, it is considered historical.
+ * - Otherwise, the function extracts a timestamp from the activity ID using `extractTimestampFromId`.
+ *   - If the ID is valid and the timestamp is older than the start time, the message is historical.
+ */
 export declare const isHistoryMessage: (activity: IActivity, startTime: number) => boolean;
+export declare const extractTimestampFromId: (activity: IActivity) => number;
 export declare const buildMessagePayload: (activity: IActivity, userId: string) => MessagePayload;
 export declare const polyfillMessagePayloadForEvent: (activity: IActivity, payload: MessagePayload, conversationId?: string) => MessagePayload;
 export declare const getScenarioType: (activity: IActivity) => ScenarioType;

package/lib/types/plugins/newMessageEventHandler.d.ts

@@ -1,2 +1,2 @@
 import { IActivity } from "botframework-directlinejs";
-export declare const createOnNewAdapterActivityHandler: (chatId: string, userId: string) => (activity: IActivity) => void;
+export declare const createOnNewAdapterActivityHandler: (chatId: string, userId: string, startTime: number) => (activity: IActivity) => void;