@webex/plugin-meetings 3.8.1 → 3.9.0-multiple-llm.1

package/src/locus-info/index.ts

@@ -31,6 +31,51 @@ import LocusDeltaParser from './parser';
 import Metrics from '../metrics';
 import BEHAVIORAL_METRICS from '../metrics/constants';
 
+export type LocusDTO = {
+  controls?: any;
+  fullState?: {
+    active: boolean;
+    count: number;
+    lastActive: string;
+    locked: boolean;
+    sessionId: string;
+    seessionIds: string[];
+    startTime: number;
+    state: string;
+    type: string;
+  };
+  host?: {
+    id: string;
+    incomingCallProtocols: any[];
+    isExternal: boolean;
+    name: string;
+    orgId: string;
+  };
+  info?: any;
+  links?: any;
+  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;
+};
+
+export type LocusApiResponseBody = {
+  locus: LocusDTO; // this LocusDTO here might not be the full one (for example it won't have all the participants, but it should have self)
+};
+
 /**
  * @description LocusInfo extends ChildEmitter to convert locusInfo info a private emitter to parent object
  * @export
@@ -48,7 +93,6 @@ export default class LocusInfo extends EventsScope {
   aclUrl: any;
   baseSequence: any;
   created: any;
-  deltaParticipants: any;
   identities: any;
   membership: any;
   participants: any;
@@ -94,18 +138,26 @@ export default class LocusInfo extends EventsScope {
    * Does a Locus sync. It tries to get the latest delta DTO or if it can't, it falls back to getting the full Locus DTO.
    *
    * @param {Meeting} meeting
+   * @param {boolean} isLocusUrlChanged
+   * @param {Locus} locus
    * @returns {undefined}
    */
