@microsoft/omnichannel-chat-widget 1.8.7 → 2.0.0-main.5ebd4eb

package/lib/cjs/plugins/createChatTranscript.js

@@ -723,10 +723,9 @@ const createChatTranscript = async function (transcript, facadeChatSDK) {
   if (renderAttachments) {
     messages = await Promise.all(transcriptMessages.map(async message => {
       // eslint-disable-line @typescript-eslint/no-explicit-any
-      const {
-        amsReferences = message.amsreferences,
-        amsMetadata
-      } = message;
+      const _message$amsReference = message.amsReferences,
+        amsReferences = _message$amsReference === void 0 ? message.amsreferences : _message$amsReference,
+        amsMetadata = message.amsMetadata;
       if (amsReferences && amsMetadata) {
         const references = JSON.parse(amsReferences);
         const metadata = JSON.parse(amsMetadata);

package/lib/cjs/plugins/newMessageEventHandler.js

@@ -20,6 +20,8 @@ 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);
   };
@@ -41,9 +43,14 @@ const createOnNewAdapterActivityHandler = (chatId, userId, startTime) => {
     });
   };
   const systemMessageStrategy = activity => {
-    var _TelemetryManager$Int3;
+    var _activity$channelData, _TelemetryManager$Int3;
     const payload = (0, _util.buildMessagePayload)(activity, userId);
     payload.messageType = _Constants2.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$channelData = _activity$channelData.tags) !== null && _activity$channelData !== void 0 && _activity$channelData.includes(_Constants2.Constants.queuePositionMessageTag)) {
+      isInQueue = true;
+    }
     if ((0, _util.isHistoryMessage)(activity, startTime)) {
       var _TelemetryManager$Int2;
       historyMessageStrategy((0, _util.polyfillMessagePayloadForEvent)(activity, payload, (_TelemetryManager$Int2 = _TelemetryManager.TelemetryManager.InternalTelemetryData) === null || _TelemetryManager$Int2 === void 0 ? void 0 : _TelemetryManager$Int2.conversationId));
@@ -76,11 +83,11 @@ const createOnNewAdapterActivityHandler = (chatId, userId, startTime) => {
     }
   };
   const isValidMessage = activity => {
-    var _activity$channelData, _activity$channelData2;
+    var _activity$channelData2, _activity$channelData3;
     // 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 || (_activity$channelData2 = activity.channelData) === null || _activity$channelData2 === void 0 || (_activity$channelData2 = _activity$channelData2.tags) === null || _activity$channelData2 === void 0 ? void 0 : _activity$channelData2.length) === 0;
+    const messageHasNoTags = !(activity !== null && activity !== void 0 && activity.channelData) || !(activity !== null && activity !== void 0 && (_activity$channelData2 = activity.channelData) !== null && _activity$channelData2 !== void 0 && _activity$channelData2.tags) || (activity === null || activity === void 0 || (_activity$channelData3 = activity.channelData) === null || _activity$channelData3 === void 0 || (_activity$channelData3 = _activity$channelData3.tags) === null || _activity$channelData3 === void 0 ? void 0 : _activity$channelData3.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) {
@@ -102,6 +109,16 @@ const createOnNewAdapterActivityHandler = (chatId, userId, startTime) => {
       historyMessageStrategy((0, _util.polyfillMessagePayloadForEvent)(activity, payload, (_TelemetryManager$Int4 = _TelemetryManager.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.TelemetryHelper.logActionEvent(_TelemetryConstants.LogLevel.INFO, {
+        Event: _TelemetryConstants.TelemetryEvent.AgentJoinedConversation,
+        Description: "First message received from agent after queue"
+      });
+    }
     firstResponseLatencyTracker.stopClock(payload);
     const newMessageReceivedEvent = {
       eventName: _TelemetryConstants.BroadcastEvent.NewMessageReceived,

package/lib/esm/common/Constants.js

@@ -75,6 +75,8 @@ _defineProperty(Constants, "audioMediaRegex", /(\.)(aac|aiff|alac|amr|flac|mp2|m
 _defineProperty(Constants, "videoMediaRegex", /(\.)(avchd|avi|flv|mpe|mpeg|mpg|mpv|mp4|m4p|m4v|mov|qt|swf|webm|wmv)$/i);
 _defineProperty(Constants, "chromeSupportedInlineMediaRegex", /(\.)(aac|mp3|wav|mp4)$/i);
 _defineProperty(Constants, "firefoxSupportedInlineMediaRegex", /(\.)(aac|flac|mp3|wav|mp4|mov)$/i);
+_defineProperty(Constants, "AdaptiveCardType", "adaptivecard");
+_defineProperty(Constants, "SuggestedActionsType", "suggestedactions");
 // calling container event names
 _defineProperty(Constants, "CallAdded", "callAdded");
 _defineProperty(Constants, "LocalVideoStreamAdded", "localVideoStreamAdded");
@@ -137,6 +139,9 @@ _defineProperty(Constants, "customEventValue", "customEventValue");
 _defineProperty(Constants, "Hidden", "Hidden");
 _defineProperty(Constants, "EndConversationDueToOverflow", "endconversationduetooverflow");
 _defineProperty(Constants, "SkipSessionCloseForPersistentChatFlag", "skipSessionCloseForPersistentChat");
+// Minimum font-size for input fields to prevent iOS Safari auto-zoom on focus
+_defineProperty(Constants, "minInputFontSizePx", 16);
+_defineProperty(Constants, "minInputFontSize", "16px");
 export const Regex = (_Class = /*#__PURE__*/_createClass(function Regex() {
   _classCallCheck(this, Regex);
 }), _defineProperty(_Class, "EmailRegex", "^(?:[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+(?:\\.[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+)*|\"[^\"\\\\]*(?:\\\\.[^\"\\\\]*)*\")@(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?(?:\\.[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?)*|\\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\])$"), _Class);

package/lib/esm/common/facades/FacadeChatSDK.js

@@ -5,7 +5,7 @@ function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object
 function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
 function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 import { BroadcastEvent, LogLevel, TelemetryEvent } from "../telemetry/TelemetryConstants";
-import { getAuthClientFunction, handleAuthentication } from "../../components/livechatwidget/common/authHelper";
+import { getAuthClientFunction, handleAuthentication, isMidAuthEnabled } from "../../components/livechatwidget/common/authHelper";
 import { BroadcastService } from "@microsoft/omnichannel-chat-components";
 import { TelemetryHelper } from "../telemetry/TelemetryHelper";
 import { isNullOrEmptyString } from "../utils";
@@ -20,6 +20,8 @@ export let FacadeChatSDK = /*#__PURE__*/function () {
     _defineProperty(this, "getAuthToken", void 0);
     _defineProperty(this, "sdkMocked", void 0);
     _defineProperty(this, "disableReauthentication", void 0);
+    // Stays true so CASE 1 re-triggers on every startChat to set deferInitialAuth
+    _defineProperty(this, "pendingMidAuthUnauthenticatedState", false);
     this.chatSDK = input.chatSDK;
     this.chatConfig = input.chatConfig;
     this.getAuthToken = input.getAuthToken;
@@ -44,6 +46,12 @@ export let FacadeChatSDK = /*#__PURE__*/function () {
     value: function destroy() {
       this.token = null;
       this.expiration = 0;
+      if (isMidAuthEnabled(this.chatConfig)) {
+        this.pendingMidAuthUnauthenticatedState = false;
+        this.isAuthenticated = true;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.chatSDK.deferInitialAuth = false;
+      }
     }
   }, {
     key: "isTokenSet",
@@ -208,6 +216,10 @@ export let FacadeChatSDK = /*#__PURE__*/function () {
           message: "Token is valid"
         };
       }
+
+      // Token missing or expired - need to get a new one via getAuthToken
+      // For mid-auth: getAuthToken receives { isMidAuthEnabled: true } so customer implementations
+      // can check portal state and return null for logged-out users
       TelemetryHelper.logFacadeChatSDKEventToAllTelemetry(LogLevel.INFO, {
         Event: TelemetryEvent.NewTokenValidationStarted,
         Description: "Token validation started."
@@ -228,6 +240,7 @@ export let FacadeChatSDK = /*#__PURE__*/function () {
       this.token = "";
       this.expiration = 0;
       try {
+        var _ring$error, _ring$error2;
         const ring = await handleAuthentication(this.chatSDK, this.chatConfig, this.getAuthToken);
         if ((ring === null || ring === void 0 ? void 0 : ring.result) === true && ring !== null && ring !== void 0 && ring.token) {
           await this.setToken(ring.token);
@@ -242,18 +255,35 @@ export let FacadeChatSDK = /*#__PURE__*/function () {
             result: true,
             message: "New Token obtained"
           };
-        } else {
-          var _ring$error, _ring$error2;
-          TelemetryHelper.logFacadeChatSDKEventToAllTelemetry(LogLevel.ERROR, {
-            Event: TelemetryEvent.NewTokenValidationFailed,
-            Description: (_ring$error = ring.error) === null || _ring$error === void 0 ? void 0 : _ring$error.message,
-            ExceptionDetails: ring === null || ring === void 0 ? void 0 : ring.error
+        }
+
+        // Mid-auth: no token available - set pending flag for startChat to handle
+        const isEmptyTokenWithoutError = isNullOrEmptyString(ring === null || ring === void 0 ? void 0 : ring.token) && ((ring === null || ring === void 0 ? void 0 : ring.result) === true || (ring === null || ring === void 0 ? void 0 : ring.result) === false && !(ring !== null && ring !== void 0 && ring.error));
+        if (isMidAuthEnabled(this.chatConfig) && isEmptyTokenWithoutError) {
+          // Clear Facade and SDK token state so API calls use unauthenticated endpoints
+          this.token = "";
+          this.expiration = 0;
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          this.chatSDK.authenticatedUserToken = null;
+          this.pendingMidAuthUnauthenticatedState = true;
+          TelemetryHelper.logFacadeChatSDKEventToAllTelemetry(LogLevel.INFO, {
+            Event: TelemetryEvent.NewTokenValidationCompleted,
+            Description: "Mid-auth enabled: no token returned; proceeding as unauthenticated"
           });
           return {
-            result: false,
-            message: (ring === null || ring === void 0 || (_ring$error2 = ring.error) === null || _ring$error2 === void 0 ? void 0 : _ring$error2.message) || "Failed to get token"
+            result: true,
+            message: "Mid-auth: proceeding as unauthenticated"
           };
         }
+        TelemetryHelper.logFacadeChatSDKEventToAllTelemetry(LogLevel.ERROR, {
+          Event: TelemetryEvent.NewTokenValidationFailed,
+          Description: (_ring$error = ring.error) === null || _ring$error === void 0 ? void 0 : _ring$error.message,
+          ExceptionDetails: ring === null || ring === void 0 ? void 0 : ring.error
+        });
+        return {
+          result: false,
+          message: (ring === null || ring === void 0 || (_ring$error2 = ring.error) === null || _ring$error2 === void 0 ? void 0 : _ring$error2.message) || "Failed to get token"
+        };
       } catch (e) {
         console.error("Unexpected error while getting token", e);
         TelemetryHelper.logFacadeChatSDKEventToAllTelemetry(LogLevel.ERROR, {
@@ -267,6 +297,155 @@ export let FacadeChatSDK = /*#__PURE__*/function () {
         };
       }
     }
+
+    /**
+     * Sets unauthenticated state for mid-auth flow.
+     * Clears SDK internal state to prevent reconnection to previous authenticated session.
+     */
+  }, {
+    key: "setMidAuthUnauthenticatedState",
+    value: function setMidAuthUnauthenticatedState() {
+      var _sdk$chatToken, _sdk$chatToken2;
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const sdk = this.chatSDK;
+      const hadExistingChat = !!((_sdk$chatToken = sdk.chatToken) !== null && _sdk$chatToken !== void 0 && _sdk$chatToken.chatId);
+      const previousChatId = (_sdk$chatToken2 = sdk.chatToken) === null || _sdk$chatToken2 === void 0 ? void 0 : _sdk$chatToken2.chatId;
+      this.clearAuthState();
+
+      // Clear SDK internal state for fresh unauthenticated chat
+      sdk.chatToken = {};
+      sdk.reconnectId = null;
+      sdk.requestId = null;
+      sdk.sessionId = null;
+      sdk.conversation = null;
+      TelemetryHelper.logFacadeChatSDKEventToAllTelemetry(LogLevel.INFO, {
+        Event: TelemetryEvent.MidConversationAuthReset,
+        Description: hadExistingChat ? "Mid-auth without token: local state cleared" : "Mid-auth: initialized as unauthenticated (no prior chat)",
+        Data: hadExistingChat ? {
+          previousChatId
+        } : undefined
+      });
+    }
+
+    /** Clears authentication state in both FacadeChatSDK and underlying SDK */
+  }, {
+    key: "clearAuthState",
+    value: function clearAuthState() {
+      this.token = "";
+      this.expiration = 0;
+      this.isAuthenticated = false;
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      this.chatSDK.authenticatedUserToken = null;
+    }
+
+    /**
+     * Migrates conversation from unauthenticated to authenticated via authenticateChat.
+     * Called after startChat() when user has a valid token but the backend conversation
+     * was started as unauthenticated.
+     */
+  }, {
+    key: "migrateConversationToAuthenticated",
+    value: async function migrateConversationToAuthenticated() {
+      try {
+        await this.chatSDK.authenticateChat(this.token, {
+          refreshChatToken: true
+        });
+        this.isAuthenticated = true;
+        TelemetryHelper.logFacadeChatSDKEventToAllTelemetry(LogLevel.INFO, {
+          Event: TelemetryEvent.MidConversationAuthSucceeded,
+          Description: "Mid-auth: authenticateChat completed, conversation migrated to authenticated"
+        });
+      } catch (e) {
+        // Non-fatal: Chat is already active via startChat, will retry on next reconnect
+        TelemetryHelper.logFacadeChatSDKEventToAllTelemetry(LogLevel.WARN, {
+          Event: TelemetryEvent.MidConversationAuthFailed,
+          Description: "Mid-auth: authenticateChat returned error after startChat, chat still active",
+          ExceptionDetails: {
+            message: e === null || e === void 0 ? void 0 : e.message
+          }
+        });
+      }
+    }
+
+    /**
+     * Configures SDK auth state before startChat.
+     * CASE 1: Pending unauthenticated (no token) - sets deferInitialAuth=true
+     * CASE 2: Authenticated with valid token - sets SDK token and deferInitialAuth based on scenario
+     */
+  }, {
+    key: "configureMidAuthState",
+    value: function configureMidAuthState(isReconnect, wasPreviousSessionAuthenticated) {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const sdk = this.chatSDK;
+
+      // CASE 1: No token available (user not logged in)
+      // pendingMidAuthUnauthenticatedState stays true until user logs in (cleared in tokenRing)
+      if (this.pendingMidAuthUnauthenticatedState) {
+        const shouldClear = this.handlePendingUnauthenticatedState(wasPreviousSessionAuthenticated);
+        sdk.deferInitialAuth = true;
+        TelemetryHelper.logFacadeChatSDKEventToAllTelemetry(LogLevel.INFO, {
+          Event: TelemetryEvent.MidConversationAuthReset,
+          Description: "Mid-auth configureMidAuthState: CASE 1 - unauthenticated, deferInitialAuth=true",
+          Data: {
+            isReconnect: String(isReconnect),
+            wasPreviousSessionAuthenticated: String(wasPreviousSessionAuthenticated),
+            shouldClearReconnectParams: String(shouldClear)
+          }
+        });
+        return {
+          shouldClearReconnectParams: shouldClear
+        };
+      }
+
+      // CASE 2: Authenticated with valid token
+      if (this.isTokenSet() && !this.isTokenExpired()) {
+        this.handleAuthenticatedState(isReconnect, wasPreviousSessionAuthenticated);
+      }
+      return {
+        shouldClearReconnectParams: false
+      };
+    }
+
+    /**
+     * CASE 1 handler: Returns true if reconnect params should be cleared (Auth -> Unauth transition)
+     */
+  }, {
+    key: "handlePendingUnauthenticatedState",
+    value: function handlePendingUnauthenticatedState(wasPreviousSessionAuthenticated) {
+      if (wasPreviousSessionAuthenticated) {
+        // Auth -> Unauth: user logged out, clear state for fresh chat
+        this.setMidAuthUnauthenticatedState();
+        return true;
+      }
+
+      // Unauth -> Unauth: keep liveChatContext for reconnection
+      this.isAuthenticated = false;
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      this.chatSDK.authenticatedUserToken = null;
+      return false;
+    }
+
+    /**
+     * CASE 2 handler: Sets deferInitialAuth only for reconnects to unauthenticated sessions (need migration).
+     * For new chats or reconnects to authenticated sessions, SDK handles auth internally.
+     */
+  }, {
+    key: "handleAuthenticatedState",
+    value: function handleAuthenticatedState(isReconnect, wasPreviousSessionAuthenticated) {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const sdk = this.chatSDK;
+      sdk.authenticatedUserToken = this.token;
+      if (isReconnect && !wasPreviousSessionAuthenticated) {
+        sdk.deferInitialAuth = true;
+        TelemetryHelper.logFacadeChatSDKEventToAllTelemetry(LogLevel.INFO, {
+          Event: TelemetryEvent.MidConversationAuthSucceeded,
+          Description: "Mid-auth handleAuthenticatedState: CASE 2 - reconnect to unauth session, deferInitialAuth=true (migration needed)"
+        });
+      } else {
+        // Reset to prevent inheriting deferInitialAuth=true from a previous unauthenticated chat
+        sdk.deferInitialAuth = false;
+      }
+    }
   }, {
     key: "validateAndExecuteCall",
     value: async function validateAndExecuteCall(functionName, fn) {
@@ -301,7 +480,52 @@ export let FacadeChatSDK = /*#__PURE__*/function () {
     key: "startChat",
     value: async function startChat() {
       let optionalParams = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-      return this.validateAndExecuteCall("startChat", () => this.chatSDK.startChat(optionalParams));
+      const midAuthEnabled = isMidAuthEnabled(this.chatConfig);
+      const isReconnect = !!optionalParams.liveChatContext || !!optionalParams.reconnectId;
+      const wasPreviousSessionAuthenticated = optionalParams.wasAuthenticated === true;
+      return this.validateAndExecuteCall("startChat", async () => {
+        if (midAuthEnabled) {
+          const _this$configureMidAut = this.configureMidAuthState(isReconnect, wasPreviousSessionAuthenticated),
+            shouldClearReconnectParams = _this$configureMidAut.shouldClearReconnectParams;
+          if (shouldClearReconnectParams) {
+            delete optionalParams.liveChatContext;
+            delete optionalParams.reconnectId;
+          }
+        }
+        await this.chatSDK.startChat(optionalParams);
+
+        // Migrate to authenticated if needed (reconnects to unauthenticated sessions only)
+        if (midAuthEnabled) {
+          const shouldMigrateToAuth = isReconnect && this.isTokenSet() && !this.isTokenExpired() && !wasPreviousSessionAuthenticated;
+          if (shouldMigrateToAuth) {
+            TelemetryHelper.logFacadeChatSDKEventToAllTelemetry(LogLevel.INFO, {
+              Event: TelemetryEvent.MidConversationAuthSucceeded,
+              Description: "Mid-auth startChat: initiating migration to authenticated",
+              Data: {
+                isReconnect: String(isReconnect),
+                wasPreviousSessionAuthenticated: String(wasPreviousSessionAuthenticated)
+              }
+            });
+            await this.migrateConversationToAuthenticated();
+          }
+        }
+
+        // Broadcast final auth state after startChat completes (only on state change)
+        if (midAuthEnabled) {
+          const isAuthenticatedAfterStart = this.isTokenSet() && !this.isTokenExpired();
+          const authStateChanged = !isReconnect || isAuthenticatedAfterStart !== wasPreviousSessionAuthenticated;
+          if (authStateChanged) {
+            BroadcastService.postMessage({
+              eventName: isAuthenticatedAfterStart ? BroadcastEvent.MidConversationAuthSucceeded : BroadcastEvent.MidConversationAuthReset,
+              payload: {
+                isAuthenticated: isAuthenticatedAfterStart,
+                isStartChatComplete: true,
+                isReconnect
+              }
+            });
+          }
+        }
+      });
     }
   }, {
     key: "endChat",
@@ -439,6 +663,7 @@ export let FacadeChatSDK = /*#__PURE__*/function () {
       let optionalParams = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
       return this.validateAndExecuteCall("getAgentAvailability", () => this.chatSDK.getAgentAvailability(optionalParams));
     }
+
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
   }, {
     key: "getReconnectableChats",

package/lib/esm/common/telemetry/TelemetryConstants.js

@@ -67,6 +67,9 @@ export let BroadcastEvent = /*#__PURE__*/function (BroadcastEvent) {
   BroadcastEvent["FMLTrackingCompletedAck"] = "FMLTrackingCompletedAck";
   BroadcastEvent["FMLTrackingCompleted"] = "FMLTrackingCompleted";
   BroadcastEvent["PersistentConversationReset"] = "PersistentConversationReset";
+  BroadcastEvent["MidConversationAuthSucceeded"] = "MidConversationAuthSucceeded";
+  // Emitted when mid-conversation auth succeeds (for reconnect support)
+  BroadcastEvent["MidConversationAuthReset"] = "MidConversationAuthReset"; // Emitted when mid-auth falls back to unauthenticated mode (token null/empty)
   return BroadcastEvent;
 }({});
 
@@ -103,6 +106,10 @@ export let TelemetryEvent = /*#__PURE__*/function (TelemetryEvent) {
   TelemetryEvent["CallingSDKInitFailed"] = "CallingSDKInitFailed";
   TelemetryEvent["CallingSDKLoadSuccess"] = "CallingSDKLoadSuccess";
   TelemetryEvent["CallingSDKLoadFailed"] = "CallingSDKLoadFailed";
+  TelemetryEvent["MidConversationAuthSucceeded"] = "MidConversationAuthSucceeded";
+  TelemetryEvent["MidConversationAuthFailed"] = "MidConversationAuthFailed";
+  TelemetryEvent["MidConversationAuthReset"] = "MidConversationAuthReset";
+  TelemetryEvent["RecoveryEligibilityEvaluated"] = "RecoveryEligibilityEvaluated";
   TelemetryEvent["GetConversationDetailsCallStarted"] = "GetConversationDetailsCallStarted";
   TelemetryEvent["GetConversationDetailsCallFailed"] = "GetConversationDetailsCallFailed";
   TelemetryEvent["EndChatSDKCallFailed"] = "EndChatSDKCallFailed";
@@ -193,6 +200,7 @@ export let TelemetryEvent = /*#__PURE__*/function (TelemetryEvent) {
   //WebChat Middleware Events
   TelemetryEvent["ProcessingHTMLTextMiddlewareFailed"] = "ProcessingHTMLTextMiddlewareFailed";
   TelemetryEvent["ProcessingSanitizationMiddlewareFailed"] = "ProcessingSanitizationMiddlewareFailed";
+  TelemetryEvent["HTMLSanitized"] = "HTMLSanitized";
   TelemetryEvent["FormatTagsMiddlewareJSONStringifyFailed"] = "FormatTagsMiddlewareJSONStringifyFailed";
   TelemetryEvent["AttachmentUploadValidatorMiddlewareFailed"] = "AttachmentUploadValidatorMiddlewareFailed";
   TelemetryEvent["CitationMiddlewareFailed"] = "CitationMiddlewareFailed";
@@ -319,11 +327,19 @@ export let TelemetryEvent = /*#__PURE__*/function (TelemetryEvent) {
   TelemetryEvent["LCWLazyLoadNoMoreHistory"] = "LCWLazyLoadNoMoreHistory";
   TelemetryEvent["LCWLazyLoadHistoryError"] = "LCWLazyLoadHistoryError";
   TelemetryEvent["LCWLazyLoadDestroyed"] = "LCWLazyLoadDestroyed";
+  TelemetryEvent["LCWLazyLoadTriggerFired"] = "LCWLazyLoadTriggerFired";
+  TelemetryEvent["LCWLazyLoadBatchReceived"] = "LCWLazyLoadBatchReceived";
+  TelemetryEvent["LCWLazyLoadInitialLoadComplete"] = "LCWLazyLoadInitialLoadComplete";
+  TelemetryEvent["LCWLazyLoadScrollAnchorApplied"] = "LCWLazyLoadScrollAnchorApplied";
   // SecureEventBus events
   TelemetryEvent["SecureEventBusUnauthorizedDispatch"] = "SecureEventBusUnauthorizedDispatch";
   TelemetryEvent["SecureEventBusListenerError"] = "SecureEventBusListenerError";
   TelemetryEvent["SecureEventBusDispatchError"] = "SecureEventBusDispatchError";
   TelemetryEvent["StartChatComplete"] = "StartChatComplete";
+  // Queue & Agent Assignment
+  TelemetryEvent["AgentJoinedConversation"] = "AgentJoinedConversation";
+  // Browser Close Detection
+  TelemetryEvent["BrowserTabHidden"] = "BrowserTabHidden";
   return TelemetryEvent;
 }({});
 export let TelemetryConstants = /*#__PURE__*/function () {
@@ -395,6 +411,9 @@ export let TelemetryConstants = /*#__PURE__*/function () {
         case TelemetryEvent.SecureEventBusUnauthorizedDispatch:
         case TelemetryEvent.SecureEventBusListenerError:
         case TelemetryEvent.SecureEventBusDispatchError:
+        case TelemetryEvent.AgentJoinedConversation:
+        case TelemetryEvent.BrowserTabHidden:
+        case TelemetryEvent.RecoveryEligibilityEvaluated:
           return ScenarioType.ACTIONS;
         case TelemetryEvent.StartChatSDKCall:
         case TelemetryEvent.StartChatEventReceived:

package/lib/esm/common/telemetry/TelemetryManager.js

@@ -11,6 +11,7 @@ import { appInsightsLogger } from "./loggers/appInsightsLogger";
 import { ariaTelemetryLogger } from "./loggers/ariaTelemetryLogger";
 import { consoleLogger } from "./loggers/consoleLogger";
 import { defaultAriaConfig } from "./defaultConfigs/defaultAriaConfig";
+import { sanitizeSasInPayload } from "./sanitizeSasInPayload";
 export let TelemetryTimers = /*#__PURE__*/_createClass(function TelemetryTimers() {
   _classCallCheck(this, TelemetryTimers);
 });
@@ -72,11 +73,15 @@ export const RegisterLoggers = () => {
     };
   };
   const logTelemetry = telemetryEvent => {
+    // Redact Azure SAS credentials in any URL embedded in the payload (e.g.
+    // customer-supplied blob asset URLs in widget customization props) before
+    // it fans out to console, Aria, AppInsights, or any custom logger.
+    const sanitizedPayload = sanitizeSasInPayload(telemetryEvent === null || telemetryEvent === void 0 ? void 0 : telemetryEvent.payload);
     loggers.map(logger => {
       var _payload, _telemetryInput$paylo;
       const logLevel = telemetryEvent.logLevel ?? LogLevel.INFO;
       const scenarioType = ((_payload = telemetryEvent.payload) === null || _payload === void 0 ? void 0 : _payload.scenarioType) ?? ScenarioType.UNDEFINED;
-      const telemetryInput = parseInput(telemetryEvent === null || telemetryEvent === void 0 ? void 0 : telemetryEvent.payload, scenarioType);
+      const telemetryInput = parseInput(sanitizedPayload, scenarioType);
       telemetryInput.telemetryInfo = {
         telemetryInfo: TelemetryHelper.buildTelemetryEvent(logLevel, telemetryInput)
       };

package/lib/esm/common/telemetry/loggers/appInsightsLogger.js

@@ -34,9 +34,8 @@ export const appInsightsLogger = appInsightsKey => {
       }
       try {
         // Dynamically import Application Insights
-        const {
-          ApplicationInsights
-        } = await import("@microsoft/applicationinsights-web");
+        const _await$import = await import("@microsoft/applicationinsights-web"),
+          ApplicationInsights = _await$import.ApplicationInsights;
         const config = {
           ...(appInsightsKey.includes("IngestionEndpoint") ? {
             connectionString: appInsightsKey

package/lib/esm/common/telemetry/sanitizeSasInPayload.js

@@ -0,0 +1,84 @@
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+/**
+ * Redacts the values of Azure Shared Access Signature (SAS) query parameters in any
+ * URL embedded in a telemetry payload, so customer-supplied SAS URLs (e.g. blob asset
+ * URLs in widget customization props) cannot leak credentials through Aria/AppInsights.
+ *
+ * Trigger: any URL whose query string contains `sig=`. When detected, every well-known
+ * SAS parameter value in that query is replaced with `[REDACTED]`. Other URLs and other
+ * substrings of the payload pass through unchanged.
+ *
+ * Coverage of SAS parameter names:
+ *  - Service/Blob SAS:        sig, sv, se, st, sp, spr, sr, sip
+ *  - Account SAS:             ss, srt
+ *  - User-delegation key SAS: skoid, sktid, skt, ske, sks, skv, saoid, suoid, sce, sdd
+ *  - Response header overrides: rscc, rscd, rsce, rscl, rsct
+ *
+ * Reference: https://learn.microsoft.com/en-us/rest/api/storageservices/create-service-sas
+ */
+
+const SAS_PARAM_NAMES = new Set(["sig", "sv", "se", "st", "sp", "spr", "sr", "sip", "ss", "srt", "skoid", "sktid", "skt", "ske", "sks", "skv", "saoid", "suoid", "sce", "sdd", "rscc", "rscd", "rsce", "rscl", "rsct"]);
+const REDACTED_VALUE = "[REDACTED]";
+
+// Matches any http(s) URL substring up to whitespace / closing quote / angle-bracket / paren.
+const URL_REGEX = /\bhttps?:\/\/[^\s"'<>)]+/gi;
+const redactQueryIfSas = url => {
+  const queryIdx = url.indexOf("?");
+  if (queryIdx < 0) {
+    return url;
+  }
+  // Separate the fragment (#...) before processing the query — fragments come
+  // after the query string in URL syntax and must not be folded into the last
+  // query parameter's value when we split on `&`.
+  const afterQuestionMark = url.slice(queryIdx + 1);
+  const fragIdx = afterQuestionMark.indexOf("#");
+  const query = fragIdx < 0 ? afterQuestionMark : afterQuestionMark.slice(0, fragIdx);
+  const fragment = fragIdx < 0 ? "" : afterQuestionMark.slice(fragIdx); // includes the leading '#'
+  if (!/(^|&)sig=/i.test(query)) {
+    // No SAS signature present — leave the URL alone so legitimate non-SAS query
+    // strings (e.g. ?utm_source=...) are not mangled.
+    return url;
+  }
+  const base = url.slice(0, queryIdx);
+  const sanitizedQuery = query.split("&").map(pair => {
+    const eqIdx = pair.indexOf("=");
+    if (eqIdx < 0) {
+      return pair;
+    }
+    const name = pair.slice(0, eqIdx).toLowerCase();
+    return SAS_PARAM_NAMES.has(name) ? `${pair.slice(0, eqIdx)}=${REDACTED_VALUE}` : pair;
+  }).join("&");
+  return `${base}?${sanitizedQuery}${fragment}`;
+};
+const sanitizeString = s => s.replace(URL_REGEX, redactQueryIfSas);
+
+/**
+ * Deep-walk a value and redact SAS credentials in any string it contains.
+ * Returns a new object/array (originals are not mutated); non-string leaves are
+ * passed through. Tree-shaped, JSON-like values only — not designed for class
+ * instances, prototype-bound objects, or cyclic graphs.
+ */
+export const sanitizeSasInPayload = value => {
+  if (typeof value === "string") {
+    return sanitizeString(value);
+  }
+  if (Array.isArray(value)) {
+    return value.map(sanitizeSasInPayload);
+  }
+  if (value !== null && typeof value === "object") {
+    const out = {};
+    for (const _ref of Object.entries(value)) {
+      var _ref2 = _slicedToArray(_ref, 2);
+      const k = _ref2[0];
+      const v = _ref2[1];
+      out[k] = sanitizeSasInPayload(v);
+    }
+    return out;
+  }
+  return value;
+};