@webex/plugin-meetings 3.12.0-next.1 → 3.12.0-next.10

package/src/meeting/index.ts

@@ -22,6 +22,7 @@ import {
   MediaConnectionEventNames,
   MediaContent,
   MediaType,
+  MediaCodecMimeType,
   RemoteTrackType,
   RoapMessage,
   StatsAnalyzer,
@@ -3733,7 +3734,7 @@ export default class Meeting extends StatelessWebexPlugin {
       });
       this.updateLLMConnection();
     });
-    this.locusInfo.on(LOCUSINFO.EVENTS.SELF_ADMITTED_GUEST, async (payload) => {
+    this.locusInfo.on(LOCUSINFO.EVENTS.SELF_ADMITTED_GUEST, (payload) => {
       this.stopKeepAlive();
 
       if (payload) {
@@ -3759,6 +3760,15 @@ export default class Meeting extends StatelessWebexPlugin {
         });
       }
       this.rtcMetrics?.sendNextMetrics();
+
+      this.ensureDefaultDatachannelTokenAfterAdmit().catch((error) => {
+        LoggerProxy.logger.warn(
+          `Meeting:index#setUpLocusInfoSelfListener --> failed post-admit token prefetch flow: ${
+            error?.message || String(error)
+          }`
+        );
+      });
+
       this.updateLLMConnection();
     });
 
@@ -5907,37 +5917,35 @@ export default class Meeting extends StatelessWebexPlugin {
    * @returns {void}
    */
   stopTranscription() {
-    if (this.transcription) {
-      // @ts-ignore
-      this.webex.internal.voicea.off(
-        VOICEAEVENTS.VOICEA_ANNOUNCEMENT,
-        this.voiceaListenerCallbacks[VOICEAEVENTS.VOICEA_ANNOUNCEMENT]
-      );
+    // @ts-ignore
+    this.webex.internal.voicea.off(
+      VOICEAEVENTS.VOICEA_ANNOUNCEMENT,
+      this.voiceaListenerCallbacks[VOICEAEVENTS.VOICEA_ANNOUNCEMENT]
+    );
 
-      // @ts-ignore
-      this.webex.internal.voicea.off(
-        VOICEAEVENTS.CAPTIONS_TURNED_ON,
-        this.voiceaListenerCallbacks[VOICEAEVENTS.CAPTIONS_TURNED_ON]
-      );
+    // @ts-ignore
+    this.webex.internal.voicea.off(
+      VOICEAEVENTS.CAPTIONS_TURNED_ON,
+      this.voiceaListenerCallbacks[VOICEAEVENTS.CAPTIONS_TURNED_ON]
+    );
 
-      // @ts-ignore
-      this.webex.internal.voicea.off(
-        VOICEAEVENTS.EVA_COMMAND,
-        this.voiceaListenerCallbacks[VOICEAEVENTS.EVA_COMMAND]
-      );
+    // @ts-ignore
+    this.webex.internal.voicea.off(
+      VOICEAEVENTS.EVA_COMMAND,
+      this.voiceaListenerCallbacks[VOICEAEVENTS.EVA_COMMAND]
+    );
 
-      // @ts-ignore
-      this.webex.internal.voicea.off(
-        VOICEAEVENTS.NEW_CAPTION,
-        this.voiceaListenerCallbacks[VOICEAEVENTS.NEW_CAPTION]
-      );
+    // @ts-ignore
+    this.webex.internal.voicea.off(
+      VOICEAEVENTS.NEW_CAPTION,
+      this.voiceaListenerCallbacks[VOICEAEVENTS.NEW_CAPTION]
+    );
 
-      // @ts-ignore
-      this.webex.internal.voicea.deregisterEvents();
+    // @ts-ignore
+    this.webex.internal.voicea.deregisterEvents();
 
-      this.areVoiceaEventsSetup = false;
-      this.triggerStopReceivingTranscriptionEvent();
-    }
+    this.areVoiceaEventsSetup = false;
+    this.triggerStopReceivingTranscriptionEvent();
   }
 
   /**
@@ -5961,6 +5969,30 @@ export default class Meeting extends StatelessWebexPlugin {
     );
   }
 
+  /**
+   * Restores LLM subchannel subscriptions after reconnect when captions are active.
+   * @returns {void}
+   */
+  private restoreLLMSubscriptionsIfNeeded(): void {
+    try {
+      // @ts-ignore
+      const isCaptionBoxOn = this.webex.internal.voicea?.getIsCaptionBoxOn?.();
+
+      if (!isCaptionBoxOn) {
+        return;
+      }
+
+      // @ts-ignore
+      this.webex.internal.voicea.updateSubchannelSubscriptions({subscribe: ['transcription']});
+    } catch (error) {
+      const msg = error?.message || String(error);
+
+      LoggerProxy.logger.warn(
+        `Meeting:index#restoreLLMSubscriptionsIfNeeded --> failed to restore subscriptions after LLM online: ${msg}`
+      );
+    }
+  }
+
   /**
    * This is a callback for the LLM event that is triggered when it comes online
    * This method in turn will trigger an event to the developers that the LLM is connected
@@ -5969,8 +6001,8 @@ export default class Meeting extends StatelessWebexPlugin {
    * @returns {null}
    */
   private handleLLMOnline = (): void => {
-    // @ts-ignore
-    this.webex.internal.llm.off('online', this.handleLLMOnline);
+    this.restoreLLMSubscriptionsIfNeeded();
+
     Trigger.trigger(
       this,
       {
@@ -6198,8 +6230,11 @@ export default class Meeting extends StatelessWebexPlugin {
         return Promise.reject(error);
       })
       .then((join) => {
+        this.saveDataChannelToken(join);
         // @ts-ignore - config coming from registerPlugin
         if (this.config.enableAutomaticLLM) {
+          // @ts-ignore
+          this.webex.internal.llm.off('online', this.handleLLMOnline);
           // @ts-ignore
           this.webex.internal.llm.on('online', this.handleLLMOnline);
           this.updateLLMConnection()
@@ -6309,33 +6344,102 @@ export default class Meeting extends StatelessWebexPlugin {
     }
   };
 
+  /**
+   * Clears all data channel tokens stored in LLM.
+   * Called during meeting cleanup to ensure stale tokens are not reused.
+   * @returns {void}
+   */
+  clearDataChannelToken(): void {
+    // @ts-ignore
+    this.webex.internal.llm.resetDatachannelTokens();
+  }
+
+  /**
+   * Saves the data channel tokens from the join response into LLM so that
+   * updateLLMConnection / updatePSDataChannel don't need to fetch them from locusInfo.
+   * @param {Object} join - The parsed join response (from MeetingUtil.parseLocusJoin)
+   * @returns {void}
+   */
+  saveDataChannelToken(join: any): void {
+    const datachannelToken = join?.locus?.self?.datachannelToken;
+    const practiceSessionDatachannelToken = join?.locus?.self?.practiceSessionDatachannelToken;
+
+    if (datachannelToken) {
+      // @ts-ignore
+      this.webex.internal.llm.setDatachannelToken(datachannelToken, DataChannelTokenType.Default);
+    }
+
+    if (practiceSessionDatachannelToken) {
+      // @ts-ignore
+      this.webex.internal.llm.setDatachannelToken(
+        practiceSessionDatachannelToken,
+        DataChannelTokenType.PracticeSession
+      );
+    }
+  }
+
+  /**
+   * Ensures default-session data channel token exists after lobby admission.
+   * Some lobby users do not receive a token until they are admitted.
+   * @returns {Promise<boolean>} true when a new token is fetched and cached
+   */
+  private async ensureDefaultDatachannelTokenAfterAdmit(): Promise<boolean> {
+    try {
+      // @ts-ignore
+      const datachannelToken = this.webex.internal.llm.getDatachannelToken();
+      // @ts-ignore
+      const isDataChannelTokenEnabled = await this.webex.internal.llm.isDataChannelTokenEnabled();
+
+      if (!isDataChannelTokenEnabled || datachannelToken) {
+        return false;
+      }
+
+      const response = await this.meetingRequest.fetchDatachannelToken({
+        locusUrl: this.locusUrl,
+        requestingParticipantId: this.members.selfId,
+        isPracticeSession: false,
+      });
+      const fetchedDatachannelToken = response?.body?.datachannelToken;
+
+      if (!fetchedDatachannelToken) {
+        return false;
+      }
+
+      // @ts-ignore
+      this.webex.internal.llm.setDatachannelToken(
+        fetchedDatachannelToken,
+        DataChannelTokenType.Default
+      );
+
+      return true;
+    } catch (error) {
+      const msg = error?.message || String(error);
+
+      LoggerProxy.logger.warn(
+        `Meeting:index#ensureDefaultDatachannelTokenAfterAdmit --> failed to proactively fetch default data channel token after admit: ${msg}`,
+        {statusCode: error?.statusCode}
+      );
+
+      return false;
+    }
+  }
+
   /**
    * Connects to low latency mercury and reconnects if the address has changed
    * It will also disconnect if called when the meeting has ended
-   * @param {String} datachannelUrl
    * @returns {Promise}
    */
   async updateLLMConnection() {
     // @ts-ignore - Fix type
-    const {
-      url = undefined,
-      info: {datachannelUrl = undefined} = {},
-      self: {datachannelToken = undefined} = {},
-    } = this.locusInfo || {};
+    const {url = undefined, info: {datachannelUrl = undefined} = {}} = this.locusInfo || {};
 
     const isJoined = this.isJoined();
 
     // @ts-ignore
-    const currentToken = this.webex.internal.llm.getDatachannelToken(DataChannelTokenType.Default);
-
-    const finalToken = currentToken ?? datachannelToken;
-
-    if (!currentToken && datachannelToken) {
-      // @ts-ignore
-      this.webex.internal.llm.setDatachannelToken(datachannelToken, DataChannelTokenType.Default);
-    }
+    const datachannelToken = this.webex.internal.llm.getDatachannelToken(
+      DataChannelTokenType.Default
+    );
 
-    // webinar panelist should use new data channel in practice session
     const dataChannelUrl = datachannelUrl;
 
     // @ts-ignore - Fix type
@@ -6358,7 +6462,7 @@ export default class Meeting extends StatelessWebexPlugin {
 
     // @ts-ignore - Fix type
     return this.webex.internal.llm
-      .registerAndConnect(url, dataChannelUrl, finalToken)
+      .registerAndConnect(url, dataChannelUrl, datachannelToken)
       .then((registerAndConnectResult) => {
         // @ts-ignore - Fix type
         this.webex.internal.llm.off('event:relay.event', this.processRelayEvent);
@@ -9618,13 +9722,12 @@ export default class Meeting extends StatelessWebexPlugin {
     }
     this.queuedMediaUpdates = [];
 
-    if (this.transcription) {
-      this.stopTranscription();
-      this.transcription = undefined;
-    }
+    this.stopTranscription();
+    this.transcription = undefined;
 
     this.annotation.deregisterEvents();
 
+    this.clearDataChannelToken();
     await this.cleanupLLMConneciton({throwOnError: false});
   };
 
@@ -9818,15 +9921,20 @@ export default class Meeting extends StatelessWebexPlugin {
     }
 
     if (shouldEnableMusicMode) {
-      await this.sendSlotManager.setCodecParameters(MediaType.AudioMain, {
-        maxaveragebitrate: '64000',
-        maxplaybackrate: '48000',
-      });
+      await this.sendSlotManager.setCustomCodecParameters(
+        MediaType.AudioMain,
+        MediaCodecMimeType.OPUS,
+        {
+          maxaveragebitrate: '64000',
+          maxplaybackrate: '48000',
+        }
+      );
     } else {
-      await this.sendSlotManager.deleteCodecParameters(MediaType.AudioMain, [
-        'maxaveragebitrate',
-        'maxplaybackrate',
-      ]);
+      await this.sendSlotManager.markCustomCodecParametersForDeletion(
+        MediaType.AudioMain,
+        MediaCodecMimeType.OPUS,
+        ['maxaveragebitrate', 'maxplaybackrate']
+      );
     }
   }
 

package/src/metrics/constants.ts

@@ -91,6 +91,11 @@ const BEHAVIORAL_METRICS = {
   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',
+  DEPRECATED_SET_CODEC_PARAMETERS_USED: 'js_sdk_deprecated_set_codec_parameters_used',
+  DEPRECATED_DELETE_CODEC_PARAMETERS_USED: 'js_sdk_deprecated_delete_codec_parameters_used',
+  SET_CUSTOM_CODEC_PARAMETERS_USED: 'js_sdk_set_custom_codec_parameters_used',
+  MARK_CUSTOM_CODEC_PARAMETERS_FOR_DELETION_USED:
+    'js_sdk_mark_custom_codec_parameters_for_deletion_used',
 };
 
 export {BEHAVIORAL_METRICS as default};

package/src/multistream/sendSlotManager.ts

@@ -5,7 +5,11 @@ import {
   MultistreamRoapMediaConnection,
   NamedMediaGroup,
   StreamState,
+  MediaCodecMimeType,
+  CodecParameters,
 } from '@webex/internal-media-core';
+import Metrics from '../metrics';
+import BEHAVIORAL_METRICS from '../metrics/constants';
 
 /**
  * This class is used to manage the sendSlots for the given media types.
@@ -206,6 +210,8 @@ export default class SendSlotManager {
   }
 
   /**
+   * @deprecated Use {@link setCustomCodecParameters} instead, which requires specifying the codec MIME type.
+   *
    * This method is used to set the codec parameters for the sendSlot of the given mediaType
    * @param {MediaType} mediaType MediaType of the sendSlot for which the codec parameters needs to be set (AUDIO_MAIN/VIDEO_MAIN/AUDIO_SLIDES/VIDEO_SLIDES)
    * @param {Object} codecParameters
@@ -226,12 +232,19 @@ export default class SendSlotManager {
 
     await slot.setCodecParameters(codecParameters);
 
-    this.LoggerProxy.logger.info(
-      `SendSlotsManager->setCodecParameters#Set codec parameters for ${mediaType} to ${codecParameters}`
+    this.LoggerProxy.logger.warn(
+      'SendSlotsManager->setCodecParameters --> [DEPRECATION WARNING]: setCodecParameters has been deprecated, use setCustomCodecParameters instead'
     );
+
+    Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.DEPRECATED_SET_CODEC_PARAMETERS_USED, {
+      mediaType,
+      codecParameters,
+    });
   }
 
   /**
+   * @deprecated Use {@link markCustomCodecParametersForDeletion} instead, which requires specifying the codec MIME type.
+   *
    * This method is used to delete the codec parameters for the sendSlot of the given mediaType
    * @param {MediaType} mediaType MediaType of the sendSlot for which the codec parameters needs to be deleted (AUDIO_MAIN/VIDEO_MAIN/AUDIO_SLIDES/VIDEO_SLIDES)
    * @param {Array<String>} parameters Array of keys of the codec parameters to be deleted
@@ -246,8 +259,89 @@ export default class SendSlotManager {
 
     await slot.deleteCodecParameters(parameters);
 
+    this.LoggerProxy.logger.warn(
+      'SendSlotsManager->deleteCodecParameters --> [DEPRECATION WARNING]: deleteCodecParameters has been deprecated, use markCustomCodecParametersForDeletion instead'
+    );
+
+    Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.DEPRECATED_DELETE_CODEC_PARAMETERS_USED, {
+      mediaType,
+      parameters,
+    });
+  }
+
+  /**
+   * Sets custom codec parameters for the sendSlot of the given mediaType, scoped to a specific codec MIME type.
+   * Delegates to WCME's setCustomCodecParameters API.
+   * @param {MediaType} mediaType MediaType of the sendSlot
+   * @param {MediaCodecMimeType} codecMimeType The codec MIME type to apply parameters to (e.g. OPUS, H264, AV1)
+   * @param {CodecParameters} parameters Key-value pairs of codec parameters to set
+   * @returns {Promise<void>}
+   */
+  public async setCustomCodecParameters(
+    mediaType: MediaType,
+    codecMimeType: MediaCodecMimeType,
+    parameters: CodecParameters
+  ): Promise<void> {
+    const slot = this.slots.get(mediaType);
+
+    if (!slot) {
+      throw new Error(`Slot for ${mediaType} does not exist`);
+    }
+
+    try {
+      await slot.setCustomCodecParameters(codecMimeType, parameters);
+
+      this.LoggerProxy.logger.info(
+        `SendSlotsManager->setCustomCodecParameters#Set custom codec parameters for ${mediaType} (codec: ${codecMimeType}) to ${JSON.stringify(
+          parameters
+        )}`
+      );
+    } catch (error) {
+      this.LoggerProxy.logger.error(
+        `SendSlotsManager->setCustomCodecParameters#Failed to set custom codec parameters for ${mediaType} (codec: ${codecMimeType}): ${error}`
+      );
+      throw error;
+    } finally {
+      Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.SET_CUSTOM_CODEC_PARAMETERS_USED, {
+        mediaType,
+        codecMimeType,
+        parameters,
+      });
+    }
+  }
+
+  /**
+   * Marks custom codec parameters for deletion on the sendSlot of the given mediaType, scoped to a specific codec MIME type.
+   * Delegates to WCME's markCustomCodecParametersForDeletion API.
+   * @param {MediaType} mediaType MediaType of the sendSlot
+   * @param {MediaCodecMimeType} codecMimeType The codec MIME type whose parameters should be deleted (e.g. OPUS, H264, AV1)
+   * @param {string[]} parameters Array of parameter keys to delete
+   * @returns {Promise<void>}
+   */
+  public async markCustomCodecParametersForDeletion(
+    mediaType: MediaType,
+    codecMimeType: MediaCodecMimeType,
+    parameters: string[]
+  ): Promise<void> {
+    const slot = this.slots.get(mediaType);
+
+    if (!slot) {
+      throw new Error(`Slot for ${mediaType} does not exist`);
+    }
+
+    await slot.markCustomCodecParametersForDeletion(codecMimeType, parameters);
+
     this.LoggerProxy.logger.info(
-      `SendSlotsManager->deleteCodecParameters#Deleted the following codec parameters -> ${parameters} for ${mediaType}`
+      `SendSlotsManager->markCustomCodecParametersForDeletion#Marked codec parameters for deletion -> ${parameters} for ${mediaType} (codec: ${codecMimeType})`
+    );
+
+    Metrics.sendBehavioralMetric(
+      BEHAVIORAL_METRICS.MARK_CUSTOM_CODEC_PARAMETERS_FOR_DELETION_USED,
+      {
+        mediaType,
+        codecMimeType,
+        parameters,
+      }
     );
   }
 

package/src/webinar/index.ts

@@ -131,6 +131,12 @@ const Webinar = WebexPlugin.extend({
    * @returns {Promise<void>}
    */
   async cleanupPSDataChannel() {
+    if (this._pendingOnlineListener) {
+      // @ts-ignore - Fix type
+      this.webex.internal.llm.off('online', this._pendingOnlineListener);
+      this._pendingOnlineListener = null;
+    }
+
     const meeting = this.webex.meetings.getMeetingByType(_ID_, this.meetingId);
 
     // @ts-ignore - Fix type
@@ -148,12 +154,63 @@ const Webinar = WebexPlugin.extend({
     );
   },
 
+  /**
+   * Ensures practice-session token exists before registering the practice LLM channel.
+   * @param {object} meeting
+   * @returns {Promise<string|undefined>}
+   */
+  async ensurePracticeSessionDatachannelToken(meeting) {
+    // @ts-ignore
+    const isDataChannelTokenEnabled = await this.webex.internal.llm.isDataChannelTokenEnabled();
+
+    if (!isDataChannelTokenEnabled) {
+      return undefined;
+    }
+
+    // @ts-ignore
+    const cachedToken = this.webex.internal.llm.getDatachannelToken(
+      DataChannelTokenType.PracticeSession
+    );
+
+    if (cachedToken) {
+      return cachedToken;
+    }
+
+    try {
+      const refreshResponse = await meeting.refreshDataChannelToken();
+      const {datachannelToken, dataChannelTokenType} = refreshResponse?.body ?? {};
+
+      if (!datachannelToken) {
+        return undefined;
+      }
+
+      // @ts-ignore
+      this.webex.internal.llm.setDatachannelToken(
+        datachannelToken,
+        dataChannelTokenType || DataChannelTokenType.PracticeSession
+      );
+
+      return datachannelToken;
+    } catch (error) {
+      LoggerProxy.logger.warn(
+        `Webinar:index#ensurePracticeSessionDatachannelToken --> failed to proactively refresh practice-session token: ${
+          error?.message || String(error)
+        }`
+      );
+
+      return undefined;
+    }
+  },
+
   /**
    * Connects to low latency mercury and reconnects if the address has changed
    * It will also disconnect if called when the meeting has ended
    * @returns {Promise}
    */
   async updatePSDataChannel() {
+    this._updatePSDataChannelSequence = (this._updatePSDataChannelSequence || 0) + 1;
+    const invocationSequence = this._updatePSDataChannelSequence;
+
     const meeting = this.webex.meetings.getMeetingByType(_ID_, this.meetingId);
     const isPracticeSession = meeting?.isJoined() && this.isJoinPracticeSessionDataChannel();
 
@@ -164,29 +221,16 @@ const Webinar = WebexPlugin.extend({
     }
 
     // @ts-ignore - Fix type
-    const {
-      url = undefined,
-      info: {practiceSessionDatachannelUrl = undefined} = {},
-      self: {practiceSessionDatachannelToken = undefined} = {},
-    } = meeting?.locusInfo || {};
+    const {url = undefined, info: {practiceSessionDatachannelUrl = undefined} = {}} =
+      meeting?.locusInfo || {};
 
     // @ts-ignore
-    const currentToken = this.webex.internal.llm.getDatachannelToken(
+    let practiceSessionDatachannelToken = this.webex.internal.llm.getDatachannelToken(
       DataChannelTokenType.PracticeSession
     );
 
-    const finalToken = currentToken ?? practiceSessionDatachannelToken;
-
     const isCaptionBoxOn = this.webex.internal.voicea.getIsCaptionBoxOn();
 
-    if (!currentToken && practiceSessionDatachannelToken) {
-      // @ts-ignore
-      this.webex.internal.llm.setDatachannelToken(
-        practiceSessionDatachannelToken,
-        DataChannelTokenType.PracticeSession
-      );
-    }
-
     if (!practiceSessionDatachannelUrl) {
       return undefined;
     }
@@ -205,9 +249,68 @@ const Webinar = WebexPlugin.extend({
       await this.cleanupPSDataChannel();
     }
 
+    // Ensure the default session data channel is connected before connecting the practice session.
+    // Subscribe before checking isConnected() to avoid a race where the 'online' event fires
+    // between the check and the subscription — Mercury does not replay missed events.
+    if (!this._pendingOnlineListener) {
+      const onDefaultSessionConnected = () => {
+        this._pendingOnlineListener = null;
+        // @ts-ignore - Fix type
+        this.webex.internal.llm.off('online', onDefaultSessionConnected);
+        this.updatePSDataChannel();
+      };
+      this._pendingOnlineListener = onDefaultSessionConnected;
+      // @ts-ignore - Fix type
+      this.webex.internal.llm.on('online', onDefaultSessionConnected);
+    }
+
+    // @ts-ignore - Fix type
+    if (!this.webex.internal.llm.isConnected()) {
+      LoggerProxy.logger.info(
+        'Webinar:index#updatePSDataChannel --> default session not yet connected, deferring practice session connect.'
+      );
+
+      return undefined;
+    }
+
+    // Default session is already connected — cancel the pending listener and proceed
+    if (this._pendingOnlineListener) {
+      // @ts-ignore - Fix type
+      this.webex.internal.llm.off('online', this._pendingOnlineListener);
+      this._pendingOnlineListener = null;
+    }
+
+    const refreshedPracticeSessionToken = await this.ensurePracticeSessionDatachannelToken(meeting);
+
+    const latestPracticeSessionDatachannelUrl = get(
+      meeting,
+      'locusInfo.info.practiceSessionDatachannelUrl'
+    );
+    const isStillPracticeSession = meeting?.isJoined() && this.isJoinPracticeSessionDataChannel();
+
+    // Skip stale invocations after async refresh to avoid reconnecting a session
+    // that was already updated/cleaned by a newer state transition.
+    if (
+      invocationSequence !== this._updatePSDataChannelSequence ||
+      !isStillPracticeSession ||
+      !latestPracticeSessionDatachannelUrl ||
+      latestPracticeSessionDatachannelUrl !== practiceSessionDatachannelUrl
+    ) {
+      return undefined;
+    }
+
+    if (refreshedPracticeSessionToken) {
+      practiceSessionDatachannelToken = refreshedPracticeSessionToken;
+    }
+
     // @ts-ignore - Fix type
     return this.webex.internal.llm
-      .registerAndConnect(url, practiceSessionDatachannelUrl, finalToken, LLM_PRACTICE_SESSION)
+      .registerAndConnect(
+        url,
+        practiceSessionDatachannelUrl,
+        practiceSessionDatachannelToken,
+        LLM_PRACTICE_SESSION
+      )
       .then((registerAndConnectResult) => {
         // @ts-ignore - Fix type
         this.webex.internal.llm.off(
@@ -366,7 +469,6 @@ const Webinar = WebexPlugin.extend({
 
   /**
    * view all webcast attendees
-   * @param {string} queryString
    * @returns {Promise}
    */
   async viewAllWebcastAttendees() {