@webex/plugin-meetings 3.10.0 → 3.11.0

package/src/locus-info/types.ts

@@ -0,0 +1,53 @@
+import {HtMeta} from '../hashTree/types';
+
+export type LocusFullState = {
+  active: boolean;
+  count: number;
+  lastActive: string;
+  locked: boolean;
+  sessionId: string;
+  seessionIds: string[];
+  startTime: number;
+  state: string;
+  type: string;
+};
+
+export type Links = {
+  services: Record<'breakout' | 'record', {url: string}>; // there exist also other services, but these are the ones we currently use
+  resources: Record<'webcastInstance' | 'visibleDataSets', {url: string}>; // there exist also other resources, but these are the ones we currently use
+};
+
+export type LocusDTO = {
+  controls?: any;
+  fullState?: LocusFullState;
+  host?: {
+    id: string;
+    incomingCallProtocols: any[];
+    isExternal: boolean;
+    name: string;
+    orgId: string;
+  };
+  htMeta?: HtMeta;
+  info?: any;
+  jsSdkMeta?: {
+    removedParticipantIds: string[]; // list of ids of participants that are removed in the last update
+  };
+  links?: Links;
+  mediaShares?: any[];
+  meetings?: any[];
+  participants: any[];
+  replaces?: any[];
+  self?: any;
+  sequence?: {
+    dirtyParticipants: number;
+    entries: number[];
+    rangeEnd: number;
+    rangeStart: number;
+    sequenceHash: number;
+    sessionToken: string;
+    since: string;
+    totalParticipants: number;
+  };
+  syncUrl?: string;
+  url?: string;
+};

package/src/media/index.ts

@@ -194,6 +194,12 @@ Media.createMediaConnection = (
       config.stopIceGatheringAfterFirstRelayCandidate = stopIceGatheringAfterFirstRelayCandidate;
     }
 
