@webex/plugin-meetings 3.11.0-webex-services-ready.1 → 3.12.0

package/test/unit/spec/meeting/index.js

@@ -82,6 +82,7 @@ import Mercury from '@webex/internal-plugin-mercury';
 import Breakouts from '@webex/plugin-meetings/src/breakouts';
 import SimultaneousInterpretation from '@webex/plugin-meetings/src/interpretation';
 import Webinar from '@webex/plugin-meetings/src/webinar';
+import AIEnableRequest from '@webex/plugin-meetings/src/aiEnableRequest';
 import {REACTION_RELAY_TYPES} from '../../../../src/reactions/constants';
 import locus from '../fixture/locus';
 import {
@@ -123,7 +124,6 @@ import {EVENT_TRIGGERS as VOICEAEVENTS} from '@webex/internal-plugin-voicea';
 import {createBrbState} from '@webex/plugin-meetings/src/meeting/brbState';
 import JoinForbiddenError from '../../../../src/common/errors/join-forbidden-error';
 import {EventEmitter} from 'stream';
-
 describe('plugin-meetings', () => {
   const logger = {
     info: () => {},
@@ -265,7 +265,9 @@ describe('plugin-meetings', () => {
       stopReachability: sinon.stub(),
       isSubnetReachable: sinon.stub().returns(true),
     };
+    webex.internal.llm.isDataChannelTokenEnabled = sinon.stub().resolves(false);
     webex.internal.llm.on = sinon.stub();
+    webex.internal.voicea.announce = sinon.stub();
     webex.internal.newMetrics.callDiagnosticLatencies = new CallDiagnosticLatencies(
       {},
       {parent: webex}
@@ -376,6 +378,7 @@ describe('plugin-meetings', () => {
           assert.instanceOf(meeting.breakouts, Breakouts);
           assert.instanceOf(meeting.simultaneousInterpretation, SimultaneousInterpretation);
           assert.instanceOf(meeting.webinar, Webinar);
+          assert.instanceOf(meeting.aiEnableRequest, AIEnableRequest);
         });
 
         it('should call the callback with the meeting that has id already set', () => {
@@ -738,7 +741,9 @@ describe('plugin-meetings', () => {
         let supportsRTCPeerConnectionStub;
 
         beforeEach(() => {
-          supportsRTCPeerConnectionStub = sinon.stub(WebCapabilities, 'supportsRTCPeerConnection').returns(CapabilityState.CAPABLE);
+          supportsRTCPeerConnectionStub = sinon
+            .stub(WebCapabilities, 'supportsRTCPeerConnection')
+            .returns(CapabilityState.CAPABLE);
 
           meeting.join = sinon.stub().callsFake((joinOptions) => {
             meeting.isMultistream = joinOptions.enableMultistream;
@@ -1011,33 +1016,53 @@ describe('plugin-meetings', () => {
           );
         });
 
-        it('should call leave() if addMediaInternal() fails ', async () => {
+        it('should call leave() if addMediaInternal() fails with a browser media error (TypeError)', async () => {
           const addMediaError = new Error('fake addMedia error');
-          addMediaError.name = 'TypeError';
+          addMediaError.name = 'TypeError'; // This makes it a browser media error
 
-          const rejectError = {
-            error: {
-              body: {
-                errorCode: 2729,
-                message: 'fake addMedia error',
-                name: 'TypeError'
-              }
-            }
-          };
-          meeting.addMediaInternal.rejects(addMediaError);
-          sinon.stub(meeting, 'leave').resolves();
+          const leaveStub = sinon.stub(meeting, 'leave').resolves();
+          meeting.addMediaInternal = sinon.stub().rejects(addMediaError);
 
-          await assert.isRejected(
+          // When a browser media error occurs, it gets transformed into a special structure
+          const rejectedError = await assert.isRejected(
             meeting.joinWithMedia({
               joinOptions,
               mediaOptions,
-            }),
-            rejectError
+            })
           );
 
+          // Verify the error was transformed with errorCode 2729
+          assert.equal(rejectedError.error.body.errorCode, 2729);
+          assert.equal(rejectedError.error.body.message, 'fake addMedia error');
+          assert.equal(rejectedError.error.body.name, 'TypeError');
+
           assert.calledOnce(meeting.join);
           assert.calledOnce(meeting.addMediaInternal);
+          assert.calledOnce(leaveStub);
+          assert.calledOnceWithExactly(leaveStub, {
+            resourceId: undefined,
+            reason: 'joinWithMedia failure',
+          });
+
+          // Browser media errors don't retry, so behavioral metric is sent only once
+          // NOTE: The error gets transformed, so the metric receives undefined for message/stack/name
+          // because they're now nested in error.body instead of at the top level
           assert.calledOnce(Metrics.sendBehavioralMetric);
+          assert.calledWith(
+            Metrics.sendBehavioralMetric,
+            BEHAVIORAL_METRICS.JOIN_WITH_MEDIA_FAILURE,
+            {
+              correlation_id: meeting.correlationId,
+              locus_id: meeting.locusUrl.split('/').pop(),
+              reason: undefined, // transformed error doesn't have .message at top level
+              stack: undefined, // transformed error doesn't have .stack at top level
+              leaveErrorReason: undefined,
+              isRetry: false,
+            },
+            {
+              type: undefined, // transformed error doesn't have .name at top level
+            }
+          );
         });
 
         it('should not call leave() if addMediaInternal() fails the first time and succeeds the second time and should only call join() once', async () => {
@@ -1249,8 +1274,14 @@ describe('plugin-meetings', () => {
         });
 
         [
-          {errorName: 'SdpOfferCreationError', description: 'if we fail to create the offer on first attempt'}, 
-          {errorName: 'WebrtcApiNotAvailableError', description: 'if RTCPeerConnection is not available'},
+          {
+            errorName: 'SdpOfferCreationError',
+            description: 'if we fail to create the offer on first attempt',
+          },
+          {
+            errorName: 'WebrtcApiNotAvailableError',
+            description: 'if RTCPeerConnection is not available',
+          },
         ].forEach(({errorName, description}) => {
           it(`should not attempt a retry ${description}`, async () => {
             const addMediaError = new Error('fake addMedia error');
@@ -1290,7 +1321,7 @@ describe('plugin-meetings', () => {
               resourceId: undefined,
               reason: 'joinWithMedia failure',
             });
-          })
+          });
         });
 
         it('should ignore sendVideo/receiveVideo when videoEnabled is false', async () => {
@@ -1882,6 +1913,53 @@ describe('plugin-meetings', () => {
             fakeProcessedReaction
           );
         });
+
+        it('should process if participantId does not exist in membersCollection but has displayName in Webinar', () => {
+          LoggerProxy.logger.warn = sinon.stub();
+          meeting.isReactionsSupported = sinon.stub().returns(true);
+          meeting.config.receiveReactions = true;
+          meeting.locusInfo.info = {isWebinar: true};
+          const fakeSendersName = 'Fake reactors name';
+          const fakeReactionPayload = {
+            type: 'fake_type',
+            codepoints: 'fake_codepoints',
+            shortcodes: 'fake_shortcodes',
+            tone: {
+              type: 'fake_tone_type',
+              codepoints: 'fake_tone_codepoints',
+              shortcodes: 'fake_tone_shortcodes',
+            },
+          };
+          const fakeSenderPayload = {
+            displayName: 'Fake reactors name',
+            participantId: 'fake_participant_id',
+          };
+          const fakeProcessedReaction = {
+            reaction: fakeReactionPayload,
+            sender: {
+              id: fakeSenderPayload.participantId,
+              name: fakeSendersName,
+            },
+          };
+          const fakeRelayEvent = {
+            data: {
+              relayType: REACTION_RELAY_TYPES.REACTION,
+              reaction: fakeReactionPayload,
+              sender: fakeSenderPayload,
+            },
+          };
+          meeting.processRelayEvent(fakeRelayEvent);
+          assert.calledWith(
+            TriggerProxy.trigger,
+            sinon.match.instanceOf(Meeting),
+            {
+              file: 'meeting/index',
+              function: 'join',
+            },
+            EVENT_TRIGGERS.MEETING_RECEIVE_REACTIONS,
+            fakeProcessedReaction
+          );
+        });
       });
 
       describe('#handleLLMOnline', () => {
@@ -3028,6 +3106,111 @@ describe('plugin-meetings', () => {
           checkWorking({allowMediaInLobby: true});
         });
 
+        const setupLobbyTest = () => {
+          meeting.roap.doTurnDiscovery = sinon
+            .stub()
+            .resolves({turnServerInfo: undefined, turnDiscoverySkippedReason: undefined});
+
+          meeting.meetingState = 'ACTIVE';
+          meeting.locusInfo.parsedLocus = {self: {state: 'IDLE'}};
+          meeting.isUserUnadmitted = true;
+
+          // Mock locusMediaRequest
+          meeting.locusMediaRequest = {
+            send: sinon.stub().resolves(),
+            isConfluenceCreated: sinon.stub().returns(false),
+          };
+
+          sinon.stub(RemoteMediaManagerModule, 'RemoteMediaManager').returns({
+            start: sinon.stub().resolves(),
+            on: sinon.stub(),
+            logAllReceiveSlots: sinon.stub(),
+          });
+
+          meeting.isMultistream = true;
+
+          const createFakeStream = (id) => ({
+            on: sinon.stub(),
+            off: sinon.stub(),
+            userMuted: false,
+            systemMuted: false,
+            get muted() {
+              return this.userMuted || this.systemMuted;
+            },
+            setUnmuteAllowed: sinon.stub(),
+            setUserMuted: sinon.stub(),
+            outputStream: {
+              getTracks: () => [{id}],
+            },
+            getSettings: sinon.stub().returns({}),
+          });
+
+          return {
+            fakeMicrophoneStream: createFakeStream('fake mic'),
+            fakeCameraStream: createFakeStream('fake camera'),
+          };
+        };
+
+        it('should not publish any local streams when in the lobby and allowPublishMediaInLobby is false', async () => {
+          const {fakeMicrophoneStream, fakeCameraStream} = setupLobbyTest();
+
+          const publishStreamStub = sinon.stub();
+          fakeMediaConnection.createSendSlot = sinon.stub().returns({
+            publishStream: publishStreamStub,
+            unpublishStream: sinon.stub(),
+            setNamedMediaGroups: sinon.stub(),
+          });
+
+          await meeting.addMedia({
+            allowMediaInLobby: true,
+            allowPublishMediaInLobby: false,
+            audioEnabled: true,
+            videoEnabled: true,
+            localStreams: {
+              microphone: fakeMicrophoneStream,
+              camera: fakeCameraStream,
+            },
+          });
+
+          assert.notCalled(publishStreamStub);
+        });
+
+        it('should publish local streams when in the lobby and allowPublishMediaInLobby is true', async () => {
+          const {fakeMicrophoneStream, fakeCameraStream} = setupLobbyTest();
+
+          const audioSlot = {
+            publishStream: sinon.stub(),
+            unpublishStream: sinon.stub(),
+            setNamedMediaGroups: sinon.stub(),
+          };
+          const videoSlot = {
+            publishStream: sinon.stub(),
+            unpublishStream: sinon.stub(),
+            setNamedMediaGroups: sinon.stub(),
+          };
+
+          fakeMediaConnection.createSendSlot = sinon.stub().callsFake((mediaType) => {
+            if (mediaType === 'AUDIO-MAIN') {
+              return audioSlot;
+            }
+            return videoSlot;
+          });
+
+          await meeting.addMedia({
+            allowMediaInLobby: true,
+            allowPublishMediaInLobby: true,
+            audioEnabled: true,
+            videoEnabled: true,
+            localStreams: {
+              microphone: fakeMicrophoneStream,
+              camera: fakeCameraStream,
+            },
+          });
+
+          assert.calledOnceWithExactly(audioSlot.publishStream, fakeMicrophoneStream);
+          assert.calledOnceWithExactly(videoSlot.publishStream, fakeCameraStream);
+        });
+
         it('should create rtcMetrics and pass them to Media.createMediaConnection()', async () => {
           const setIntervalOriginal = window.setInterval;
           window.setInterval = sinon.stub().returns(1);
@@ -6218,7 +6401,10 @@ describe('plugin-meetings', () => {
           meeting.statsAnalyzer = {stopAnalyzer: sinon.stub().resolves()};
           meeting.unsetPeerConnections = sinon.stub().returns(true);
           meeting.logger.error = sinon.stub().returns(true);
-          meeting.updateLLMConnection = sinon.stub().returns(Promise.resolve());
+          meeting.clearMeetingData = sinon.stub().callsFake(async () => {
+            meeting.audio = null;
+            meeting.video = null;
+          });
           webex.internal.voicea.off = sinon.stub().returns(true);
           meeting.stopTranscription = sinon.stub();
           meeting.transcription = {};
@@ -6245,9 +6431,7 @@ describe('plugin-meetings', () => {
           assert.calledOnce(meeting.closePeerConnections);
           assert.calledOnce(meeting.unsetRemoteStreams);
           assert.calledOnce(meeting.unsetPeerConnections);
-          assert.calledOnce(meeting.stopTranscription);
-          assert.calledOnce(meeting.annotation.deregisterEvents);
-          assert.calledWith(webex.internal.llm.off, 'event:relay.event', meeting.processRelayEvent);
+          assert.calledOnce(meeting.clearMeetingData);
         });
 
         it('should reset call diagnostic latencies correctly', async () => {
@@ -8248,7 +8432,10 @@ describe('plugin-meetings', () => {
           meeting.statsAnalyzer = {stopAnalyzer: sinon.stub().resolves()};
           meeting.unsetPeerConnections = sinon.stub().returns(true);
           meeting.logger.error = sinon.stub().returns(true);
-          meeting.updateLLMConnection = sinon.stub().returns(Promise.resolve());
+          meeting.clearMeetingData = sinon.stub().callsFake(async () => {
+            meeting.audio = null;
+            meeting.video = null;
+          });
           meeting.transcription = {};
           meeting.stopTranscription = sinon.stub();
 
@@ -8274,10 +8461,7 @@ describe('plugin-meetings', () => {
           assert.calledOnce(meeting?.closePeerConnections);
           assert.calledOnce(meeting?.unsetRemoteStreams);
           assert.calledOnce(meeting?.unsetPeerConnections);
-          assert.calledOnce(meeting?.stopTranscription);
-
-          assert.called(meeting.annotation.deregisterEvents);
-          assert.calledWith(webex.internal.llm.off, 'event:relay.event', meeting.processRelayEvent);
+          assert.calledOnce(meeting?.clearMeetingData);
         });
       });
 
@@ -9149,7 +9333,10 @@ describe('plugin-meetings', () => {
 
             // check that the right things were called by the callback
             assert.calledOnceWithExactly(meeting.waitForRemoteSDPAnswer);
-            assert.calledOnceWithExactly(meeting.mediaProperties.waitForMediaConnectionConnected);
+            assert.calledOnceWithExactly(
+              meeting.mediaProperties.waitForMediaConnectionConnected,
+              meeting.correlationId
+            );
           });
         });
 
@@ -10323,6 +10510,21 @@ describe('plugin-meetings', () => {
             EVENT_TRIGGERS.MEETING_INTERPRETATION_UPDATE
           );
         });
+
+        it('listens to the self id changed event and updates aiEnableRequest', () => {
+          meeting.aiEnableRequest = {
+            selfParticipantIdUpdate: sinon.stub(),
+          };
+
+          const payload = {selfId: 'participant-test-123'};
+
+          meeting.locusInfo.emit({function: 'test', file: 'test'}, 'SELF_ID_CHANGED', payload);
+
+          assert.calledOnceWithExactly(
+            meeting.aiEnableRequest.selfParticipantIdUpdate,
+            payload.selfId
+          );
+        });
       });
 
       describe('#setUpBreakoutsListener', () => {
@@ -10570,6 +10772,24 @@ describe('plugin-meetings', () => {
           );
         });
 
+        it('listens to MEETING_CONTROLS_AI_SUMMARY_NOTIFICATION_UPDATED', async () => {
+          const aiSummaryNotification = {example: 'value'};
+
+          await meeting.locusInfo.emitScoped(
+            {function: 'test', file: 'test'},
+            LOCUSINFO.EVENTS.CONTROLS_AI_SUMMARY_NOTIFICATION_UPDATED,
+            {aiSummaryNotification}
+          );
+
+          assert.calledWith(
+            TriggerProxy.trigger,
+            meeting,
+            {file: 'meeting/index', function: 'setupLocusControlsListener'},
+            EVENT_TRIGGERS.MEETING_CONTROLS_AI_SUMMARY_NOTIFICATION_UPDATED,
+            {aiSummaryNotification}
+          );
+        });
+
         it('listens to MEETING_CONTROLS_MEETING_FULL_UPDATED', async () => {
           const state = {example: 'value'};
 
@@ -10842,6 +11062,9 @@ describe('plugin-meetings', () => {
           meeting.simultaneousInterpretation = {
             approvalUrlUpdate: sinon.stub().returns(undefined),
           };
+          meeting.aiEnableRequest = {
+            approvalUrlUpdate: sinon.stub().returns(undefined),
+          };
 
           meeting.locusInfo.emit(
             {function: 'test', file: 'test'},
@@ -10861,6 +11084,10 @@ describe('plugin-meetings', () => {
             meeting.simultaneousInterpretation.approvalUrlUpdate,
             newLocusServices.services.approval.url
           );
+          assert.calledWith(
+            meeting.aiEnableRequest.approvalUrlUpdate,
+            newLocusServices.services.approval.url
+          );
           assert.calledOnce(meeting.recordingController.setSessionId);
           done();
         });
@@ -11266,6 +11493,41 @@ describe('plugin-meetings', () => {
         });
       });
 
+      describe('localConstraintsChangeHandler', () => {
+        it('calls updatePreferredBitrateKbps when not multistream', () => {
+          meeting.isMultistream = false;
+          meeting.mediaProperties.webrtcMediaConnection = {
+            updatePreferredBitrateKbps: sinon.stub(),
+          };
+
+          meeting.localConstraintsChangeHandler();
+
+          assert.calledOnce(
+            meeting.mediaProperties.webrtcMediaConnection.updatePreferredBitrateKbps
+          );
+        });
+
+        it('does not call updatePreferredBitrateKbps when multistream', () => {
+          meeting.isMultistream = true;
+          meeting.mediaProperties.webrtcMediaConnection = {
+            updatePreferredBitrateKbps: sinon.stub(),
+          };
+
+          meeting.localConstraintsChangeHandler();
+
+          assert.notCalled(
+            meeting.mediaProperties.webrtcMediaConnection.updatePreferredBitrateKbps
+          );
+        });
+
+        it('does not throw when webrtcMediaConnection is undefined', () => {
+          meeting.isMultistream = false;
+          meeting.mediaProperties.webrtcMediaConnection = undefined;
+
+          assert.doesNotThrow(() => meeting.localConstraintsChangeHandler());
+        });
+      });
+
       describe('#parseMeetingInfo', () => {
         const checkParseMeetingInfo = (expectedInfoToParse) => {
           assert.equal(meeting.conversationUrl, expectedInfoToParse.conversationUrl);
@@ -11645,6 +11907,7 @@ describe('plugin-meetings', () => {
         let canUnsetDisallowUnmuteSpy;
         let canUserRaiseHandSpy;
         let bothLeaveAndEndMeetingAvailableSpy;
+        let requireHostEndMeetingBeforeLeaveSpy;
         let canUserLowerAllHandsSpy;
         let canUserLowerSomeoneElsesHandSpy;
         let waitingForOthersToJoinSpy;
@@ -11656,6 +11919,8 @@ describe('plugin-meetings', () => {
         let canMoveToLobbySpy;
         let isSpokenLanguageAutoDetectionEnabledSpy;
         let showAutoEndMeetingWarningSpy;
+        let canAttendeeRequestAiAssistantEnabledSpy;
+        let attendeeRequestAiAssistantDeclinedAllSpy;
         // Due to import tree issues, hasHints must be stubed within the scope of the `it`.
 
         beforeEach(() => {
@@ -11676,6 +11941,10 @@ describe('plugin-meetings', () => {
             MeetingUtil,
             'bothLeaveAndEndMeetingAvailable'
           );
+          requireHostEndMeetingBeforeLeaveSpy = sinon.spy(
+            MeetingUtil,
+            'requireHostEndMeetingBeforeLeave'
+          );
           canUserLowerSomeoneElsesHandSpy = sinon.spy(MeetingUtil, 'canUserLowerSomeoneElsesHand');
           waitingForOthersToJoinSpy = sinon.spy(MeetingUtil, 'waitingForOthersToJoin');
           canSendReactionsSpy = sinon.spy(MeetingUtil, 'canSendReactions');
@@ -11692,12 +11961,22 @@ describe('plugin-meetings', () => {
             MeetingUtil,
             'isSpokenLanguageAutoDetectionEnabled'
           );
+          canAttendeeRequestAiAssistantEnabledSpy = sinon.spy(
+            MeetingUtil,
+            'canAttendeeRequestAiAssistantEnabled'
+          );
+          attendeeRequestAiAssistantDeclinedAllSpy = sinon.spy(
+            MeetingUtil,
+            'attendeeRequestAiAssistantDeclinedAll'
+          );
         });
 
         afterEach(() => {
           inMeetingActionsSetSpy.restore();
           waitingForOthersToJoinSpy.restore();
           showAutoEndMeetingWarningSpy.restore();
+          canAttendeeRequestAiAssistantEnabledSpy.restore();
+          attendeeRequestAiAssistantDeclinedAllSpy.restore();
         });
 
         forEach(
@@ -12221,6 +12500,7 @@ describe('plugin-meetings', () => {
           const userDisplayHints = ['LOCK_CONTROL_UNLOCK'];
           meeting.userDisplayHints = ['LOCK_CONTROL_UNLOCK'];
           meeting.meetingInfo.supportVoIP = true;
+          meeting.roles = [];
 
           meeting.updateMeetingActions();
 
@@ -12236,6 +12516,7 @@ describe('plugin-meetings', () => {
           assert.calledWith(canUnsetDisallowUnmuteSpy, userDisplayHints);
           assert.calledWith(canUserRaiseHandSpy, userDisplayHints);
           assert.calledWith(bothLeaveAndEndMeetingAvailableSpy, userDisplayHints);
+          assert.calledWith(requireHostEndMeetingBeforeLeaveSpy, userDisplayHints);
           assert.calledWith(canUserLowerAllHandsSpy, userDisplayHints);
           assert.calledWith(canUserLowerSomeoneElsesHandSpy, userDisplayHints);
           assert.calledWith(waitingForOthersToJoinSpy, userDisplayHints);
@@ -12247,6 +12528,12 @@ describe('plugin-meetings', () => {
           assert.calledWith(canMoveToLobbySpy, userDisplayHints);
           assert.calledWith(showAutoEndMeetingWarningSpy, userDisplayHints);
           assert.calledWith(isSpokenLanguageAutoDetectionEnabledSpy, userDisplayHints);
+          assert.calledWith(
+            canAttendeeRequestAiAssistantEnabledSpy,
+            userDisplayHints,
+            meeting.roles
+          );
+          assert.calledWith(attendeeRequestAiAssistantDeclinedAllSpy, userDisplayHints);
 
           assert.calledWith(ControlsOptionsUtil.hasHints, {
             requiredHints: [DISPLAY_HINTS.MUTE_ALL],
@@ -12389,33 +12676,72 @@ describe('plugin-meetings', () => {
 
       describe('#handleDataChannelUrlChange', () => {
         let updateLLMConnectionSpy;
+        let updatePSDataChannelSpy;
 
         beforeEach(() => {
           updateLLMConnectionSpy = sinon.spy(meeting, 'updateLLMConnection');
+          updatePSDataChannelSpy = sinon.stub(meeting.webinar, 'updatePSDataChannel').resolves();
+          meeting.webinar.isJoinPracticeSessionDataChannel = sinon.stub().returns(false);
         });
 
-        const check = (url, expectedCalled) => {
-          meeting.handleDataChannelUrlChange(url);
+        const check = (
+          url,
+          practiceSessionDatachannelUrl,
+          {expectedMainCalled, expectedPracticeCalled}
+        ) => {
+          meeting.handleDataChannelUrlChange(url, practiceSessionDatachannelUrl);
 
-          if (expectedCalled) {
+          if (expectedMainCalled) {
             assert.calledWith(updateLLMConnectionSpy);
           } else {
             assert.notCalled(updateLLMConnectionSpy);
           }
+
+          if (expectedPracticeCalled) {
+            assert.calledWith(updatePSDataChannelSpy);
+          } else {
+            assert.notCalled(updatePSDataChannelSpy);
+          }
         };
 
         it('calls deferred updateLLMConnection if datachannelURL is set and the enableAutomaticLLM is true', () => {
           meeting.config.enableAutomaticLLM = true;
-          check('some url', true);
+          check('some url', undefined, {expectedMainCalled: true, expectedPracticeCalled: false});
         });
 
         it('does not call updateLLMConnection if datachannelURL is undefined', () => {
           meeting.config.enableAutomaticLLM = true;
-          check(undefined, false);
+          check(undefined, undefined, {
+            expectedMainCalled: false,
+            expectedPracticeCalled: false,
+          });
         });
 
         it('does not call updateLLMConnection if enableAutomaticLLM is false', () => {
-          check('some url', false);
+          check('some url', 'some practice url', {
+            expectedMainCalled: false,
+            expectedPracticeCalled: false,
+          });
+        });
+
+        it('calls updatePSDataChannel when practice-session routing is active', () => {
+          meeting.config.enableAutomaticLLM = true;
+          meeting.webinar.isJoinPracticeSessionDataChannel.returns(true);
+
+          check('some url', 'some practice url', {
+            expectedMainCalled: true,
+            expectedPracticeCalled: true,
+          });
+        });
+
+        it('does not call updatePSDataChannel when the main datachannelURL is undefined', () => {
+          meeting.config.enableAutomaticLLM = true;
+          meeting.webinar.isJoinPracticeSessionDataChannel.returns(true);
+
+          check(undefined, 'some practice url', {
+            expectedMainCalled: false,
+            expectedPracticeCalled: false,
+          });
         });
       });
 
@@ -12424,16 +12750,20 @@ describe('plugin-meetings', () => {
           webex.internal.llm.isConnected = sinon.stub().returns(false);
           webex.internal.llm.getLocusUrl = sinon.stub();
           webex.internal.llm.getDatachannelUrl = sinon.stub();
-          webex.internal.llm.registerAndConnect = sinon
-            .stub()
-            .returns(Promise.resolve('something'));
-          webex.internal.llm.disconnectLLM = sinon.stub().returns(Promise.resolve());
-          meeting.webex.internal.llm.on = sinon.stub();
-          meeting.webex.internal.llm.off = sinon.stub();
+          webex.internal.llm.registerAndConnect = sinon.stub().resolves('something');
+          webex.internal.llm.disconnectLLM = sinon.stub().resolves();
+          webex.internal.llm.on = sinon.stub();
+          webex.internal.llm.off = sinon.stub();
+          webex.internal.llm.getDatachannelToken = sinon.stub().returns(undefined);
+          webex.internal.llm.setDatachannelToken = sinon.stub();
+
           meeting.processRelayEvent = sinon.stub();
+          meeting.processLocusLLMEvent = sinon.stub();
+          meeting.clearLLMHealthCheckTimer = sinon.stub();
+          meeting.startLLMHealthCheckTimer = sinon.stub();
+
           meeting.webinar.isJoinPracticeSessionDataChannel = sinon.stub().returns(false);
         });
-
         it('does not connect if the call is not joined yet', async () => {
           meeting.joinedWith = {state: 'any other state'};
           webex.internal.llm.getLocusUrl.returns('a url');
@@ -12447,31 +12777,21 @@ describe('plugin-meetings', () => {
           assert.equal(result, undefined);
           assert.notCalled(meeting.webex.internal.llm.on);
         });
-
         it('returns undefined if llm is already connected and the locus url is unchanged', async () => {
           meeting.joinedWith = {state: 'JOINED'};
-          webex.internal.llm.isConnected.returns(true);
-          webex.internal.llm.getLocusUrl.returns('a url');
-          webex.internal.llm.getDatachannelUrl.returns('a datachannel url');
-
-          meeting.locusInfo = {url: 'a url', info: {datachannelUrl: 'a datachannel url'}};
-
-          const result = await meeting.updateLLMConnection();
-
-          assert.notCalled(webex.internal.llm.registerAndConnect);
-          assert.notCalled(webex.internal.llm.disconnectLLM);
-          assert.equal(result, undefined);
-          assert.notCalled(meeting.webex.internal.llm.on);
-        });
-
-        it('connects if not already connected', async () => {
-          meeting.joinedWith = {state: 'JOINED'};
-          meeting.locusInfo = {url: 'a url', info: {datachannelUrl: 'a datachannel url'}};
+          meeting.locusInfo = {
+            url: 'a url',
+            info: {datachannelUrl: 'a datachannel url'},
+          };
 
           const result = await meeting.updateLLMConnection();
-
           assert.notCalled(webex.internal.llm.disconnectLLM);
-          assert.calledWith(webex.internal.llm.registerAndConnect, 'a url', 'a datachannel url');
+          assert.calledWithExactly(
+            webex.internal.llm.registerAndConnect,
+            'a url',
+            'a datachannel url',
+            undefined
+          );
           assert.equal(result, 'something');
           assert.calledWithExactly(
             meeting.webex.internal.llm.off,
@@ -12494,27 +12814,49 @@ describe('plugin-meetings', () => {
             meeting.processLocusLLMEvent
           );
         });
+        it('connects if not already connected', async () => {
+          meeting.joinedWith = {state: 'JOINED'};
+          meeting.locusInfo = {url: 'a url', info: {datachannelUrl: 'a datachannel url'}};
+
+          const result = await meeting.updateLLMConnection();
 
-        it('disconnects if first if the locus url has changed', async () => {
+          assert.notCalled(webex.internal.llm.disconnectLLM);
+          assert.calledWithExactly(
+            webex.internal.llm.registerAndConnect,
+            'a url',
+            'a datachannel url',
+            undefined
+          );
+          assert.equal(result, 'something');
+        });
+        it('disconnects if the locus url has changed', async () => {
           meeting.joinedWith = {state: 'JOINED'};
+
           webex.internal.llm.isConnected.returns(true);
           webex.internal.llm.getLocusUrl.returns('a url');
-          webex.internal.llm.getDatachannelUrl.returns('a datachannel url');
 
-          meeting.locusInfo = {url: 'a different url', info: {datachannelUrl: 'a datachannel url'}};
+          meeting.locusInfo = {
+            url: 'a different url',
+            info: {datachannelUrl: 'a datachannel url'},
+            self: {},
+          };
 
           const result = await meeting.updateLLMConnection();
 
-          assert.calledWith(webex.internal.llm.disconnectLLM, {
+          assert.calledWithExactly(webex.internal.llm.disconnectLLM, {
             code: 3050,
             reason: 'done (permanent)',
           });
-          assert.calledWith(
+
+          assert.calledWithExactly(
             webex.internal.llm.registerAndConnect,
             'a different url',
-            'a datachannel url'
+            'a datachannel url',
+            undefined
           );
+
           assert.equal(result, 'something');
+
           assert.calledWithExactly(
             meeting.webex.internal.llm.off,
             'event:relay.event',
@@ -12526,6 +12868,7 @@ describe('plugin-meetings', () => {
             meeting.processLocusLLMEvent
           );
           assert.callCount(meeting.webex.internal.llm.off, 4);
+
           assert.calledWithExactly(
             meeting.webex.internal.llm.on,
             'event:relay.event',
@@ -12536,28 +12879,37 @@ describe('plugin-meetings', () => {
             'event:locus.state_message',
             meeting.processLocusLLMEvent
           );
+          assert.isFalse(
+            meeting.webex.internal.llm.off.calledWithExactly('online', meeting.handleLLMOnline)
+          );
         });
-
-        it('disconnects it first if the data channel url has changed', async () => {
+        it('disconnects if the data channel url has changed', async () => {
           meeting.joinedWith = {state: 'JOINED'};
           webex.internal.llm.isConnected.returns(true);
           webex.internal.llm.getLocusUrl.returns('a url');
-          webex.internal.llm.getDatachannelUrl.returns('a datachannel url');
 
-          meeting.locusInfo = {url: 'a url', info: {datachannelUrl: 'a different datachannel url'}};
+          meeting.locusInfo = {
+            url: 'a url',
+            info: {datachannelUrl: 'a different datachannel url'},
+            self: {},
+          };
 
           const result = await meeting.updateLLMConnection();
 
-          assert.calledWith(webex.internal.llm.disconnectLLM, {
+          assert.calledWithExactly(webex.internal.llm.disconnectLLM, {
             code: 3050,
             reason: 'done (permanent)',
           });
-          assert.calledWith(
+
+          assert.calledWithExactly(
             webex.internal.llm.registerAndConnect,
             'a url',
-            'a different datachannel url'
+            'a different datachannel url',
+            undefined
           );
+
           assert.equal(result, 'something');
+
           assert.calledWithExactly(
             meeting.webex.internal.llm.off,
             'event:relay.event',
@@ -12568,6 +12920,7 @@ describe('plugin-meetings', () => {
             'event:locus.state_message',
             meeting.processLocusLLMEvent
           );
+
           assert.calledWithExactly(
             meeting.webex.internal.llm.on,
             'event:relay.event',
@@ -12578,8 +12931,10 @@ describe('plugin-meetings', () => {
             'event:locus.state_message',
             meeting.processLocusLLMEvent
           );
+          assert.isFalse(
+            meeting.webex.internal.llm.off.calledWithExactly('online', meeting.handleLLMOnline)
+          );
         });
-
         it('disconnects when the state is not JOINED', async () => {
           meeting.joinedWith = {state: 'any other state'};
           webex.internal.llm.isConnected.returns(true);
@@ -12589,9 +12944,38 @@ describe('plugin-meetings', () => {
 
           const result = await meeting.updateLLMConnection();
 
-          assert.calledWith(webex.internal.llm.disconnectLLM, undefined);
+          assert.calledWith(webex.internal.llm.disconnectLLM, {
+            code: 3050,
+            reason: 'done (permanent)',
+          });
           assert.notCalled(webex.internal.llm.registerAndConnect);
           assert.equal(result, undefined);
+          assert.isFalse(
+            meeting.webex.internal.llm.off.calledWithExactly('online', meeting.handleLLMOnline)
+          );
+        });
+        it('rethrows disconnect errors during reconnect cleanup after removing relay listeners and timer', async () => {
+          const disconnectError = new Error('disconnect failed');
+
+          meeting.joinedWith = {state: 'JOINED'};
+          webex.internal.llm.isConnected.returns(true);
+          webex.internal.llm.getLocusUrl.returns('a url');
+          webex.internal.llm.disconnectLLM.rejects(disconnectError);
+
+          meeting.locusInfo = {
+            url: 'a different url',
+            info: {datachannelUrl: 'a datachannel url'},
+            self: {},
+          };
+
+          try {
+            await meeting.updateLLMConnection();
+            assert.fail('Expected updateLLMConnection to reject when disconnectLLM fails');
+          } catch (error) {
+            assert.equal(error, disconnectError);
+          }
+
+          assert.notCalled(webex.internal.llm.registerAndConnect);
           assert.calledWithExactly(
             meeting.webex.internal.llm.off,
             'event:relay.event',
@@ -12602,22 +12986,149 @@ describe('plugin-meetings', () => {
             'event:locus.state_message',
             meeting.processLocusLLMEvent
           );
+          assert.isFalse(
+            meeting.webex.internal.llm.off.calledWithExactly('online', meeting.handleLLMOnline)
+          );
+          assert.calledOnce(meeting.clearLLMHealthCheckTimer);
         });
-
-        it('connect ps data channel if ps started in webinar', async () => {
+        it('still need connect main session data channel when PS started', async () => {
           meeting.joinedWith = {state: 'JOINED'};
           meeting.locusInfo = {
             url: 'a url',
             info: {
               datachannelUrl: 'a datachannel url',
-              practiceSessionDatachannelUrl: 'a ps datachannel url',
+              practiceSessionDatachannelUrl: 'ps-url',
             },
           };
-          meeting.webinar.isJoinPracticeSessionDataChannel = sinon.stub().returns(true);
+          meeting.webinar.isJoinPracticeSessionDataChannel.returns(true);
+
           await meeting.updateLLMConnection();
 
-          assert.notCalled(webex.internal.llm.disconnectLLM);
-          assert.calledWith(webex.internal.llm.registerAndConnect, 'a url', 'a ps datachannel url');
+          assert.calledWithExactly(
+            webex.internal.llm.registerAndConnect,
+            'a url',
+            'a datachannel url',
+            undefined
+          );
+        });
+        it('passes dataChannelToken to registerAndConnect', async () => {
+          meeting.joinedWith = {state: 'JOINED'};
+          meeting.locusInfo = {
+            url: 'a url',
+            info: {datachannelUrl: 'a datachannel url'},
+            self: {datachannelToken: 'token-123'},
+          };
+
+          webex.internal.llm.getDatachannelToken.returns(undefined);
+
+          await meeting.updateLLMConnection();
+
+          assert.calledWithExactly(
+            webex.internal.llm.registerAndConnect,
+            'a url',
+            'a datachannel url',
+            'token-123'
+          );
+          assert.calledWithExactly(webex.internal.llm.setDatachannelToken, 'token-123', 'llm-default-session');
+        });
+        it('prefers refreshed token over locus self token', async () => {
+          meeting.joinedWith = {state: 'JOINED'};
+          meeting.locusInfo = {
+            url: 'a url',
+            info: {datachannelUrl: 'a datachannel url'},
+            self: {datachannelToken: 'locus-token'},
+          };
+
+          webex.internal.llm.getDatachannelToken.withArgs('llm-default-session').returns('refreshed-token');
+
+          await meeting.updateLLMConnection();
+
+          assert.calledWithExactly(
+            webex.internal.llm.registerAndConnect,
+            'a url',
+            'a datachannel url',
+            'refreshed-token'
+          );
+
+          assert.notCalled(webex.internal.llm.setDatachannelToken);
+        });
+
+        it('does not pass token when data channel with jwt token is disabled', async () => {
+          meeting.joinedWith = {state: 'JOINED'};
+          meeting.locusInfo = {
+            url: 'a url',
+            info: {datachannelUrl: 'a datachannel url'},
+            self: {datachannelToken: 'token-123'},
+          };
+
+          webex.internal.llm.getDatachannelToken.returns(undefined);
+          webex.internal.llm.isDataChannelTokenEnabled = sinon.stub().resolves(false);
+
+          await meeting.updateLLMConnection();
+
+          assert.calledWithExactly(
+            webex.internal.llm.registerAndConnect,
+            'a url',
+            'a datachannel url',
+            'token-123'
+          );
+          assert.calledWithExactly(webex.internal.llm.setDatachannelToken, 'token-123', 'llm-default-session');
+        });
+
+        describe('#clearMeetingData', () => {
+          beforeEach(() => {
+            webex.internal.llm.isConnected = sinon.stub().returns(true);
+            webex.internal.llm.disconnectLLM = sinon.stub().resolves();
+            webex.internal.llm.off = sinon.stub();
+            meeting.annotation.deregisterEvents = sinon.stub();
+            meeting.clearLLMHealthCheckTimer = sinon.stub();
+            meeting.stopTranscription = sinon.stub();
+            meeting.transcription = {};
+            meeting.shareStatus = 'no-share';
+          });
+
+          it('disconnects llm and removes online and relay listeners during meeting data cleanup', async () => {
+            await meeting.clearMeetingData();
+
+            assert.calledOnceWithExactly(webex.internal.llm.disconnectLLM, {
+              code: 3050,
+              reason: 'done (permanent)',
+            });
+            assert.calledWithExactly(webex.internal.llm.off, 'online', meeting.handleLLMOnline);
+            assert.calledWithExactly(
+              webex.internal.llm.off,
+              'event:relay.event',
+              meeting.processRelayEvent
+            );
+            assert.calledWithExactly(
+              webex.internal.llm.off,
+              'event:locus.state_message',
+              meeting.processLocusLLMEvent
+            );
+            assert.calledOnce(meeting.clearLLMHealthCheckTimer);
+            assert.calledOnce(meeting.stopTranscription);
+            assert.calledOnce(meeting.annotation.deregisterEvents);
+          });
+          it('continues cleanup when disconnectLLM fails during meeting data cleanup', async () => {
+            webex.internal.llm.disconnectLLM.rejects(new Error('disconnect failed'));
+
+            await meeting.clearMeetingData();
+
+            assert.calledWithExactly(webex.internal.llm.off, 'online', meeting.handleLLMOnline);
+            assert.calledWithExactly(
+              webex.internal.llm.off,
+              'event:relay.event',
+              meeting.processRelayEvent
+            );
+            assert.calledWithExactly(
+              webex.internal.llm.off,
+              'event:locus.state_message',
+              meeting.processLocusLLMEvent
+            );
+            assert.calledOnce(meeting.clearLLMHealthCheckTimer);
+            assert.calledOnce(meeting.stopTranscription);
+            assert.calledOnce(meeting.annotation.deregisterEvents);
+          });
         });
       });
 
@@ -12628,6 +13139,7 @@ describe('plugin-meetings', () => {
 
         it('should read the locus object, set on the meeting and return null', () => {
           const dataSets = {someFakeStuff: 'dataSet'};
+          const metadata = {some: 'metadata'};
 
           meeting.setLocus({
             mediaConnections: [test1],
@@ -12637,12 +13149,14 @@ describe('plugin-meetings', () => {
             mediaId: uuid3,
             locus: {host: {id: uuid4}},
             dataSets,
+            metadata,
           });
           assert.calledOnce(meeting.locusInfo.initialSetup);
           assert.calledWith(meeting.locusInfo.initialSetup, {
             trigger: 'join-response',
             locus: {host: {id: uuid4}},
             dataSets,
+            metadata,
           });
           assert.equal(meeting.mediaConnections, test1);
           assert.equal(meeting.locusUrl, url1);
@@ -14184,6 +14698,69 @@ describe('plugin-meetings', () => {
           assert.calledOnce(meeting.meetingRequest.keepAlive);
         });
       });
+      describe('#refreshDataChannelToken()', () => {
+        let meeting;
+
+        beforeEach(() => {
+          meeting = Object.create(Meeting.prototype);
+          meeting.locusUrl = 'https://locus.example.com';
+          meeting.meetingRequest = {
+            fetchDatachannelToken: sinon.stub().resolves({
+              body: {datachannelToken: 'mock-token'},
+            }),
+          };
+          meeting.members = {
+            selfId: 'self-123',
+          };
+          meeting.webinar = {
+            isJoinPracticeSessionDataChannel: sinon.stub().returns(true),
+          };
+        });
+
+        it('calls fetchDatachannelToken with correct parameters', async () => {
+          await meeting.refreshDataChannelToken();
+
+          sinon.assert.calledOnce(meeting.meetingRequest.fetchDatachannelToken);
+
+          sinon.assert.calledWith(meeting.meetingRequest.fetchDatachannelToken, {
+            locusUrl: 'https://locus.example.com',
+            requestingParticipantId: 'self-123',
+            isPracticeSession: true,
+          });
+        });
+
+        it('returns the correct structured result', async () => {
+          const result = await meeting.refreshDataChannelToken();
+
+          expect(result).to.deep.equal({
+            body: {
+              datachannelToken: 'mock-token',
+              dataChannelTokenType: 'llm-practice-session',
+            },
+          });
+        });
+      });
+      describe('#getDataChannelTokenType', () => {
+        it('returns PracticeSession when webinar is in practice session mode', () => {
+          meeting.webinar = {
+            isJoinPracticeSessionDataChannel: sinon.stub().returns(true),
+          };
+
+          const result = meeting.getDataChannelTokenType();
+
+          expect(result).to.equal('llm-practice-session');
+        });
+
+        it('returns Default when not in practice session mode', () => {
+          meeting.webinar = {
+            isJoinPracticeSessionDataChannel: sinon.stub().returns(false),
+          };
+
+          const result = meeting.getDataChannelTokenType();
+
+          expect(result).to.equal('llm-default-session');
+        });
+      });
       describe('#stopKeepAlive', () => {
         let clock;
         const defaultKeepAliveUrl = 'keep.alive.url';