@webex/plugin-meetings 3.11.0 → 3.12.0

package/src/meeting/util.ts

@@ -1,4 +1,5 @@
 import {LocalCameraStream, LocalMicrophoneStream} from '@webex/media-helpers';
+import url from 'url';
 
 import {cloneDeep} from 'lodash';
 import {MeetingNotActiveError, UserNotJoinedError} from '../common/errors/webex-errors';
@@ -24,6 +25,7 @@ import PermissionError from '../common/errors/permission';
 import PasswordError from '../common/errors/password-error';
 import CaptchaError from '../common/errors/captcha-error';
 import Trigger from '../common/events/trigger-proxy';
+import {ServerRoles} from '../member/types';
 
 const MeetingUtil = {
   parseLocusJoin: (response) => {
@@ -32,6 +34,7 @@ const MeetingUtil = {
     // First todo: add check for existance
     parsed.locus = response.body.locus;
     parsed.dataSets = response.body.dataSets;
+    parsed.metadata = response.body.metaData;
     parsed.mediaConnections = response.body.mediaConnections;
     parsed.locusUrl = parsed.locus.url;
     parsed.locusId = parsed.locus.url.split('/').pop();
@@ -47,6 +50,124 @@ const MeetingUtil = {
     return parsed;
   },
 
+  /**
+   * Sanitizes a WebSocket URL by extracting only protocol, host, and pathname
+   * Returns concatenated protocol + host + pathname for safe logging
+   * Note: This is used for logging only; URL matching uses partial matching via _urlsPartiallyMatch
+   * @param {string} urlString - The URL to sanitize
+   * @returns {string} Sanitized URL or empty string if parsing fails
+   */
+  sanitizeWebSocketUrl: (urlString: string): string => {
+    if (!urlString || typeof urlString !== 'string') {
+      return '';
+    }
+
+    try {
+      const parsedUrl = url.parse(urlString);
+      const protocol = parsedUrl.protocol || '';
+      const host = parsedUrl.host || '';
+
+      // If we don't have at least protocol and host, it's not a valid URL
+      if (!protocol || !host) {
+        return '';
+      }
+
+      const pathname = parsedUrl.pathname || '';
+
+      // Strip trailing slash if pathname is just '/'
+      const normalizedPathname = pathname === '/' ? '' : pathname;
+
+      return `${protocol}//${host}${normalizedPathname}`;
+    } catch (error) {
+      LoggerProxy.logger.warn(
+        `Meeting:util#sanitizeWebSocketUrl --> unable to parse URL: ${error}`
+      );
+
+      return '';
+    }
+  },
+
+  /**
+   * Checks if two URLs partially match using an endsWith approach
+   * Combines host and pathname, then checks if one ends with the other
+   * This handles cases where one URL goes through a proxy (e.g., /webproxy/) while the other is direct
+   * @param {string} url1 - First URL to compare
+   * @param {string} url2 - Second URL to compare
+   * @returns {boolean} True if one URL path ends with the other (partial match), false otherwise
+   */
+  _urlsPartiallyMatch: (url1: string, url2: string): boolean => {
+    if (!url1 || !url2) {
+      return false;
+    }
+
+    try {
+      const parsedUrl1 = url.parse(url1);
+      const parsedUrl2 = url.parse(url2);
+
+      const host1 = parsedUrl1.host || '';
+      const host2 = parsedUrl2.host || '';
+      const pathname1 = parsedUrl1.pathname || '';
+      const pathname2 = parsedUrl2.pathname || '';
+
+      // If either failed to parse, they don't match
+      if (!host1 || !host2 || !pathname1 || !pathname2) {
+        return false;
+      }
+
+      // Combine host and pathname for comparison
+      const combined1 = host1 + pathname1;
+      const combined2 = host2 + pathname2;
+
+      // Check if one combined path ends with the other (handles proxy URLs)
+      return combined1.endsWith(combined2) || combined2.endsWith(combined1);
+    } catch (e) {
+      LoggerProxy.logger.warn('Meeting:util#_urlsPartiallyMatch --> error comparing URLs', e);
+
+      return false;
+    }
+  },
+
+  /**
+   * Gets socket URL information for metrics, including whether the socket URLs match
+   * Uses partial matching to handle proxy URLs (e.g., URLs with /webproxy/ prefix)
+   * @param {Object} webex - The webex instance
+   * @returns {Object} Object with hasMismatchedSocket, mercurySocketUrl, and deviceSocketUrl properties
+   */
+  getSocketUrlInfo: (
+    webex: any
+  ): {hasMismatchedSocket: boolean; mercurySocketUrl: string; deviceSocketUrl: string} => {
+    try {
+      const mercuryUrl = webex?.internal?.mercury?.socket?.url;
+      const deviceUrl = webex?.internal?.device?.webSocketUrl;
+
+      const sanitizedMercuryUrl = MeetingUtil.sanitizeWebSocketUrl(mercuryUrl);
+      const sanitizedDeviceUrl = MeetingUtil.sanitizeWebSocketUrl(deviceUrl);
+
+      // Only report a mismatch if both URLs are present and they don't match
+      // If either URL is missing, we can't determine if there's a mismatch, so return false
+      let hasMismatchedSocket = false;
+      if (sanitizedMercuryUrl && sanitizedDeviceUrl) {
+        hasMismatchedSocket = !MeetingUtil._urlsPartiallyMatch(mercuryUrl, deviceUrl);
+      }
+
+      return {
+        hasMismatchedSocket,
+        mercurySocketUrl: sanitizedMercuryUrl,
+        deviceSocketUrl: sanitizedDeviceUrl,
+      };
+    } catch (error) {
+      LoggerProxy.logger.warn(
+        `Meeting:util#getSocketUrlInfo --> error getting socket URL info: ${error}`
+      );
+
+      return {
+        hasMismatchedSocket: false,
+        mercurySocketUrl: '',
+        deviceSocketUrl: '',
+      };
+    }
+  },
+
   remoteUpdateAudioVideo: (meeting, audioMuted?: boolean, videoMuted?: boolean) => {
     if (!meeting) {
       return Promise.reject(new ParameterError('You need a meeting object.'));
@@ -203,6 +324,7 @@ const MeetingUtil = {
         const parsed = MeetingUtil.parseLocusJoin(res);
         meeting.setLocus(parsed);
         meeting.isoLocalClientMeetingJoinTime = res?.headers?.date; // read from header if exist, else fall back to system clock : https://jira-eng-gpk2.cisco.com/jira/browse/SPARK-555657
+        const socketUrlInfo = MeetingUtil.getSocketUrlInfo(webex);
         webex.internal.newMetrics.submitClientEvent({
           name: 'client.locus.join.response',
           payload: {
@@ -210,6 +332,9 @@ const MeetingUtil = {
             identifiers: {
               trackingId: res.headers.trackingid,
             },
+            eventData: {
+              ...socketUrlInfo,
+            },
           },
           options: {
             meetingId: meeting.id,
@@ -220,12 +345,19 @@ const MeetingUtil = {
         return parsed;
       })
       .catch((err) => {
+        const socketUrlInfo = MeetingUtil.getSocketUrlInfo(webex);
         webex.internal.newMetrics.submitClientEvent({
           name: 'client.locus.join.response',
           payload: {
             identifiers: {meetingLookupUrl: meeting.meetingInfo?.meetingLookupUrl},
+            eventData: {
+              ...socketUrlInfo,
+            },
+          },
+          options: {
+            meetingId: meeting.id,
+            rawError: err,
           },
-          options: {meetingId: meeting.id, rawError: err},
         });
 
         throw err;
@@ -237,6 +369,7 @@ const MeetingUtil = {
     meeting.stopPeriodicLogUpload();
 
     meeting.breakouts.cleanUp();
+    meeting.webinar.cleanUp();
     meeting.simultaneousInterpretation.cleanUp();
     meeting.locusMediaRequest = undefined;
 
@@ -261,8 +394,10 @@ const MeetingUtil = {
       .then(() => meeting.stopKeepAlive())
       .then(() => {
         if (meeting.config?.enableAutomaticLLM) {
-          meeting.updateLLMConnection();
+          return meeting.cleanupLLMConneciton({throwOnError: false});
         }
+
+        return undefined;
       });
   },
 
@@ -528,6 +663,11 @@ const MeetingUtil = {
     displayHints.includes(DISPLAY_HINTS.LEAVE_TRANSFER_HOST_END_MEETING) ||
     displayHints.includes(DISPLAY_HINTS.LEAVE_END_MEETING),
 
+  requireHostEndMeetingBeforeLeave: (displayHints) =>
+    displayHints.includes(DISPLAY_HINTS.REQUIRE_HOST_END_MEETING_BEFORE_LEAVE) ||
+    (!displayHints.includes(DISPLAY_HINTS.LEAVE_TRANSFER_HOST_END_MEETING) &&
+      displayHints.includes(DISPLAY_HINTS.END_MEETING)),
+
   canManageBreakout: (displayHints) => displayHints.includes(DISPLAY_HINTS.BREAKOUT_MANAGEMENT),
 
   canStartBreakout: (displayHints) => !displayHints.includes(DISPLAY_HINTS.DISABLE_BREAKOUT_START),
@@ -772,6 +912,24 @@ const MeetingUtil = {
     return locusDeltaRequest;
   },
 
+  canAttendeeRequestAiAssistantEnabled: (displayHints = [], roles: any[] = []) => {
+    const isHostOrCoHost =
+      roles.includes(ServerRoles.Cohost) || roles.includes(ServerRoles.Moderator);
+
+    if (isHostOrCoHost) {
+      return false;
+    }
+
+    if (displayHints.includes(DISPLAY_HINTS.ATTENDEE_REQUEST_AI_ASSISTANT_ENABLED)) {
+      return true;
+    }
+
+    return false;
+  },
+
+  attendeeRequestAiAssistantDeclinedAll: (displayHints = []) =>
+    displayHints.includes(DISPLAY_HINTS.ATTENDEE_REQUEST_AI_ASSISTANT_DECLINED_ALL),
+
   selfSupportsFeature: (feature: SELF_POLICY, userPolicies: Record<SELF_POLICY, boolean>) => {
     if (!userPolicies) {
       return true;

package/src/meetings/index.ts

@@ -69,6 +69,7 @@ import JoinForbiddenError from '../common/errors/join-forbidden-error';
 import {HashTreeMessage} from '../hashTree/hashTreeParser';
 import {HashTreeObject} from '../hashTree/types';
 import {isSelf} from '../hashTree/utils';
+import {createLocusFromHashTreeMessage} from '../locus-info';
 
 let mediaLogger;
 
@@ -195,6 +196,8 @@ export default class Meetings extends WebexPlugin {
   preferredWebexSite: any;
   reachability: Reachability;
   registered: any;
+  registrationPromise: Promise<void>;
+  unregistrationPromise: Promise<void>;
   request: any;
   geoHintInfo: any;
   meetingInfo: any;
@@ -520,41 +523,45 @@ export default class Meetings extends WebexPlugin {
       // };
       // rather then locus object change to locus url
 
-      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;
-        }
+      if (data.eventType === LOCUSEVENT.HASH_TREE_DATA_UPDATED) {
+        // We're about to create a new meeting object from this hash tree message.
+        // There is some existing (pre-hash trees) SDK logic here that requires a locus object
+        // (at the very minimum we need locus.url to be set)
+        // so we try to create locus from the received hash tree message
+        // it will not be complete, in most cases it will only have the self part, but that's still better than nothing
+        const {locus} = createLocusFromHashTreeMessage(data.stateElementsMessage);
+
+        data.locus = locus;
+      }
 
-        // 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.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;
       }
 
-      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);
+      // 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.'
+        );
+
+        return;
       }
 
       this.create(data.locus, DESTINATION_TYPE.LOCUS_ID, useRandomDelayForInfo)
@@ -624,7 +631,7 @@ export default class Meetings extends WebexPlugin {
   }
 
   /**
-   * handles locus events through mercury that are not roap
+   * handles locus events through mercury that are not roap or approval request events
    * @param {Object} envelope
    * @param {Object} envelope.data
    * @param {String} envelope.data.eventType
@@ -637,7 +644,11 @@ export default class Meetings extends WebexPlugin {
     // eslint-disable-next-line @typescript-eslint/no-shadow
     const {eventType} = data;
 
-    if (eventType && eventType !== LOCUSEVENT.MESSAGE_ROAP) {
+    if (
+      eventType &&
+      eventType !== LOCUSEVENT.MESSAGE_ROAP &&
+      eventType !== LOCUSEVENT.APPROVAL_REQUEST
+    ) {
       this.handleLocusEvent(data, true);
     }
   }
@@ -929,9 +940,20 @@ export default class Meetings extends WebexPlugin {
    * @returns {Promise} A promise that resolves when the step is completed.
    */
   executeRegistrationStep(step: () => Promise<any>, stepName: string) {
-    return step().then(() => {
-      this.registrationStatus[stepName] = true;
-    });
+    return step()
+      .then(() => {
+        LoggerProxy.logger.info(
+          `Meetings:index#executeRegistrationStep --> INFO, ${stepName} completed`
+        );
+        this.registrationStatus[stepName] = true;
+      })
+      .catch((error) => {
+        LoggerProxy.logger.error(
+          `Meetings:index#executeRegistrationStep --> ERROR, ${stepName} failed: ${error.message}`
+        );
+
+        return Promise.reject(error);
+      });
   }
 
   /**
@@ -944,7 +966,33 @@ export default class Meetings extends WebexPlugin {
    * @memberof Meetings
    */
   public register(deviceRegistrationOptions?: DeviceRegistrationOptions): Promise<any> {
-    this.registrationStatus = clone(INITIAL_REGISTRATION_STATUS);
+    if (this.unregistrationPromise) {
+      LoggerProxy.logger.info(
+        'Meetings:index#register --> INFO, Meetings plugin unregistration in progress, waiting to register'
+      );
+
+      this.registrationPromise = this.unregistrationPromise
+        .catch(() => {}) // It doesn't matter what happened during unregistration
+        .finally(() => {
+          LoggerProxy.logger.info(
+            'Meetings:index#register --> INFO, Meetings plugin unregistration completed, proceeding to register'
+          );
+
+          this.registrationPromise = null;
+
+          return this.register(deviceRegistrationOptions);
+        });
+
+      return this.registrationPromise;
+    }
+
+    if (this.registrationPromise) {
+      LoggerProxy.logger.info(
+        'Meetings:index#register --> INFO, Meetings plugin registration in progress, returning existing promise'
+      );
+
+      return this.registrationPromise;
+    }
 
     // @ts-ignore
     if (!this.webex.canAuthorize) {
@@ -963,7 +1011,11 @@ export default class Meetings extends WebexPlugin {
       return Promise.resolve();
     }
 
-    return Promise.all([
+    LoggerProxy.logger.info('Meetings:index#register --> INFO, Registering Meetings plugin');
+
+    this.registrationStatus = clone(INITIAL_REGISTRATION_STATUS);
+
+    this.registrationPromise = Promise.all([
       this.executeRegistrationStep(() => this.fetchUserPreferredWebexSite(), 'fetchWebexSite'),
       this.executeRegistrationStep(() => this.getGeoHint(), 'getGeoHint'),
       this.executeRegistrationStep(
@@ -1022,7 +1074,12 @@ export default class Meetings extends WebexPlugin {
         });
 
         return Promise.reject(error);
+      })
+      .finally(() => {
+        this.registrationPromise = null;
       });
+
+    return this.registrationPromise;
   }
 
   /**
@@ -1034,6 +1091,35 @@ export default class Meetings extends WebexPlugin {
    * @memberof Meetings
    */
   unregister() {
+    if (this.unregistrationPromise) {
+      LoggerProxy.logger.info(
+        'Meetings:index#unregister --> INFO, Meetings plugin unregistration in progress, returning existing promise'
+      );
+
+      return this.unregistrationPromise;
+    }
+
+    if (this.registrationPromise) {
+      LoggerProxy.logger.info(
+        'Meetings:index#unregister --> INFO, Meetings plugin registration in progress, waiting to unregister'
+      );
+
+      // Wait for registration to complete (success or failure), then call unregister again
+      this.unregistrationPromise = this.registrationPromise
+        .catch(() => {}) // It doesn't matter what happened during registration
+        .finally(() => {
+          LoggerProxy.logger.info(
+            'Meetings:index#unregister --> INFO, Meetings plugin registration completed, proceeding to unregister'
+          );
+
+          this.unregistrationPromise = null;
+
+          return this.unregister();
+        });
+
+      return this.unregistrationPromise;
+    }
+
     if (!this.registered) {
       LoggerProxy.logger.info(
         'Meetings:index#unregister --> INFO, Meetings plugin already unregistered'
@@ -1044,10 +1130,14 @@ export default class Meetings extends WebexPlugin {
 
     this.stopListeningForEvents();
 
-    return (
+    this.unregistrationPromise =
       // @ts-ignore
       this.webex.internal.mercury
-        .disconnect()
+        // Use code 3050 with a non-reconnecting reason to prevent Mercury auto-reconnect
+        // during unregister. Without this, disconnect() defaults to code 1000/"Done" which
+        // force-closes as "Done (forced)" - a normalReconnectReason that triggers auto-reconnect,
+        // causing a race condition with device.unregister().
+        .disconnect({code: 3050, reason: 'meetings unregister'})
         // @ts-ignore
         .then(() => this.webex.internal.device.unregister())
         .catch((error) => {
@@ -1077,7 +1167,11 @@ export default class Meetings extends WebexPlugin {
           this.registered = false;
           this.registrationStatus = clone(INITIAL_REGISTRATION_STATUS);
         })
-    );
+        .finally(() => {
+          this.unregistrationPromise = null;
+        });
+
+    return this.unregistrationPromise;
   }
 
   /**

package/src/member/index.ts

@@ -13,6 +13,7 @@ export type MemberId = string;
 export default class Member {
   associatedUser: MemberId | null; // deprecated, use associatedUsers instead
   associatedUsers: Set<MemberId>; // users associated with this device, empty if this member is not a device
+  canApproveAIEnablement: boolean;
   canReclaimHost: boolean;
   id: MemberId;
   isAudioMuted: any;
@@ -291,6 +292,14 @@ export default class Member {
      */
     this.isPresenterAssignmentProhibited = null;
 
+    /**
+     * @instance
+     * @type {Boolean}
+     * @public
+     * @memberof Member
+     */
+    this.canApproveAIEnablement = null;
+
     /**
      * @instance
      * @type {Boolean}
@@ -360,6 +369,7 @@ export default class Member {
         MemberUtil.isModeratorAssignmentProhibited(participant);
       this.isPresenterAssignmentProhibited =
         MemberUtil.isPresenterAssignmentProhibited(participant);
+      this.canApproveAIEnablement = MemberUtil.canApproveAIEnablement(participant);
       this.processStatus(participant);
       this.processRoles(participant);
       // must be done last

package/src/member/util.ts

@@ -42,6 +42,18 @@ const MemberUtil = {
     return participant.canReclaimHostRole || false;
   },
 
+  /**
+   * @param {Object} participant - The locus participant object.
+   * @returns {Boolean}
+   */
+  canApproveAIEnablement: (participant) => {
+    if (!participant) {
+      return false;
+    }
+
+    return !participant.attendeeRequestAiAssistantNotAllowed;
+  },
+
   /**
    * @param {Object} participant - The locus participant object.
    * @returns {[ServerRoleShape]}

package/src/metrics/constants.ts

@@ -90,6 +90,7 @@ const BEHAVIORAL_METRICS = {
   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',
+  MEDIA_STILL_NOT_CONNECTED: 'js_sdk_media_still_not_connected',
 };
 
 export {BEHAVIORAL_METRICS as default};

package/src/multistream/mediaRequestManager.ts

@@ -10,7 +10,7 @@ import {
   RecommendedOpusBitrates,
   NamedMediaGroup,
 } from '@webex/internal-media-core';
-import {cloneDeepWith, debounce, isEmpty} from 'lodash';
+import {cloneDeepWith, debounce} from 'lodash';
 
 import LoggerProxy from '../common/logs/logger-proxy';
 
@@ -94,8 +94,6 @@ export class MediaRequestManager {
 
   private debouncedSourceUpdateListener: () => void;
 
-  private previousStreamRequests: Array<StreamRequest> = [];
-
   private trimRequestsToNumOfSources: boolean;
   private numTotalSources: number;
   private numLiveSources: number;
@@ -161,36 +159,6 @@ export class MediaRequestManager {
     }
   }
 
-  /**
-   * Returns true if two stream requests are the same, false otherwise.
-   *
-   * @param {StreamRequest} streamRequestA - Stream request A for comparison.
-   * @param {StreamRequest} streamRequestB - Stream request B for comparison.
-   * @returns {boolean} - Whether they are equal.
-   */
-  // eslint-disable-next-line class-methods-use-this
-  public isEqual(streamRequestA: StreamRequest, streamRequestB: StreamRequest) {
-    return (
-      JSON.stringify(streamRequestA._toJmpStreamRequest()) ===
-      JSON.stringify(streamRequestB._toJmpStreamRequest())
-    );
-  }
-
-  /**
-   * Compares new stream requests to previous ones and determines
-   * if they are the same.
-   *
-   * @param {StreamRequest[]} newRequests - Array with new requests.
-   * @returns {boolean} - True if they are equal, false otherwise.
-   */
-  private checkIsNewRequestsEqualToPrev(newRequests: StreamRequest[]) {
-    return (
-      !isEmpty(this.previousStreamRequests) &&
-      this.previousStreamRequests.length === newRequests.length &&
-      this.previousStreamRequests.every((req, idx) => this.isEqual(req, newRequests[idx]))
-    );
-  }
-
   /**
    * Returns the maxPayloadBitsPerSecond per Stream
    *
@@ -230,15 +198,6 @@ export class MediaRequestManager {
     return (mediaRequest.codecInfo.maxFs * maxFps) / 100;
   }
 
-  /**
-   * Clears the previous stream requests.
-   *
-   * @returns {void}
-   */
-  public clearPreviousRequests(): void {
-    this.previousStreamRequests = [];
-  }
-
   /** Modifies the passed in clientRequests and makes sure that in total they don't ask
    *  for more streams than there are available.
    *
@@ -356,7 +315,7 @@ export class MediaRequestManager {
             mr.receiveSlots.map((receiveSlot) => receiveSlot.wcmeReceiveSlot),
             this.getMaxPayloadBitsPerSecond(mr),
             mr.codecInfo && [
-              new WcmeCodecInfo(
+              WcmeCodecInfo.fromH264(
                 0x80,
                 new H264Codec(
                   mr.codecInfo.maxFs,
@@ -372,17 +331,8 @@ export class MediaRequestManager {
       }
     });
 
-    //! IMPORTANT: this is only a temporary fix. This will soon be done in the jmp layer (@webex/json-multistream)
-    // https://jira-eng-gpk2.cisco.com/jira/browse/WEBEX-326713
-    if (!this.checkIsNewRequestsEqualToPrev(streamRequests)) {
-      this.sendMediaRequestsCallback(streamRequests);
-      this.previousStreamRequests = streamRequests;
-      LoggerProxy.logger.info(`multistream:sendRequests --> media requests sent. `);
-    } else {
-      LoggerProxy.logger.info(
-        `multistream:sendRequests --> detected duplicate WCME requests, skipping them... `
-      );
-    }
+    this.sendMediaRequestsCallback(streamRequests);
+    LoggerProxy.logger.info(`multistream:sendRequests --> media requests sent. `);
   }
 
   public addRequest(mediaRequest: MediaRequest, commit = true): MediaRequestId {

package/src/multistream/remoteMediaManager.ts

@@ -67,6 +67,18 @@ const AllEqualLayout: VideoLayout = {
   ],
 };
 
+// An "all equal" grid, with size up to 5 x 5 = 25:
+const AllEqual25Layout: VideoLayout = {
+  activeSpeakerVideoPaneGroups: [
+    {
+      id: 'main',
+      numPanes: 25,
+      size: 'best',
+      priority: 255,
+    },
+  ],
+};
+
 // A layout with just a single remote active speaker video pane:
 const SingleLayout: VideoLayout = {
   activeSpeakerVideoPaneGroups: [
@@ -164,6 +176,7 @@ export const DefaultConfiguration: Configuration = {
 
     layouts: {
       AllEqual: AllEqualLayout,
+      AllEqual25: AllEqual25Layout,
       OnePlusFive: OnePlusFiveLayout,
       Single: SingleLayout,
       Stage: Stage2x2With6ThumbnailsLayout,