+    if (BrowserInfo.isEdge() || BrowserInfo.isChrome()) {
+      // we need this for getting inbound audio metadata
+      // but the audioLevel that we use is only available on Chromium based browsers
+      config.enableInboundAudioLevelMonitoring = true;
+    }
+
     return new MultistreamRoapMediaConnection(
       config,
       meetingId,

package/src/meeting/index.ts

@@ -1,5 +1,5 @@
 import uuid from 'uuid';
-import {cloneDeep, isEqual, isEmpty} from 'lodash';
+import {cloneDeep, isEqual, isEmpty, merge} from 'lodash';
 import jwtDecode from 'jwt-decode';
 // @ts-ignore - Fix this
 import {StatelessWebexPlugin} from '@webex/webex-core';
@@ -30,6 +30,7 @@ import {
   NetworkQualityMonitor,
   StatsMonitor,
   StatsMonitorEventNames,
+  InboundAudioIssueSubTypes,
 } from '@webex/internal-media-core';
 
 import {
@@ -49,6 +50,11 @@ import {
   type MeetingTranscriptPayload,
 } from '@webex/internal-plugin-voicea';
 
+import {
+  getBrowserMediaErrorCode,
+  isBrowserMediaError,
+  isBrowserMediaErrorName,
+} from '@webex/internal-plugin-metrics/src/call-diagnostic/call-diagnostic-metrics.util';
 import {processNewCaptions} from './voicea-meeting';
 
 import {
@@ -57,6 +63,7 @@ import {
   NoMediaEstablishedYetError,
   UserNotJoinedError,
   AddMediaFailed,
+  SdpResponseTimeoutError,
 } from '../common/errors/webex-errors';
 
 import LoggerProxy from '../common/logs/logger-proxy';
@@ -68,7 +75,7 @@ import Media, {type BundlePolicy} from '../media';
 import MediaProperties from '../media/properties';
 import MeetingStateMachine from './state';
 import {createMuteState} from './muteState';
-import LocusInfo from '../locus-info';
+import LocusInfo, {LocusLLMEvent} from '../locus-info';
 import Metrics from '../metrics';
 import ReconnectionManager from '../reconnection-manager';
 import ReconnectionNotStartedError from '../common/errors/reconnection-not-started';
@@ -124,6 +131,8 @@ import {
   JOIN_BEFORE_HOST,
   REGISTRATION_ID_STATUS,
   STAGE_MANAGER_TYPE,
+  LOCUSEVENT,
+  LOCUS_LLM_EVENT,
 } from '../constants';
 import BEHAVIORAL_METRICS from '../metrics/constants';
 import ParameterError from '../common/errors/parameter';
@@ -169,10 +178,14 @@ import JoinForbiddenError from '../common/errors/join-forbidden-error';
 import {ReachabilityMetrics} from '../reachability/reachability.types';
 import {SetStageOptions, SetStageVideoLayout, UnsetStageVideoLayout} from './request.type';
 import {Invitee} from './type';
+import {DataSet} from '../hashTree/hashTreeParser';
+import {LocusDTO} from '../locus-info/types';
 
 // default callback so we don't call an undefined function, but in practice it should never be used
 const DEFAULT_ICE_PHASE_CALLBACK = () => 'JOIN_MEETING_FINAL';
 
+const LLM_HEALTHCHECK_TIMER_MS = 3 * 60 * 1000;
+
 const logRequest = (request: any, {logText = ''}) => {
   LoggerProxy.logger.info(`${logText} - sending request`);
 
@@ -745,6 +758,7 @@ export default class Meeting extends StatelessWebexPlugin {
   private uploadLogsTimer?: ReturnType<typeof setTimeout>;
   private logUploadIntervalIndex: number;
   private mediaServerIp: string;
+  private llmHealthCheckTimer?: ReturnType<typeof setTimeout>;
 
   /**
    * @param {Object} attrs
@@ -2837,6 +2851,13 @@ export default class Meeting extends StatelessWebexPlugin {
       );
     });
 
+    this.locusInfo.on(LOCUSINFO.EVENTS.CONTROLS_MEETING_HESIOD_LLM_ID_UPDATED, ({hesiodLlmId}) => {
+      if (hesiodLlmId) {
+        // @ts-ignore
+        this.webex.internal.voicea.onCaptionServiceIdUpdate(hesiodLlmId);
+      }
+    });
+
     this.locusInfo.on(LOCUSINFO.EVENTS.CONTROLS_MEETING_BREAKOUT_UPDATED, ({breakout}) => {
       this.breakouts.updateBreakout(breakout);
       Trigger.trigger(
@@ -4549,40 +4570,45 @@ export default class Meeting extends StatelessWebexPlugin {
   }
 
   /**
-   * Set the locus info the class instance
-   * @param {Object} locus
-   * @param {Array} locus.mediaConnections
-   * @param {String} locus.locusUrl
-   * @param {String} locus.locusId
-   * @param {String} locus.mediaId
-   * @param {Object} locus.host
+   * Set the locus info the class instance. Should be called with the parsed locus
+   * we got in the join response.
+   *
+   * @param {Object} data
+   * @param {Array} data.mediaConnections
+   * @param {String} data.locusUrl
+   * @param {String} data.locusId
+   * @param {String} data.mediaId
+   * @param {Object} data.host
    * @todo change name to genertic parser
    * @returns {undefined}
    * @private
    * @memberof Meeting
    */
-  setLocus(
-    locus:
-      | {
-          mediaConnections: Array<any>;
-          locusUrl: string;
-          locusId: string;
-          mediaId: string;
-          host: object;
-        }
-      | any
-  ) {
-    const mtgLocus: any = locus.locus || locus;
+  setLocus(data: {
+    locus: LocusDTO;
+    mediaConnections: Array<any>;
+    locusUrl: string;
+    locusId: string;
+    mediaId: string;
+    host: object;
+    selfId: string;
+    dataSets: DataSet[];
+  }) {
+    const mtgLocus: any = data.locus;
 
     // LocusInfo object saves the locus object
     // this.locus = mtgLocus;
-    this.mediaConnections = locus.mediaConnections;
-    this.locusUrl = locus.locusUrl || locus.url;
-    this.locusId = locus.locusId;
-    this.selfId = locus.selfId;
-    this.mediaId = locus.mediaId;
+    this.mediaConnections = data.mediaConnections;
+    this.locusUrl = data.locusUrl;
+    this.locusId = data.locusId;
+    this.selfId = data.selfId;
+    this.mediaId = data.mediaId;
     this.hostId = mtgLocus.host ? mtgLocus.host.id : this.hostId;
-    this.locusInfo.initialSetup(mtgLocus);
+    this.locusInfo.initialSetup({
+      trigger: 'join-response',
+      locus: mtgLocus,
+      dataSets: data.dataSets,
+    });
   }
 
   /**
@@ -5429,6 +5455,20 @@ export default class Meeting extends StatelessWebexPlugin {
         shouldRetry = false;
       }
 
+      if (CallDiagnosticUtils.isBrowserMediaError(error)) {
+        shouldRetry = false;
+        // eslint-disable-next-line no-ex-assign
+        error = merge({
+          error: {
+            body: {
+              errorCode: CallDiagnosticUtils.getBrowserMediaErrorCode(error),
+              message: error?.message,
+              name: error?.name,
+            },
+          },
+        });
+      }
+
       // we only want to call leave if join was successful and this was a retry or we won't be doing any more retries
       if (joined && (isRetry || !shouldRetry)) {
         try {
@@ -5695,6 +5735,21 @@ export default class Meeting extends StatelessWebexPlugin {
     }
   }
 
+  /** Handles Locus LLM events
+   *
+   * @param {LocusLLMEvent} event - The Locus LLM event to process
+   * @returns {void}
+   */
+  private processLocusLLMEvent = (event: LocusLLMEvent): void => {
+    if (event.data.eventType === LOCUSEVENT.HASH_TREE_DATA_UPDATED) {
+      this.locusInfo.parse(this, event.data);
+    } else {
+      LoggerProxy.logger.warn(
+        `Meeting:index#processLocusLLMEvent --> Unknown event type: ${event.data.eventType}`
+      );
+    }
+  };
+
   /**
    * Callback called when a relay event is received from meeting LLM Connection
    * @param {RelayEvent} e Event object coming from LLM Connection
@@ -6066,6 +6121,46 @@ export default class Meeting extends StatelessWebexPlugin {
       });
   }
 
+  /** starts a timer that after a few minutes checks if
+   * the LLM connection is connected, if not it sends a metric
+   * @private
+   * @returns {void}
+   */
+  private startLLMHealthCheckTimer() {
+    // first cancel any existing timer
+    this.clearLLMHealthCheckTimer();
+
+    this.llmHealthCheckTimer = setTimeout(() => {
+      // @ts-ignore
+      const isConnected = this.webex.internal.llm.isConnected();
+
+      if (!isConnected) {
+        // @ts-ignore
+        const {hasEverConnected} = this.webex.internal.llm;
+
+        // only send metric if not connected - to avoid too many metrics
+        Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.LLM_HEALTHCHECK_FAILURE, {
+          correlation_id: this.correlationId,
+          hasEverConnected,
+        });
+      }
+
+      this.llmHealthCheckTimer = undefined;
+    }, LLM_HEALTHCHECK_TIMER_MS);
+  }
+
+  /**
+   * Clears the LLM health check timer
+   * @private
+   * @returns {void}
+   */
+  private clearLLMHealthCheckTimer() {
+    if (this.llmHealthCheckTimer) {
+      clearTimeout(this.llmHealthCheckTimer);
+      this.llmHealthCheckTimer = undefined;
+    }
+  }
+
   /**
    * Connects to low latency mercury and reconnects if the address has changed
    * It will also disconnect if called when the meeting has ended
@@ -6106,6 +6201,10 @@ export default class Meeting extends StatelessWebexPlugin {
       );
       // @ts-ignore - Fix type
       this.webex.internal.llm.off('event:relay.event', this.processRelayEvent);
+      // @ts-ignore - Fix type
+      this.webex.internal.llm.off(LOCUS_LLM_EVENT, this.processLocusLLMEvent);
+
+      this.clearLLMHealthCheckTimer();
     }
 
     if (!isJoined) {
@@ -6120,10 +6219,16 @@ export default class Meeting extends StatelessWebexPlugin {
         this.webex.internal.llm.off('event:relay.event', this.processRelayEvent);
         // @ts-ignore - Fix type
         this.webex.internal.llm.on('event:relay.event', this.processRelayEvent);
+        // @ts-ignore - Fix type
+        this.webex.internal.llm.off(LOCUS_LLM_EVENT, this.processLocusLLMEvent);
+        // @ts-ignore - Fix type
+        this.webex.internal.llm.on(LOCUS_LLM_EVENT, this.processLocusLLMEvent);
         LoggerProxy.logger.info(
           'Meeting:index#updateLLMConnection --> enabled to receive relay events!'
         );
 
+        this.startLLMHealthCheckTimer();
+
         return Promise.resolve(registerAndConnectResult);
       });
   }
@@ -7451,7 +7556,7 @@ export default class Meeting extends StatelessWebexPlugin {
         } seconds`
       );
 
-      const error = new Error('Timed out waiting for REMOTE SDP ANSWER');
+      const error = new SdpResponseTimeoutError();
 
       // @ts-ignore
       this.webex.internal.newMetrics.submitClientEvent({
@@ -9371,6 +9476,10 @@ export default class Meeting extends StatelessWebexPlugin {
 
     // @ts-ignore - fix types
     this.webex.internal.llm.off('event:relay.event', this.processRelayEvent);
+    // @ts-ignore - Fix type
+    this.webex.internal.llm.off(LOCUS_LLM_EVENT, this.processLocusLLMEvent);
+
+    this.clearLLMHealthCheckTimer();
   };
 
   /**

package/src/meeting/util.ts

@@ -31,6 +31,7 @@ const MeetingUtil = {
 
     // First todo: add check for existance
     parsed.locus = response.body.locus;
+    parsed.dataSets = response.body.dataSets;
     parsed.mediaConnections = response.body.mediaConnections;
     parsed.locusUrl = parsed.locus.url;
     parsed.locusId = parsed.locus.url.split('/').pop();

package/src/meetings/index.ts

@@ -1,5 +1,5 @@
 /* eslint no-shadow: ["error", { "allow": ["eventType"] }] */
-import {cloneDeep, clone} from 'lodash';
+import {cloneDeep, clone, set} from 'lodash';
 import '@webex/internal-plugin-mercury';
 import '@webex/internal-plugin-conversation';
 import '@webex/internal-plugin-metrics';
@@ -66,6 +66,9 @@ import JoinWebinarError from '../common/errors/join-webinar-error';
 import {SpaceIDDeprecatedError} from '../common/errors/webex-errors';
 import NoMeetingInfoError from '../common/errors/no-meeting-info';
 import JoinForbiddenError from '../common/errors/join-forbidden-error';
+import {HashTreeMessage} from '../hashTree/hashTreeParser';
+import {HashTreeObject} from '../hashTree/types';
+import {isSelf} from '../hashTree/utils';
 
 let mediaLogger;
 
@@ -94,6 +97,18 @@ class MediaLogger {
     LoggerProxy.logger.debug(...args);
   }
 }
+
+export type LocusEvent = {
+  eventType: LOCUSEVENT;
+
+  // fields populated for "classic" locus events (eventType = 'locus.difference' and others, see LOCUSEVENT)
+  locusUrl?: string;
+  locus?: any;
+
+  // fields populated for "hash tree" locus events (eventType = 'locus.state_message' - see LOCUSEVENT.HASH_TREE_DATA_UPDATED)
+  stateElementsMessage?: HashTreeMessage;
+};
+
 /**
  * Meetings Ready Event
  * Emitted when the meetings instance on webex is ready
@@ -406,29 +421,42 @@ export default class Meetings extends WebexPlugin {
    * @private
    * @memberof Meetings
    */
-  getCorrespondingMeetingByLocus(data) {
-    // getting meeting by correlationId. This will happen for the new event
-    // Either the locus
-    // TODO : Add check for the callBack Address
+  getCorrespondingMeetingByLocus(data: LocusEvent) {
+    const locusUrl =
+      data.stateElementsMessage?.locusUrl || // hash tree event
+      data.locusUrl; // classic event
+
+    // first try to find by locusUrl - that's the simplest and quickest way
+    const existingMeeting = this.meetingCollection.getByKey(MEETING_KEY.LOCUS_URL, locusUrl);
+
+    if (existingMeeting) {
+      return existingMeeting;
+    }
+
+    // if that didn't work, fallback to other fields like correlationId, sipUri, etc
+
+    // If the event is a hash tree event, we need to extract "self" object from it
+    // We don't care about the version, just need to find the meeting this event is for,
+    // so any hash tree object of type "self" will do
+    const hashTreeEventSelf = data.stateElementsMessage?.locusStateElements?.find(
+      (obj: HashTreeObject) => isSelf(obj)
+    )?.data;
+
+    const self = hashTreeEventSelf || data.locus?.self;
+
     return (
-      this.meetingCollection.getByKey(MEETING_KEY.LOCUS_URL, data.locusUrl) ||
       // @ts-ignore
       this.meetingCollection.getByKey(
         MEETING_KEY.CORRELATION_ID,
         // @ts-ignore
-        MeetingsUtil.checkForCorrelationId(this.webex.internal.device.url, data.locus)
+        MeetingsUtil.getCorrelationIdForDevice(this.webex.internal.device.url, self)
       ) ||
-      this.meetingCollection.getByKey(
-        MEETING_KEY.SIP_URI,
-        data.locus.self &&
-          data.locus.self.callbackInfo &&
-          data.locus.self.callbackInfo.callbackAddress
-      ) ||
-      (data.locus.info?.isUnifiedSpaceMeeting
+      this.meetingCollection.getByKey(MEETING_KEY.SIP_URI, self?.callbackInfo?.callbackAddress) ||
+      (data.locus?.info?.isUnifiedSpaceMeeting
         ? undefined
         : this.meetingCollection.getByKey(
             MEETING_KEY.CONVERSATION_URL,
-            data.locus.conversationUrl
+            data.locus?.conversationUrl
           )) ||
       this.meetingCollection.getByKey(MEETING_KEY.MEETINGNUMBER, data.locus?.info?.webExMeetingId)
     );
@@ -445,30 +473,33 @@ export default class Meetings extends WebexPlugin {
    * @private
    * @memberof Meetings
    */
-  private handleLocusEvent(data: {locusUrl: string; locus: any}, useRandomDelayForInfo = false) {
+  private handleLocusEvent(data: LocusEvent, useRandomDelayForInfo = false) {
     let meeting = this.getCorrespondingMeetingByLocus(data);
 
     // Special case when locus has got replaced, This only happend once if a replace locus exists
     // https://sqbu-github.cisco.com/WebExSquared/locus/wiki/Locus-changing-mid-call
 
-    if (!meeting && data.locus?.replaces?.length > 0) {
-      // Always the last element in the replace is the active one
-      meeting = this.meetingCollection.getByKey(
-        MEETING_KEY.LOCUS_URL,
-        data.locus.replaces[data.locus.replaces.length - 1].locusUrl
-      );
-    }
+    if (data.eventType !== LOCUSEVENT.HASH_TREE_DATA_UPDATED) {
+      if (!meeting && data.locus?.replaces?.length > 0) {
+        // Always the last element in the replace is the active one
+        meeting = this.meetingCollection.getByKey(
+          MEETING_KEY.LOCUS_URL,
+          data.locus.replaces[data.locus.replaces.length - 1].locusUrl
+        );
+      }
 
-    if (meeting && !MeetingsUtil.isBreakoutLocusDTO(data.locus)) {
-      meeting.locusInfo.updateMainSessionLocusCache(data.locus);
-    }
-    if (!this.isNeedHandleLocusDTO(meeting, data.locus)) {
-      LoggerProxy.logger.log(
-        `Meetings:index#handleLocusEvent --> doesn't need to process locus event`
-      );
+      if (meeting && !MeetingsUtil.isBreakoutLocusDTO(data.locus)) {
+        meeting.locusInfo.updateMainSessionLocusCache(data.locus);
+      }
+      if (!this.isNeedHandleLocusDTO(meeting, data.locus)) {
+        LoggerProxy.logger.log(
+          `Meetings:index#handleLocusEvent --> doesn't need to process locus event`
+        );
 
-      return;
+        return;
+      }
     }
+
     if (!meeting) {
       // TODO: create meeting when we get a meeting object
       // const checkForEnded = (locus) => {
@@ -489,42 +520,65 @@ export default class Meetings extends WebexPlugin {
       // };
       // rather then locus object change to locus url
 
-      if (
-        data.locus &&
-        data.locus.fullState &&
-        data.locus.fullState.state === LOCUS.STATE.INACTIVE
-      ) {
-        // just ignore the event as its already ended and not active
-        LoggerProxy.logger.warn(
-          'Meetings:index#handleLocusEvent --> Locus event received for meeting, after it was ended.'
-        );
+      if (data.eventType !== LOCUSEVENT.HASH_TREE_DATA_UPDATED) {
+        if (
+          data.locus &&
+          data.locus.fullState &&
+          data.locus.fullState.state === LOCUS.STATE.INACTIVE
+        ) {
+          // just ignore the event as its already ended and not active
+          LoggerProxy.logger.warn(
+            'Meetings:index#handleLocusEvent --> Locus event received for meeting, after it was ended.'
+          );
 
-        return;
-      }
+          return;
+        }
 
-      // When its wireless share or guest and user leaves the meeting we dont have to keep the meeting object
-      // Any future events will be neglected
+        // When its wireless share or guest and user leaves the meeting we dont have to keep the meeting object
+        // Any future events will be neglected
+
+        if (
+          data.locus &&
+          data.locus.self &&
+          data.locus.self.state === _LEFT_ &&
+          data.locus.self.removed === true
+        ) {
+          // just ignore the event as its already ended and not active
+          LoggerProxy.logger.warn(
+            'Meetings:index#handleLocusEvent --> Locus event received for meeting, after it was ended.'
+          );
 
-      if (
-        data.locus &&
-        data.locus.self &&
-        data.locus.self.state === _LEFT_ &&
-        data.locus.self.removed === true
-      ) {
-        // just ignore the event as its already ended and not active
-        LoggerProxy.logger.warn(
-          'Meetings:index#handleLocusEvent --> Locus event received for meeting, after it was ended.'
-        );
+          return;
+        }
+      }
 
-        return;
+      if (data.eventType === LOCUSEVENT.HASH_TREE_DATA_UPDATED) {
+        // in hash tree messages we don't ge the locus object, but the meeting constructor needs at least locus.url
+        set(data, 'locus.url', data.stateElementsMessage.locusUrl);
       }
 
       this.create(data.locus, DESTINATION_TYPE.LOCUS_ID, useRandomDelayForInfo)
-        .then((newMeeting) => {
+        .then(async (newMeeting) => {
           meeting = newMeeting;
 
-          // It's a new meeting so initialize the locus data
-          meeting.locusInfo.initialSetup(data.locus);
+          try {
+            // It's a new meeting so initialize the locus data
+            await meeting.locusInfo.initialSetup({
+              trigger:
+                data.eventType === LOCUSEVENT.SDK_LOCUS_FROM_SYNC_MEETINGS
+                  ? 'get-loci-response'
+                  : 'locus-message',
+              locus: data.locus,
+              hashTreeMessage: data.stateElementsMessage,
+            });
+          } catch (error) {
+            LoggerProxy.logger.warn(
+              `Meetings:index#handleLocusEvent --> Error initializing locus data: ${error.message}`
+            );
+            // @ts-ignore
+            this.destroy(meeting, MEETING_REMOVED_REASON.LOCUS_DTO_SYNC_FAILED);
+          }
+
           this.checkHandleBreakoutLocus(data.locus);
         })
         .catch((e) => {
@@ -1739,6 +1793,7 @@ export default class Meetings extends WebexPlugin {
           lociToUpdate.forEach((locus) => {
             activeLocusUrl.push(locus.url);
             this.handleLocusEvent({
+              eventType: LOCUSEVENT.SDK_LOCUS_FROM_SYNC_MEETINGS,
               locus,
               locusUrl: locus.url,
             });
@@ -1786,6 +1841,7 @@ export default class Meetings extends WebexPlugin {
         (mainLocus) => mainLocus.controls?.breakout?.url === breakoutLocus.controls?.breakout?.url
       );
       const existCorrespondingMeeting = this.getCorrespondingMeetingByLocus({
+        eventType: LOCUSEVENT.SDK_NO_EVENT,
         locus: breakoutLocus,
         locusUrl: breakoutLocus.url,
       });
@@ -1831,7 +1887,11 @@ export default class Meetings extends WebexPlugin {
     }
 
     const associateBreakoutLocus = this.breakoutLocusForHandleLater[existIndex];
-    this.handleLocusEvent({locus: associateBreakoutLocus, locusUrl: associateBreakoutLocus.url});
+    this.handleLocusEvent({
+      eventType: LOCUSEVENT.SDK_NO_EVENT,
+      locus: associateBreakoutLocus,
+      locusUrl: associateBreakoutLocus.url,
+    });
     this.breakoutLocusForHandleLater.splice(existIndex, 1);
   }
 

package/src/meetings/util.ts

@@ -117,15 +117,16 @@ MeetingsUtil.getMediaServerIp = (sdp) => {
   return mediaServerIp;
 };
 
-MeetingsUtil.checkForCorrelationId = (deviceUrl, locus) => {
-  let devices = [];
-
-  if (locus) {
-    if (locus && locus.self && locus.self.devices) {
-      devices = locus.self.devices;
-    }
-
-    const foundDevice = devices.find((device) => device.url === deviceUrl);
+/**
+ * Finds correlationId of a device from locus self devices array
+ * that matches the given deviceUrl
+ * @param {string} deviceUrl
+ * @param {object} locusSelf
+ * @returns {string|false} correlationId or false if not found
+ */
+MeetingsUtil.getCorrelationIdForDevice = (deviceUrl: string, locusSelf: any) => {
+  if (locusSelf?.devices) {
+    const foundDevice = locusSelf?.devices.find((device) => device.url === deviceUrl);
 
     if (foundDevice && foundDevice.correlationId) {
       return foundDevice.correlationId;

package/src/metrics/constants.ts

@@ -21,6 +21,7 @@ const BEHAVIORAL_METRICS = {
   GET_DISPLAY_MEDIA_FAILURE: 'js_sdk_get_display_media_failures',
   JOIN_WITH_MEDIA_FAILURE: 'js_sdk_join_with_media_failures',
   LLM_CONNECTION_AFTER_JOIN_FAILURE: 'js_sdk_llm_connection_after_join_failure',
+  LLM_HEALTHCHECK_FAILURE: 'js_sdk_llm_healthcheck_failure',
   RECEIVE_TRANSCRIPTION_AFTER_JOIN_FAILURE: 'js_sdk_receive_transcription_after_join_failure',
 
   DISCONNECT_DUE_TO_INACTIVITY: 'js_sdk_disconnect_due_to_inactivity',
@@ -87,6 +88,8 @@ const BEHAVIORAL_METRICS = {
   VERIFY_REGISTRATION_ID_ERROR: 'js_sdk_verify_registrationId_error',
   JOIN_FORBIDDEN_ERROR: 'js_sdk_join_forbidden_error',
   MEDIA_ISSUE_DETECTED: 'js_sdk_media_issue_detected',
+  LOCUS_CLASSIC_VS_HASH_TREE_MISMATCH: 'js_sdk_locus_classic_vs_hash_tree_mismatch',
+  LOCUS_HASH_TREE_UNSUPPORTED_OPERATION: 'js_sdk_locus_hash_tree_unsupported_operation',
 };
 
 export {BEHAVIORAL_METRICS as default};