-  private doLocusSync(meeting: any) {
-    let isDelta;
+  private doLocusSync(meeting: any, isLocusUrlChanged: boolean, locus: any) {
     let url;
-
-    if (this.locusParser.workingCopy.syncUrl) {
+    let isDelta = false;
+    let meetingDestroyed = false;
+
+    if (isLocusUrlChanged) {
+      // for the locus url changed case from breakout to main session, we should always do a full sync, in this case, the url from locus is always on main session,
+      // so use the main session locus url to get the full locus(full participants list in the response).
+      // for the locus url changed case from main session to breakout, we don't need to care about it here,
+      // because it is a USE_INCOMING case, it will not be executed here.
+      url = locus.url;
+    } else if (this.locusParser.workingCopy?.syncUrl) {
       url = this.locusParser.workingCopy.syncUrl;
       isDelta = true;
     } else {
       url = meeting.locusUrl;
-      isDelta = false;
     }
 
     LoggerProxy.logger.info(
@@ -134,35 +186,77 @@ export default class LocusInfo extends EventsScope {
 
           isDelta = false;
 
-          return meeting.meetingRequest.getLocusDTO({url: meeting.locusUrl}).catch((err) => {
-            LoggerProxy.logger.info(
-              'Locus-info:index#doLocusSync --> fallback full sync failed, destroying the meeting'
-            );
-            this.webex.meetings.destroy(meeting, MEETING_REMOVED_REASON.LOCUS_DTO_SYNC_FAILED);
-            throw err;
-          });
+          // Locus sometimes returns 403, for example if meeting has ended, no point trying the fallback to full sync in that case
+          if (e.statusCode !== 403) {
+            return meeting.meetingRequest.getLocusDTO({url: meeting.locusUrl}).catch((err) => {
+              LoggerProxy.logger.info(
+                'Locus-info:index#doLocusSync --> fallback full sync failed, destroying the meeting'
+              );
+              this.webex.meetings.destroy(meeting, MEETING_REMOVED_REASON.LOCUS_DTO_SYNC_FAILED);
+              meetingDestroyed = true;
+              throw err;
+            });
+          }
+          LoggerProxy.logger.info(
+            'Locus-info:index#doLocusSync --> got 403 from Locus, skipping fallback to full sync, destroying the meeting'
+          );
+        } else {
+          LoggerProxy.logger.info(
+            'Locus-info:index#doLocusSync --> fallback full sync failed, destroying the meeting'
+          );
         }
-        LoggerProxy.logger.info(
-          'Locus-info:index#doLocusSync --> fallback full sync failed, destroying the meeting'
-        );
         this.webex.meetings.destroy(meeting, MEETING_REMOVED_REASON.LOCUS_DTO_SYNC_FAILED);
+        meetingDestroyed = true;
         throw e;
       })
       .then((res) => {
-        if (isDelta) {
-          if (!isEmpty(res.body)) {
-            meeting.locusInfo.handleLocusDelta(res.body, meeting);
-          } else {
+        if (isEmpty(res.body)) {
+          if (isDelta) {
             LoggerProxy.logger.info(
               'Locus-info:index#doLocusSync --> received empty body from syncUrl, so we already have latest Locus DTO'
             );
+          } else {
+            LoggerProxy.logger.info(
+              'Locus-info:index#doLocusSync --> received empty body from full DTO sync request'
+            );
           }
-        } else {
-          meeting.locusInfo.onFullLocus(res.body);
+
+          return;
+        }
+
+        if (isDelta) {
+          if (res.body.baseSequence) {
+            meeting.locusInfo.handleLocusDelta(res.body, meeting);
+
+            return;
+          }
+          // in some cases Locus might return us full DTO even when we asked for a delta
+          LoggerProxy.logger.info(
+            'Locus-info:index#doLocusSync --> got full DTO when we asked for delta'
+          );
+        }
+        meeting.locusInfo.onFullLocus(res.body);
+      })
+      .catch((e) => {
+        LoggerProxy.logger.info(
+          `Locus-info:index#doLocusSync --> getLocusDTO succeeded but failed to handle result, locus parser will resume but not all data may be synced (${e.toString()})`
+        );
+
+        Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.LOCUS_SYNC_HANDLING_FAILED, {
+          correlationId: meeting.correlationId,
+          url,
+          reason: e.message,
+          errorName: e.name,
+          stack: e.stack,
+          code: e.code,
+        });
+      })
+      .finally(() => {
+        if (!meetingDestroyed) {
+          // Notify parser to resume processing delta events.
+          // Any deltas in the queue that have now been superseded by this sync will simply be ignored
+          this.locusParser.resume();
         }
-        // Notify parser to resume processing delta events.
-        // Any deltas in the queue that have now been superseded by this sync will simply be ignored
-        this.locusParser.resume();
       });
   }
 
@@ -175,6 +269,7 @@ export default class LocusInfo extends EventsScope {
    */
   applyLocusDeltaData(action: string, locus: any, meeting: any) {
     const {DESYNC, USE_CURRENT, USE_INCOMING, WAIT, LOCUS_URL_CHANGED} = LocusDeltaParser.loci;
+    const isLocusUrlChanged = action === LOCUS_URL_CHANGED;
 
     switch (action) {
       case USE_INCOMING:
@@ -186,7 +281,7 @@ export default class LocusInfo extends EventsScope {
         break;
       case DESYNC:
       case LOCUS_URL_CHANGED:
-        this.doLocusSync(meeting);
+        this.doLocusSync(meeting, isLocusUrlChanged, locus);
         break;
       default:
         LoggerProxy.logger.info(
@@ -241,21 +336,10 @@ export default class LocusInfo extends EventsScope {
      * @property {Object} person - Contains person data.
      */
 
-    /**
-     * Stored participant changes between the last event and the current event.
-     * All previously stored events are overwritten between events.
-     *
-     * @instance
-     * @type {Array<DeltaParticipant>}
-     * @private
-     * @member LocusInfo
-     */
-    this.deltaParticipants = [];
-
     this.updateLocusCache(locus);
     // above section only updates the locusInfo object
     // The below section makes sure it updates the locusInfo as well as updates the meeting object
-    this.updateParticipants(locus.participants);
+    this.updateParticipants(locus.participants, []);
     // For 1:1 space meeting the conversation Url does not exist in locus.conversation
     this.updateConversationUrl(locus.conversationUrl, locus.info);
     this.updateControls(locus.controls, locus.self);
@@ -284,6 +368,16 @@ export default class LocusInfo extends EventsScope {
     this.emitChange = true;
   }
 
+  /**
+   * Handles HTTP response from Locus API call.
+   * @param {Meeting} meeting meeting object
+   * @param {LocusApiResponseBody} responseBody body of the http response from Locus API call
+   * @returns {void}
+   */
+  handleLocusAPIResponse(meeting, responseBody: LocusApiResponseBody): void {
+    this.handleLocusDelta(responseBody.locus, meeting);
+  }
+
   /**
    * @param {Meeting} meeting
    * @param {Object} data
@@ -296,6 +390,8 @@ export default class LocusInfo extends EventsScope {
     const locus = this.getTheLocusToUpdate(data.locus);
     LoggerProxy.logger.info(`Locus-info:index#parse --> received locus data: ${eventType}`);
 
+    locus.jsSdkMeta = {removedParticipantIds: []};
+
     switch (eventType) {
       case LOCUSEVENT.PARTICIPANT_JOIN:
       case LOCUSEVENT.PARTICIPANT_LEFT:
@@ -357,12 +453,15 @@ export default class LocusInfo extends EventsScope {
       return;
     }
 
-    this.updateParticipantDeltas(locus.participants);
     this.scheduledMeeting = locus.meeting || null;
     this.participants = locus.participants;
     const isReplaceMembers = ControlsUtils.isNeedReplaceMembers(this.controls, locus.controls);
     this.updateLocusInfo(locus);
-    this.updateParticipants(locus.participants, isReplaceMembers);
+    this.updateParticipants(
+      locus.participants,
+      locus.jsSdkMeta?.removedParticipantIds,
+      isReplaceMembers
+    );
     this.isMeetingActive();
     this.handleOneOnOneEvent(eventType);
     this.updateEmbeddedApps(locus.embeddedApps);
@@ -424,7 +523,11 @@ export default class LocusInfo extends EventsScope {
     const isReplaceMembers = ControlsUtils.isNeedReplaceMembers(this.controls, locus.controls);
     this.mergeParticipants(this.participants, locus.participants);
     this.updateLocusInfo(locus);
-    this.updateParticipants(locus.participants, isReplaceMembers);
+    this.updateParticipants(
+      locus.participants,
+      locus.jsSdkMeta?.removedParticipantIds,
+      isReplaceMembers
+    );
     this.isMeetingActive();
   }
 
@@ -446,12 +549,12 @@ export default class LocusInfo extends EventsScope {
     this.updateCreated(locus.created);
     this.updateFullState(locus.fullState);
     this.updateHostInfo(locus.host);
+    this.updateLocusUrl(locus.url);
     this.updateMeetingInfo(locus.info, locus.self);
     this.updateMediaShares(locus.mediaShares);
     this.updateParticipantsUrl(locus.participantsUrl);
     this.updateReplace(locus.replace);
     this.updateSelf(locus.self);
-    this.updateLocusUrl(locus.url);
     this.updateAclUrl(locus.aclUrl);
     this.updateBasequence(locus.baseSequence);
     this.updateSequence(locus.sequence);
@@ -712,63 +815,15 @@ export default class LocusInfo extends EventsScope {
     }
   }
 
-  /**
-   * Update the deltaParticipants property of this object based on a list of
-   * provided participants.
-   *
-   * @param {Array} [participants] - The participants to update against.
-   * @returns {void}
-   */
-  updateParticipantDeltas(participants: Array<any> = []) {
-    // Used to find a participant within a participants collection.
-    const findParticipant = (participant, collection) =>
-      collection.find((item) => item.person.id === participant.person.id);
-
-    // Generates an object that indicates which state properties have changed.
-    const generateDelta = (prevState: any = {}, newState: any = {}) => {
-      // Setup deltas.
-      const deltas = {
-        audioStatus: prevState.audioStatus !== newState.audioStatus,
-        videoSlidesStatus: prevState.videoSlidesStatus !== newState.videoSlidesStatus,
-        videoStatus: prevState.videoStatus !== newState.videoStatus,
-      };
-
-      // Clean the object
-      Object.keys(deltas).forEach((key) => {
-        if (deltas[key] !== true) {
-          delete deltas[key];
-        }
-      });
-
-      return deltas;
-    };
-
-    this.deltaParticipants = participants.reduce((collection, participant) => {
-      const existingParticipant = findParticipant(participant, this.participants || []) || {};
-
-      const delta = generateDelta(existingParticipant.status, participant.status);
-
-      const changed = Object.keys(delta).length > 0;
-
-      if (changed) {
-        collection.push({
-          person: participant.person,
-          delta,
-        });
-      }
-
-      return collection;
-    }, []);
-  }
-
   /**
    * update meeting's members
    * @param {Object} participants new participants object
+   * @param {Array} removedParticipantIds list of removed participants
    * @param {Boolean} isReplace is replace the whole members
    * @returns {Array} updatedParticipants
    * @memberof LocusInfo
    */
-  updateParticipants(participants: object, isReplace?: boolean) {
+  updateParticipants(participants: object, removedParticipantIds?: string[], isReplace?: boolean) {
     this.emitScoped(
       {
         file: 'locus-info',
@@ -777,6 +832,7 @@ export default class LocusInfo extends EventsScope {
       EVENTS.LOCUS_INFO_UPDATE_PARTICIPANTS,
       {
         participants,
+        removedParticipantIds,
         recordingId: this.parsedLocus.controls && this.parsedLocus.controls.record?.modifiedBy,
         selfIdentity: this.parsedLocus.self && this.parsedLocus.self.selfIdentity,
         selfId: this.parsedLocus.self && this.parsedLocus.self.selfId,
@@ -818,6 +874,7 @@ export default class LocusInfo extends EventsScope {
           hasRecordingPausedChanged,
           hasMeetingContainerChanged,
           hasTranscribeChanged,
+          hasTranscribeSpokenLanguageChanged,
           hasManualCaptionChanged,
           hasEntryExitToneChanged,
           hasBreakoutChanged,
@@ -837,6 +894,7 @@ export default class LocusInfo extends EventsScope {
           hasStageViewChanged,
           hasAnnotationControlChanged,
           hasRemoteDesktopControlChanged,
+          hasPollingQAControlChanged,
         },
         current,
       } = ControlsUtils.getControls(this.controls, controls);
@@ -956,6 +1014,21 @@ export default class LocusInfo extends EventsScope {
         );
       }
 
+      if (hasTranscribeSpokenLanguageChanged) {
+        const {spokenLanguage} = current.transcribe;
+
+        this.emitScoped(
+          {
+            file: 'locus-info',
+            function: 'updateControls',
+          },
+          LOCUSINFO.EVENTS.CONTROLS_MEETING_TRANSCRIPTION_SPOKEN_LANGUAGE_UPDATED,
+          {
+            spokenLanguage,
+          }
+        );
+      }
+
       if (hasManualCaptionChanged) {
         const {enabled} = current.manualCaptionControl;
 
@@ -1088,6 +1161,14 @@ export default class LocusInfo extends EventsScope {
         );
       }
 
+      if (hasPollingQAControlChanged) {
+        this.emitScoped(
+          {file: 'locus-info', function: 'updateControls'},
+          LOCUSINFO.EVENTS.CONTROLS_POLLING_QA_CHANGED,
+          {state: current.pollingQAControl}
+        );
+      }
+
       this.controls = controls;
     }
   }
@@ -1248,10 +1329,7 @@ export default class LocusInfo extends EventsScope {
    */
   updateMeetingInfo(info: object, self?: object) {
     const roles = self ? SelfUtils.getRoles(self) : this.parsedLocus.self?.roles || [];
-    if (
-      (info && !isEqual(this.info, info)) ||
-      (roles.length && !isEqual(this.roles, roles) && info)
-    ) {
+    if ((info && !isEqual(this.info, info)) || (!isEqual(this.roles, roles) && info)) {
       const isJoined = SelfUtils.isJoined(self || this.parsedLocus.self);
       const parsedInfo = InfoUtils.getInfos(this.parsedLocus.info, info, roles, isJoined);
 

package/src/locus-info/parser.ts

@@ -728,13 +728,17 @@ export default class Parser {
         break;
 
       case USE_INCOMING:
-      case LOCUS_URL_CHANGED:
         // update working copy for future comparisons.
         // Note: The working copy of parser gets updated in .onFullLocus()
         // and here when USE_INCOMING or LOCUS_URL_CHANGED locus.
         this.workingCopy = newLoci;
         break;
 
+      case LOCUS_URL_CHANGED:
+        // clear the working copy completely, do a full locus sync
+        this.workingCopy = null;
+        break;
+
       case WAIT:
         // we've taken newLoci from the front of the queue, so put it back there as we have to wait
         // for the one that should be in front of it, before we can process it

package/src/media/index.ts

@@ -239,8 +239,8 @@ Media.createMediaConnection = (
         screenShareAudio: shareAudioStream?.outputStream?.getTracks()[0], // TODO: add type for screenShareAudio in internal-media-core SPARK-446923
       } as unknown,
       direction: {
-        audio: Media.getDirection(true, mediaDirection.receiveAudio, mediaDirection.sendAudio),
-        video: Media.getDirection(true, mediaDirection.receiveVideo, mediaDirection.sendVideo),
+        audio: Media.getDirection(false, mediaDirection.receiveAudio, mediaDirection.sendAudio),
+        video: Media.getDirection(false, mediaDirection.receiveVideo, mediaDirection.sendVideo),
         screenShareVideo: Media.getDirection(
           false,
           mediaDirection.receiveShare,

package/src/media/properties.ts

@@ -9,9 +9,12 @@ import {
 
 import {parse} from '@webex/ts-sdp';
 import {ClientEvent} from '@webex/internal-plugin-metrics';
+import {throttle} from 'lodash';
+import Metrics from '../metrics';
 import {MEETINGS, QUALITY_LEVELS} from '../constants';
 import LoggerProxy from '../common/logs/logger-proxy';
 import MediaConnectionAwaiter from './MediaConnectionAwaiter';
+import BEHAVIORAL_METRICS from '../metrics/constants';
 
 export type MediaDirection = {
   sendAudio: boolean;
@@ -41,6 +44,8 @@ export default class MediaProperties {
   videoDeviceId: any;
   videoStream?: LocalCameraStream;
   namespace = MEETINGS;
+  mediaIssueCounters: {[key: string]: number} = {};
+  throttledSendMediaIssueMetric: ReturnType<typeof throttle>;
 
   /**
    * @param {Object} [options] -- to auto construct
@@ -66,6 +71,15 @@ export default class MediaProperties {
     this.remoteQualityLevel = QUALITY_LEVELS.HIGH;
     this.mediaSettings = {};
     this.videoDeviceId = null;
+
+    this.throttledSendMediaIssueMetric = throttle((eventPayload) => {
+      Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.MEDIA_ISSUE_DETECTED, {
+        ...eventPayload,
+      });
+      Object.keys(this.mediaIssueCounters).forEach((key) => {
+        this.mediaIssueCounters[key] = 0;
+      });
+    }, 1000 * 60 * 5); // at most once every 5 minutes
   }
 
   /**
@@ -139,8 +153,14 @@ export default class MediaProperties {
     this.videoDeviceId = deviceId;
   }
 
+  /**
+   * Clears the webrtcMediaConnection. This method should be called after
+   * peer connection is closed and no longer needed.
+   * @returns {void}
+   */
   unsetPeerConnection() {
     this.webrtcMediaConnection = null;
+    this.throttledSendMediaIssueMetric.flush();
   }
 
   /**
@@ -424,4 +444,27 @@ export default class MediaProperties {
       };
     }
   }
+
+  /**
+   * Sends a metric about a media issue. Metrics are throttled so that we don't
+   * send too many of them, but include a count so that we know how many issues
+   * were detected.
+   *
+   * @param {string} issueType
+   * @param {string} issueSubType
+   * @param {string} correlationId
+   * @returns {void}
+   */
+  public sendMediaIssueMetric(issueType: string, issueSubType: string, correlationId) {
+    const key = `${issueType}_${issueSubType}`;
+
+    const count = (this.mediaIssueCounters[key] || 0) + 1;
+
+    this.mediaIssueCounters[key] = count;
+
+    this.throttledSendMediaIssueMetric({
+      correlationId,
+      ...this.mediaIssueCounters,
+    });
+  }
 }

package/src/meeting/brbState.ts

@@ -58,7 +58,13 @@ export class BrbState {
   public enable(enabled: boolean, sendSlotManager: SendSlotManager) {
     this.state.client.enabled = enabled;
 
-    return this.applyClientStateToServer(sendSlotManager);
+    // Don't set the source state override if enabling brb fails
+    return this.applyClientStateToServer(sendSlotManager).then(() => {
+      sendSlotManager.setSourceStateOverride(
+        MediaType.VideoMain,
+        this.state.client.enabled ? 'away' : null
+      );
+    });
   }
 
   /**
@@ -92,7 +98,7 @@ export class BrbState {
 
     this.state.syncToServerInProgress = true;
 
-    return this.sendLocalBrbStateToServer(sendSlotManager)
+    return this.sendLocalBrbStateToServer()
       .then(() => {
         this.state.syncToServerInProgress = false;
 
@@ -109,19 +115,20 @@ export class BrbState {
         // need to check if a new sync is required, because this.state.client may have changed while we were doing the current sync
         this.applyClientStateToServer(sendSlotManager);
       })
-      .catch((e) => {
+      .catch((error) => {
         this.state.syncToServerInProgress = false;
-        LoggerProxy.logger.warn(`Meeting:brbState#applyClientStateToServer: error: ${e}`);
+        LoggerProxy.logger.warn(`Meeting:brbState#applyClientStateToServer: Error: ${error}`);
+
+        return Promise.reject(error);
       });
   }
 
   /**
    * Send the local brb state to the server
    *
-   * @param {SendSlotManager} sendSlotManager
    * @returns {Promise}
    */
-  private async sendLocalBrbStateToServer(sendSlotManager: SendSlotManager) {
+  private async sendLocalBrbStateToServer() {
     const {enabled} = this.state.client;
 
     if (!this.meeting.isMultistream) {
@@ -151,9 +158,6 @@ export class BrbState {
         deviceUrl: this.meeting.deviceUrl,
         selfId: this.meeting.selfId,
       })
-      .then(() => {
-        sendSlotManager.setSourceStateOverride(MediaType.VideoMain, enabled ? 'away' : null);
-      })
       .catch((error) => {
         LoggerProxy.logger.error('Meeting:brbState#sendLocalBrbStateToServer: Error ', error);
 

package/src/meeting/in-meeting-actions.ts

@@ -38,8 +38,13 @@ interface IInMeetingActions {
   isClosedCaptionActive?: boolean;
   canStartManualCaption?: boolean;
   canStopManualCaption?: boolean;
+  isLocalRecordingStarted?: boolean;
+  isLocalRecordingStopped?: boolean;
+  isLocalRecordingPaused?: boolean;
+
   isManualCaptionActive?: boolean;
   isSaveTranscriptsEnabled?: boolean;
+  isSpokenLanguageAutoDetectionEnabled?: boolean;
   isWebexAssistantActive?: boolean;
   canViewCaptionPanel?: boolean;
   isRealTimeTranslationEnabled?: boolean;
@@ -107,6 +112,8 @@ interface IInMeetingActions {
   canEnableRemoteDesktopControl?: boolean;
   canDisableRemoteDesktopControl?: boolean;
   canMoveToLobby?: boolean;
+  canEnablePollingQA?: boolean;
+  canDisablePollingQA?: boolean;
 }
 
 /**
@@ -171,10 +178,18 @@ export default class InMeetingActions implements IInMeetingActions {
 
   canStopManualCaption = null;
 
+  isLocalRecordingStopped = null;
+
+  isLocalRecordingStarted = null;
+
+  isLocalRecordingPaused = null;
+
   isManualCaptionActive = null;
 
   isSaveTranscriptsEnabled = null;
 
+  isSpokenLanguageAutoDetectionEnabled = null;
+
   isWebexAssistantActive = null;
 
   canViewCaptionPanel = null;
@@ -309,6 +324,10 @@ export default class InMeetingActions implements IInMeetingActions {
 
   canMoveToLobby = null;
 
+  canEnablePollingQA = null;
+
+  canDisablePollingQA = null;
+
   /**
    * Returns all meeting action options
    * @returns {Object}
@@ -341,9 +360,13 @@ export default class InMeetingActions implements IInMeetingActions {
     canStopTranscribing: this.canStopTranscribing,
     isClosedCaptionActive: this.isClosedCaptionActive,
     canStartManualCaption: this.canStartManualCaption,
+    isLocalRecordingStarted: this.isLocalRecordingStarted,
+    isLocalRecordingStopped: this.isLocalRecordingStopped,
+    isLocalRecordingPaused: this.isLocalRecordingPaused,
     canStopManualCaption: this.canStopManualCaption,
     isManualCaptionActive: this.isManualCaptionActive,
     isSaveTranscriptsEnabled: this.isSaveTranscriptsEnabled,
+    isSpokenLanguageAutoDetectionEnabled: this.isSpokenLanguageAutoDetectionEnabled,
     isWebexAssistantActive: this.isWebexAssistantActive,
     canViewCaptionPanel: this.canViewCaptionPanel,
     isRealTimeTranslationEnabled: this.isRealTimeTranslationEnabled,
@@ -411,6 +434,8 @@ export default class InMeetingActions implements IInMeetingActions {
     canEnableRemoteDesktopControl: this.canEnableRemoteDesktopControl,
     canDisableRemoteDesktopControl: this.canDisableRemoteDesktopControl,
     canMoveToLobby: this.canMoveToLobby,
+    canEnablePollingQA: this.canEnablePollingQA,
+    canDisablePollingQA: this.canDisablePollingQA,
   });
 
   /**