@webex/plugin-meetings 3.12.0-next.8 → 3.12.0-task-refactor.1

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

@@ -38,7 +38,6 @@ import {
 import {
   ConnectionState,
   MediaConnectionEventNames,
-  MediaCodecMimeType,
   StatsAnalyzerEventNames,
   StatsMonitorEventNames,
   Errors,
@@ -47,7 +46,6 @@ import {
   MediaType,
 } from '@webex/internal-media-core';
 import {LocalStreamEventNames} from '@webex/media-helpers';
-import {CapabilityState, WebCapabilities} from '@webex/web-capabilities';
 import EventsScope from '@webex/plugin-meetings/src/common/events/events-scope';
 import Meetings, {CONSTANTS} from '@webex/plugin-meetings';
 import Meeting from '@webex/plugin-meetings/src/meeting';
@@ -83,7 +81,6 @@ 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 {
@@ -125,6 +122,7 @@ 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: () => {},
@@ -135,15 +133,11 @@ describe('plugin-meetings', () => {
     debug: () => {},
   };
 
-  let fakeClock;
-
   beforeEach(() => {
     sinon.stub(Metrics, 'sendBehavioralMetric');
-    fakeClock = sinon.useFakeTimers();
   });
   afterEach(() => {
     sinon.restore();
-    fakeClock.restore();
   });
 
   before(() => {
@@ -266,9 +260,7 @@ 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}
@@ -379,7 +371,6 @@ 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', () => {
@@ -739,13 +730,8 @@ describe('plugin-meetings', () => {
         let handleTurnDiscoveryHttpResponseStub;
         let abortTurnDiscoveryStub;
         let addMediaInternalStub;
-        let supportsRTCPeerConnectionStub;
 
         beforeEach(() => {
-          supportsRTCPeerConnectionStub = sinon
-            .stub(WebCapabilities, 'supportsRTCPeerConnection')
-            .returns(CapabilityState.CAPABLE);
-
           meeting.join = sinon.stub().callsFake((joinOptions) => {
             meeting.isMultistream = joinOptions.enableMultistream;
             return Promise.resolve(fakeJoinResult);
@@ -1017,55 +1003,6 @@ describe('plugin-meetings', () => {
           );
         });
 
-        it('should call leave() if addMediaInternal() fails with a browser media error (TypeError)', async () => {
-          const addMediaError = new Error('fake addMedia error');
-          addMediaError.name = 'TypeError'; // This makes it a browser media error
-
-          const leaveStub = sinon.stub(meeting, 'leave').resolves();
-          meeting.addMediaInternal = sinon.stub().rejects(addMediaError);
-
-          // When a browser media error occurs, it gets transformed into a special structure
-          const rejectedError = await assert.isRejected(
-            meeting.joinWithMedia({
-              joinOptions,
-              mediaOptions,
-            })
-          );
-
-          // 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 () => {
           const addMediaError = new Error('fake addMedia error');
           const leaveStub = sinon.stub(meeting, 'leave');
@@ -1274,54 +1211,43 @@ describe('plugin-meetings', () => {
           await assert.isRejected(result);
         });
 
-        [
-          {
-            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');
-            addMediaError.name = errorName;
+        it('should not attempt a retry if we fail to create the offer on first atttempt', async () => {
+          const addMediaError = new Error('fake addMedia error');
+          addMediaError.name = 'SdpOfferCreationError';
 
-            meeting.addMediaInternal.rejects(addMediaError);
-            sinon.stub(meeting, 'leave').resolves();
+          meeting.addMediaInternal.rejects(addMediaError);
+          sinon.stub(meeting, 'leave').resolves();
 
-            await assert.isRejected(
-              meeting.joinWithMedia({
-                joinOptions,
-                mediaOptions,
-              }),
-              addMediaError
-            );
+          await assert.isRejected(
+            meeting.joinWithMedia({
+              joinOptions,
+              mediaOptions,
+            }),
+            addMediaError
+          );
 
-            // check that only 1 attempt was done
-            assert.calledOnce(meeting.join);
-            assert.calledOnce(meeting.addMediaInternal);
-            assert.calledOnce(Metrics.sendBehavioralMetric);
-            assert.calledWith(
-              Metrics.sendBehavioralMetric.firstCall,
-              BEHAVIORAL_METRICS.JOIN_WITH_MEDIA_FAILURE,
-              {
-                correlation_id: meeting.correlationId,
-                locus_id: meeting.locusUrl.split('/').pop(),
-                reason: addMediaError.message,
-                stack: addMediaError.stack,
-                leaveErrorReason: undefined,
-                isRetry: false,
-              },
-              {
-                type: addMediaError.name,
-              }
-            );
-            assert.calledOnceWithExactly(meeting.leave, {
-              resourceId: undefined,
-              reason: 'joinWithMedia failure',
-            });
+          // check that only 1 attempt was done
+          assert.calledOnce(meeting.join);
+          assert.calledOnce(meeting.addMediaInternal);
+          assert.calledOnce(Metrics.sendBehavioralMetric);
+          assert.calledWith(
+            Metrics.sendBehavioralMetric.firstCall,
+            BEHAVIORAL_METRICS.JOIN_WITH_MEDIA_FAILURE,
+            {
+              correlation_id: meeting.correlationId,
+              locus_id: meeting.locusUrl.split('/').pop(),
+              reason: addMediaError.message,
+              stack: addMediaError.stack,
+              leaveErrorReason: undefined,
+              isRetry: false,
+            },
+            {
+              type: addMediaError.name,
+            }
+          );
+          assert.calledOnceWithExactly(meeting.leave, {
+            resourceId: undefined,
+            reason: 'joinWithMedia failure',
           });
         });
 
@@ -1390,21 +1316,6 @@ describe('plugin-meetings', () => {
             })
           );
         });
-
-        it('should throw immediately if RTCPeerConnection is not available', async () => {
-          supportsRTCPeerConnectionStub.returns(CapabilityState.NOT_CAPABLE);
-
-          await assert.isRejected(
-            meeting.joinWithMedia({
-              joinOptions,
-              mediaOptions,
-            }),
-            Errors.WebrtcApiNotAvailableError
-          );
-
-          assert.notCalled(meeting.join);
-          assert.notCalled(meeting.addMediaInternal);
-        });
       });
       describe('#isTranscriptionSupported', () => {
         it('should return false if the feature is not supported for the meeting', () => {
@@ -1419,25 +1330,6 @@ describe('plugin-meetings', () => {
         });
       });
 
-      describe('#update hesiod llm id', () => {
-        beforeEach(() => {
-          webex.internal.voicea.onCaptionServiceIdUpdate = sinon.stub();
-        });
-        afterEach(() => {
-          // Restore the original methods after each test
-          sinon.restore();
-        });
-        it('should call voicea.onCaptionServiceIdUpdate when joined', async () => {
-          meeting.joinedWith = {state: 'JOINED'};
-          await meeting.locusInfo.emitScoped(
-            {function: 'test', file: 'test'},
-            LOCUSINFO.EVENTS.CONTROLS_MEETING_HESIOD_LLM_ID_UPDATED,
-            {hesiodLlmId: '123a-456b-789c'}
-          );
-          assert.calledWith(webex.internal.voicea.onCaptionServiceIdUpdate, '123a-456b-789c');
-        });
-      });
-
       describe('#update spoken language', () => {
         beforeEach(() => {
           webex.internal.voicea.onSpokenLanguageUpdate = sinon.stub();
@@ -1553,22 +1445,6 @@ describe('plugin-meetings', () => {
             EVENT_TRIGGERS.MEETING_STOPPED_RECEIVING_TRANSCRIPTION
           );
         });
-
-        it('should stop listening to voicea events even when transcription is undefined', () => {
-          meeting.transcription = undefined;
-          meeting.stopTranscription();
-          assert.equal(webex.internal.voicea.off.callCount, 4);
-          assert.equal(meeting.areVoiceaEventsSetup, false);
-          assert.calledWith(
-            TriggerProxy.trigger,
-            sinon.match.instanceOf(Meeting),
-            {
-              file: 'meeting/index',
-              function: 'triggerStopReceivingTranscriptionEvent',
-            },
-            EVENT_TRIGGERS.MEETING_STOPPED_RECEIVING_TRANSCRIPTION
-          );
-        });
       });
 
       describe('#setCaptionLanguage', () => {
@@ -1930,64 +1806,16 @@ 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', () => {
         beforeEach(() => {
           webex.internal.llm.off = sinon.stub();
-          webex.internal.voicea.getIsCaptionBoxOn = sinon.stub().returns(false);
-          webex.internal.voicea.updateSubchannelSubscriptions = sinon.stub();
         });
 
-        it('emits transcription connected events', () => {
+        it('turns off llm online, emits transcription connected events', () => {
           meeting.handleLLMOnline();
+          assert.calledOnceWithExactly(webex.internal.llm.off, 'online', meeting.handleLLMOnline);
           assert.calledWith(
             TriggerProxy.trigger,
             sinon.match.instanceOf(Meeting),
@@ -1998,24 +1826,6 @@ describe('plugin-meetings', () => {
             EVENT_TRIGGERS.MEETING_TRANSCRIPTION_CONNECTED
           );
         });
-
-        it('restores transcription subscription when caption intent is enabled', () => {
-          webex.internal.voicea.getIsCaptionBoxOn.returns(true);
-
-          meeting.handleLLMOnline();
-
-          assert.calledOnceWithExactly(webex.internal.voicea.updateSubchannelSubscriptions, {
-            subscribe: ['transcription'],
-          });
-        });
-
-        it('does not restore transcription subscription when caption intent is disabled', () => {
-          webex.internal.voicea.getIsCaptionBoxOn.returns(false);
-
-          meeting.handleLLMOnline();
-
-          assert.notCalled(webex.internal.voicea.updateSubchannelSubscriptions);
-        });
       });
 
       describe('#join', () => {
@@ -2035,7 +1845,6 @@ describe('plugin-meetings', () => {
         it('should have #join', () => {
           assert.exists(meeting.join);
         });
-
         beforeEach(() => {
           setCorrelationIdSpy = sinon.spy(meeting, 'setCorrelationId');
           meeting.setLocus = sinon.stub().returns(true);
@@ -2189,6 +1998,7 @@ describe('plugin-meetings', () => {
             await meeting.join().catch(() => {
               assert.calledOnce(MeetingUtil.joinMeeting);
 
+              // Assert that client.locus.join.response error event is not sent from this function, it is now emitted from MeetingUtil.joinMeeting
               assert.calledOnce(webex.internal.newMetrics.submitClientEvent);
               assert.calledWithMatch(webex.internal.newMetrics.submitClientEvent, {
                 name: 'client.call.initiated',
@@ -2220,7 +2030,6 @@ describe('plugin-meetings', () => {
             });
           });
         });
-
         describe('lmm, transcription & permissionTokenRefresh decoupling', () => {
           beforeEach(() => {
             sandbox.stub(MeetingUtil, 'joinMeeting').returns(Promise.resolve(joinMeetingResult));
@@ -2291,6 +2100,7 @@ describe('plugin-meetings', () => {
               const locusInfoParseStub = sinon.stub(meeting.locusInfo, 'parse');
               sinon.stub(meeting, 'isJoined').returns(true);
 
+              // Set up llm.on stub to capture the registered listener when updateLLMConnection is called
               let locusLLMEventListener;
               meeting.webex.internal.llm.on = sinon.stub().callsFake((eventName, callback) => {
                 if (eventName === 'event:locus.state_message') {
@@ -2299,12 +2109,16 @@ describe('plugin-meetings', () => {
               });
               meeting.webex.internal.llm.off = sinon.stub();
 
+              // we need the real meeting.updateLLMConnection not the mock
               meeting.updateLLMConnection.restore();
 
+              // Call updateLLMConnection to register the listener
               await meeting.updateLLMConnection();
 
+              // Verify the listener was registered and we captured it
               assert.isDefined(locusLLMEventListener, 'LLM event listener should be registered');
 
+              // Now trigger the event
               const eventData = {
                 eventType: 'locus.state_message',
                 stateElementsMessage: {
@@ -2317,66 +2131,6 @@ describe('plugin-meetings', () => {
 
               assert.calledOnceWithExactly(locusInfoParseStub, meeting, eventData);
             });
-
-            it('UpdateLLMConnection sends a metric if not connected after timeout', async () => {
-              sinon.stub(meeting, 'isJoined').returns(true);
-              sinon.stub(meeting.webex.internal.llm, 'isConnected').returns(false);
-              sinon.stub(meeting.webex.internal.llm, 'hasEverConnected').value(true);
-              sinon.stub(meeting.webex.internal.llm, 'registerAndConnect').resolves({});
-
-              meeting.updateLLMConnection.restore();
-
-              await meeting.updateLLMConnection();
-
-              fakeClock.tick(3 * 60 * 1000);
-
-              assert.calledWith(
-                Metrics.sendBehavioralMetric,
-                BEHAVIORAL_METRICS.LLM_HEALTHCHECK_FAILURE,
-                {
-                  correlation_id: meeting.correlationId,
-                  hasEverConnected: true,
-                }
-              );
-            });
-
-            it('clears the LLM health check timer when disconnecting LLM', async () => {
-              const isJoinedStub = sinon.stub(meeting, 'isJoined');
-              sinon.stub(meeting.webex.internal.llm, 'isConnected');
-              sinon.stub(meeting.webex.internal.llm, 'disconnectLLM').resolves();
-              sinon.stub(meeting.webex.internal.llm, 'registerAndConnect').resolves({});
-              sinon
-                .stub(meeting.webex.internal.llm, 'getLocusUrl')
-                .returns('https://locus1.example.com');
-              sinon
-                .stub(meeting.webex.internal.llm, 'getDatachannelUrl')
-                .returns('https://datachannel1.example.com');
-
-              meeting.updateLLMConnection.restore();
-
-              isJoinedStub.returns(true);
-              meeting.webex.internal.llm.isConnected.returns(false);
-              await meeting.updateLLMConnection();
-
-              assert.exists(meeting.llmHealthCheckTimer);
-
-              isJoinedStub.returns(false);
-              meeting.webex.internal.llm.isConnected.returns(true);
-
-              await meeting.updateLLMConnection();
-
-              assert.calledOnce(meeting.webex.internal.llm.disconnectLLM);
-
-              assert.isUndefined(meeting.llmHealthCheckTimer);
-
-              Metrics.sendBehavioralMetric.resetHistory();
-              fakeClock.tick(3 * 60 * 1000);
-
-              assert.neverCalledWith(
-                Metrics.sendBehavioralMetric,
-                BEHAVIORAL_METRICS.LLM_HEALTHCHECK_FAILURE
-              );
-            });
           });
 
           describe('refreshPermissionToken', () => {
@@ -2403,6 +2157,7 @@ describe('plugin-meetings', () => {
                 .stub()
                 .rejects(new CaptchaError('bad captcha'));
               const stateMachineFailSpy = sinon.spy(meeting.meetingFiniteStateMachine, 'fail');
+              const joinMeetingOptionsSpy = sinon.spy(MeetingUtil, 'joinMeetingOptions');
 
               try {
                 await meeting.join();
@@ -2416,7 +2171,8 @@ describe('plugin-meetings', () => {
                 );
                 assert.instanceOf(error, CaptchaError);
                 assert.equal(error.message, 'bad captcha');
-                assert.notCalled(MeetingUtil.joinMeeting);
+                // should not get to the end promise chain, which does do the join
+                assert.notCalled(joinMeetingOptionsSpy);
               }
             });
 
@@ -2425,6 +2181,7 @@ describe('plugin-meetings', () => {
                 .stub()
                 .rejects(new PasswordError('bad password'));
               const stateMachineFailSpy = sinon.spy(meeting.meetingFiniteStateMachine, 'fail');
+              const joinMeetingOptionsSpy = sinon.spy(MeetingUtil.joinMeetingOptions);
 
               try {
                 await meeting.join();
@@ -2438,7 +2195,8 @@ describe('plugin-meetings', () => {
                 );
                 assert.instanceOf(error, PasswordError);
                 assert.equal(error.message, 'bad password');
-                assert.notCalled(MeetingUtil.joinMeeting);
+                // should not get to the end promise chain, which does do the join
+                assert.notCalled(joinMeetingOptionsSpy);
               }
             });
 
@@ -2447,6 +2205,7 @@ describe('plugin-meetings', () => {
                 .stub()
                 .rejects(new PermissionError('bad permission'));
               const stateMachineFailSpy = sinon.spy(meeting.meetingFiniteStateMachine, 'fail');
+              const joinMeetingOptionsSpy = sinon.spy(MeetingUtil.joinMeetingOptions);
 
               try {
                 await meeting.join();
@@ -2460,14 +2219,14 @@ describe('plugin-meetings', () => {
                 );
                 assert.instanceOf(error, PermissionError);
                 assert.equal(error.message, 'bad permission');
-                assert.notCalled(MeetingUtil.joinMeeting);
+                // should not get to the end promise chain, which does do the join
+                assert.notCalled(joinMeetingOptionsSpy);
               }
             });
           });
         });
       });
 
-
       describe('#addMedia', () => {
         const muteStateStub = {
           handleClientRequest: sinon.stub().returns(Promise.resolve(true)),
@@ -3124,111 +2883,6 @@ 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);
@@ -6419,10 +6073,7 @@ describe('plugin-meetings', () => {
           meeting.statsAnalyzer = {stopAnalyzer: sinon.stub().resolves()};
           meeting.unsetPeerConnections = sinon.stub().returns(true);
           meeting.logger.error = sinon.stub().returns(true);
-          meeting.clearMeetingData = sinon.stub().callsFake(async () => {
-            meeting.audio = null;
-            meeting.video = null;
-          });
+          meeting.updateLLMConnection = sinon.stub().returns(Promise.resolve());
           webex.internal.voicea.off = sinon.stub().returns(true);
           meeting.stopTranscription = sinon.stub();
           meeting.transcription = {};
@@ -6449,7 +6100,9 @@ describe('plugin-meetings', () => {
           assert.calledOnce(meeting.closePeerConnections);
           assert.calledOnce(meeting.unsetRemoteStreams);
           assert.calledOnce(meeting.unsetPeerConnections);
-          assert.calledOnce(meeting.clearMeetingData);
+          assert.calledOnce(meeting.stopTranscription);
+          assert.calledOnce(meeting.annotation.deregisterEvents);
+          assert.calledWith(webex.internal.llm.off, 'event:relay.event', meeting.processRelayEvent);
         });
 
         it('should reset call diagnostic latencies correctly', async () => {
@@ -8450,10 +8103,7 @@ describe('plugin-meetings', () => {
           meeting.statsAnalyzer = {stopAnalyzer: sinon.stub().resolves()};
           meeting.unsetPeerConnections = sinon.stub().returns(true);
           meeting.logger.error = sinon.stub().returns(true);
-          meeting.clearMeetingData = sinon.stub().callsFake(async () => {
-            meeting.audio = null;
-            meeting.video = null;
-          });
+          meeting.updateLLMConnection = sinon.stub().returns(Promise.resolve());
           meeting.transcription = {};
           meeting.stopTranscription = sinon.stub();
 
@@ -8479,7 +8129,10 @@ describe('plugin-meetings', () => {
           assert.calledOnce(meeting?.closePeerConnections);
           assert.calledOnce(meeting?.unsetRemoteStreams);
           assert.calledOnce(meeting?.unsetPeerConnections);
-          assert.calledOnce(meeting?.clearMeetingData);
+          assert.calledOnce(meeting?.stopTranscription);
+
+          assert.called(meeting.annotation.deregisterEvents);
+          assert.calledWith(webex.internal.llm.off, 'event:relay.event', meeting.processRelayEvent);
         });
       });
 
@@ -9216,8 +8869,8 @@ describe('plugin-meetings', () => {
         const fakeMultistreamRoapMediaConnection = {
           createSendSlot: () => {
             return {
-              setCustomCodecParameters: sinon.stub().resolves(),
-              markCustomCodecParametersForDeletion: sinon.stub().resolves(),
+              setCodecParameters: sinon.stub().resolves(),
+              deleteCodecParameters: sinon.stub().resolves(),
             };
           },
         };
@@ -9240,29 +8893,27 @@ describe('plugin-meetings', () => {
         }
       );
 
-      it('should set custom codec parameters when shouldEnableMusicMode is true', async () => {
+      it('should set the codec parameters when shouldEnableMusicMode is true', async () => {
         await meeting.enableMusicMode(true);
         assert.calledOnceWithExactly(
-          meeting.sendSlotManager.getSlot(MediaType.AudioMain).setCustomCodecParameters,
-          MediaCodecMimeType.OPUS,
+          meeting.sendSlotManager.getSlot(MediaType.AudioMain).setCodecParameters,
           {
             maxaveragebitrate: '64000',
             maxplaybackrate: '48000',
           }
         );
         assert.notCalled(
-          meeting.sendSlotManager.getSlot(MediaType.AudioMain).markCustomCodecParametersForDeletion
+          meeting.sendSlotManager.getSlot(MediaType.AudioMain).deleteCodecParameters
         );
       });
 
-      it('should mark custom codec parameters for deletion when shouldEnableMusicMode is false', async () => {
+      it('should set the codec parameters when shouldEnableMusicMode is false', async () => {
         await meeting.enableMusicMode(false);
         assert.calledOnceWithExactly(
-          meeting.sendSlotManager.getSlot(MediaType.AudioMain).markCustomCodecParametersForDeletion,
-          MediaCodecMimeType.OPUS,
+          meeting.sendSlotManager.getSlot(MediaType.AudioMain).deleteCodecParameters,
           ['maxaveragebitrate', 'maxplaybackrate']
         );
-        assert.notCalled(meeting.sendSlotManager.getSlot(MediaType.AudioMain).setCustomCodecParameters);
+        assert.notCalled(meeting.sendSlotManager.getSlot(MediaType.AudioMain).setCodecParameters);
       });
     });
 
@@ -9353,10 +9004,7 @@ describe('plugin-meetings', () => {
 
             // check that the right things were called by the callback
             assert.calledOnceWithExactly(meeting.waitForRemoteSDPAnswer);
-            assert.calledOnceWithExactly(
-              meeting.mediaProperties.waitForMediaConnectionConnected,
-              meeting.correlationId
-            );
+            assert.calledOnceWithExactly(meeting.mediaProperties.waitForMediaConnectionConnected);
           });
         });
 
@@ -10417,24 +10065,14 @@ describe('plugin-meetings', () => {
           );
           done();
         });
-        it('listens to the self admitted guest event without blocking on token prefetch', async () => {
+        it('listens to the self admitted guest event', (done) => {
           meeting.stopKeepAlive = sinon.stub();
           meeting.updateLLMConnection = sinon.stub();
-          let resolvePrefetch;
-
-          meeting.ensureDefaultDatachannelTokenAfterAdmit = sinon
-            .stub()
-            .returns(new Promise((resolve) => {
-              resolvePrefetch = resolve;
-            }));
           meeting.rtcMetrics = {
             sendNextMetrics: sinon.stub(),
           };
-
           meeting.locusInfo.emit({function: 'test', file: 'test'}, 'SELF_ADMITTED_GUEST', test1);
-
           assert.calledOnceWithExactly(meeting.stopKeepAlive);
-          assert.calledOnceWithExactly(meeting.ensureDefaultDatachannelTokenAfterAdmit);
           assert.calledThrice(TriggerProxy.trigger);
           assert.calledWith(
             TriggerProxy.trigger,
@@ -10453,11 +10091,7 @@ describe('plugin-meetings', () => {
               correlation_id: meeting.correlationId,
             }
           );
-
-          resolvePrefetch(false);
-          await Promise.resolve();
-
-          assert.calledOnce(meeting.updateLLMConnection);
+          done();
         });
 
         it('listens to the breakouts changed event', () => {
@@ -10544,21 +10178,6 @@ 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', () => {
@@ -10806,24 +10425,6 @@ 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'};
 
@@ -11096,9 +10697,6 @@ describe('plugin-meetings', () => {
           meeting.simultaneousInterpretation = {
             approvalUrlUpdate: sinon.stub().returns(undefined),
           };
-          meeting.aiEnableRequest = {
-            approvalUrlUpdate: sinon.stub().returns(undefined),
-          };
 
           meeting.locusInfo.emit(
             {function: 'test', file: 'test'},
@@ -11118,10 +10716,6 @@ 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();
         });
@@ -11522,43 +11116,8 @@ describe('plugin-meetings', () => {
           meeting.unsetPeerConnections();
           assert.calledOnce(meeting.mediaProperties.unsetPeerConnection);
           assert.calledTwice(meeting.webex.internal.mercury.off);
-          assert.calledWith(meeting.webex.internal.mercury.off.firstCall, ONLINE);
-          assert.calledWith(meeting.webex.internal.mercury.off.secondCall, OFFLINE);
-        });
-      });
-
-      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());
+          assert.calledWith(meeting.webex.internal.mercury.off.firstCall, ONLINE);
+          assert.calledWith(meeting.webex.internal.mercury.off.secondCall, OFFLINE);
         });
       });
 
@@ -11941,7 +11500,6 @@ describe('plugin-meetings', () => {
         let canUnsetDisallowUnmuteSpy;
         let canUserRaiseHandSpy;
         let bothLeaveAndEndMeetingAvailableSpy;
-        let requireHostEndMeetingBeforeLeaveSpy;
         let canUserLowerAllHandsSpy;
         let canUserLowerSomeoneElsesHandSpy;
         let waitingForOthersToJoinSpy;
@@ -11953,8 +11511,6 @@ 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(() => {
@@ -11975,10 +11531,6 @@ 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');
@@ -11995,22 +11547,12 @@ 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(
@@ -12534,7 +12076,6 @@ describe('plugin-meetings', () => {
           const userDisplayHints = ['LOCK_CONTROL_UNLOCK'];
           meeting.userDisplayHints = ['LOCK_CONTROL_UNLOCK'];
           meeting.meetingInfo.supportVoIP = true;
-          meeting.roles = [];
 
           meeting.updateMeetingActions();
 
@@ -12550,7 +12091,6 @@ 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);
@@ -12562,12 +12102,6 @@ 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],
@@ -12710,159 +12244,33 @@ 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,
-          practiceSessionDatachannelUrl,
-          {expectedMainCalled, expectedPracticeCalled}
-        ) => {
-          meeting.handleDataChannelUrlChange(url, practiceSessionDatachannelUrl);
+        const check = (url, expectedCalled) => {
+          meeting.handleDataChannelUrlChange(url);
 
-          if (expectedMainCalled) {
+          if (expectedCalled) {
             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', undefined, {expectedMainCalled: true, expectedPracticeCalled: false});
+          check('some url', true);
         });
 
         it('does not call updateLLMConnection if datachannelURL is undefined', () => {
           meeting.config.enableAutomaticLLM = true;
-          check(undefined, undefined, {
-            expectedMainCalled: false,
-            expectedPracticeCalled: false,
-          });
+          check(undefined, false);
         });
 
         it('does not call updateLLMConnection if enableAutomaticLLM is 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,
-          });
-        });
-      });
-
-      describe('#saveDataChannelToken', () => {
-        beforeEach(() => {
-          webex.internal.llm.setDatachannelToken = sinon.stub();
-        });
-
-        it('saves datachannelToken into LLM as Default', () => {
-          meeting.saveDataChannelToken({
-            locus: {
-              self: {datachannelToken: 'default-token'},
-            },
-          });
-
-          assert.calledWithExactly(
-            webex.internal.llm.setDatachannelToken,
-            'default-token',
-            'llm-default-session'
-          );
-        });
-
-        it('saves practiceSessionDatachannelToken into LLM as PracticeSession', () => {
-          meeting.saveDataChannelToken({
-            locus: {
-              self: {practiceSessionDatachannelToken: 'ps-token'},
-            },
-          });
-
-          assert.calledWithExactly(
-            webex.internal.llm.setDatachannelToken,
-            'ps-token',
-            'llm-practice-session'
-          );
-        });
-
-        it('saves both tokens when both are present', () => {
-          meeting.saveDataChannelToken({
-            locus: {
-              self: {
-                datachannelToken: 'default-token',
-                practiceSessionDatachannelToken: 'ps-token',
-              },
-            },
-          });
-
-          assert.calledTwice(webex.internal.llm.setDatachannelToken);
-          assert.calledWithExactly(
-            webex.internal.llm.setDatachannelToken,
-            'default-token',
-            'llm-default-session'
-          );
-          assert.calledWithExactly(
-            webex.internal.llm.setDatachannelToken,
-            'ps-token',
-            'llm-practice-session'
-          );
-        });
-
-        it('does not call setDatachannelToken when no tokens are present', () => {
-          meeting.saveDataChannelToken({locus: {self: {}}});
-
-          assert.notCalled(webex.internal.llm.setDatachannelToken);
-        });
-
-        it('handles undefined join gracefully', () => {
-          meeting.saveDataChannelToken(undefined);
-
-          assert.notCalled(webex.internal.llm.setDatachannelToken);
-        });
-
-        it('handles missing locus.self gracefully', () => {
-          meeting.saveDataChannelToken({locus: {}});
-
-          assert.notCalled(webex.internal.llm.setDatachannelToken);
-        });
-      });
-
-      describe('#clearDataChannelToken', () => {
-        beforeEach(() => {
-          webex.internal.llm.resetDatachannelTokens = sinon.stub();
-        });
-
-        it('calls resetDatachannelTokens on LLM', () => {
-          meeting.clearDataChannelToken();
-
-          assert.calledOnce(webex.internal.llm.resetDatachannelTokens);
+          check('some url', false);
         });
       });
 
@@ -12871,20 +12279,16 @@ 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().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();
-
+          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();
           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');
@@ -12898,21 +12302,31 @@ 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'};
-          meeting.locusInfo = {
-            url: 'a url',
-            info: {datachannelUrl: 'a datachannel url'},
-          };
+          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.calledWithExactly(
-            webex.internal.llm.registerAndConnect,
-            'a url',
-            'a datachannel url',
-            undefined
-          );
+          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'}};
+
+          const result = await meeting.updateLLMConnection();
+
+          assert.notCalled(webex.internal.llm.disconnectLLM);
+          assert.calledWith(webex.internal.llm.registerAndConnect, 'a url', 'a datachannel url');
           assert.equal(result, 'something');
           assert.calledWithExactly(
             meeting.webex.internal.llm.off,
@@ -12935,49 +12349,27 @@ 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();
 
-          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 () => {
+        it('disconnects if first 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'},
-            self: {},
-          };
+          meeting.locusInfo = {url: 'a different url', info: {datachannelUrl: 'a datachannel url'}};
 
           const result = await meeting.updateLLMConnection();
 
-          assert.calledWithExactly(webex.internal.llm.disconnectLLM, {
+          assert.calledWith(webex.internal.llm.disconnectLLM, {
             code: 3050,
             reason: 'done (permanent)',
           });
-
-          assert.calledWithExactly(
+          assert.calledWith(
             webex.internal.llm.registerAndConnect,
             'a different url',
-            'a datachannel url',
-            undefined
+            'a datachannel url'
           );
-
           assert.equal(result, 'something');
-
           assert.calledWithExactly(
             meeting.webex.internal.llm.off,
             'event:relay.event',
@@ -12989,7 +12381,6 @@ describe('plugin-meetings', () => {
             meeting.processLocusLLMEvent
           );
           assert.callCount(meeting.webex.internal.llm.off, 4);
-
           assert.calledWithExactly(
             meeting.webex.internal.llm.on,
             'event:relay.event',
@@ -13000,37 +12391,28 @@ describe('plugin-meetings', () => {
             'event:locus.state_message',
             meeting.processLocusLLMEvent
           );
-          assert.isFalse(
-            meeting.webex.internal.llm.off.calledWithExactly('online', meeting.handleLLMOnline)
-          );
         });
-        it('disconnects if the data channel url has changed', async () => {
+
+        it('disconnects it first 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'},
-            self: {},
-          };
+          meeting.locusInfo = {url: 'a url', info: {datachannelUrl: 'a different datachannel url'}};
 
           const result = await meeting.updateLLMConnection();
 
-          assert.calledWithExactly(webex.internal.llm.disconnectLLM, {
+          assert.calledWith(webex.internal.llm.disconnectLLM, {
             code: 3050,
             reason: 'done (permanent)',
           });
-
-          assert.calledWithExactly(
+          assert.calledWith(
             webex.internal.llm.registerAndConnect,
             'a url',
-            'a different datachannel url',
-            undefined
+            'a different datachannel url'
           );
-
           assert.equal(result, 'something');
-
           assert.calledWithExactly(
             meeting.webex.internal.llm.off,
             'event:relay.event',
@@ -13041,7 +12423,6 @@ describe('plugin-meetings', () => {
             'event:locus.state_message',
             meeting.processLocusLLMEvent
           );
-
           assert.calledWithExactly(
             meeting.webex.internal.llm.on,
             'event:relay.event',
@@ -13052,10 +12433,8 @@ 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);
@@ -13065,38 +12444,9 @@ describe('plugin-meetings', () => {
 
           const result = await meeting.updateLLMConnection();
 
-          assert.calledWith(webex.internal.llm.disconnectLLM, {
-            code: 3050,
-            reason: 'done (permanent)',
-          });
+          assert.calledWith(webex.internal.llm.disconnectLLM, undefined);
           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',
@@ -13107,159 +12457,22 @@ 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('still need connect main session data channel when PS started', async () => {
+
+        it('connect ps data channel if ps started in webinar', async () => {
           meeting.joinedWith = {state: 'JOINED'};
           meeting.locusInfo = {
             url: 'a url',
             info: {
               datachannelUrl: 'a datachannel url',
-              practiceSessionDatachannelUrl: 'ps-url',
+              practiceSessionDatachannelUrl: 'a ps datachannel url',
             },
           };
-          meeting.webinar.isJoinPracticeSessionDataChannel.returns(true);
-
-          await meeting.updateLLMConnection();
-
-          assert.calledWithExactly(
-            webex.internal.llm.registerAndConnect,
-            'a url',
-            'a datachannel url',
-            undefined
-          );
-        });
-        it('passes dataChannelToken from LLM to registerAndConnect', async () => {
-          meeting.joinedWith = {state: 'JOINED'};
-          meeting.locusInfo = {
-            url: 'a url',
-            info: {datachannelUrl: 'a datachannel url'},
-          };
-
-          webex.internal.llm.getDatachannelToken.withArgs('llm-default-session').returns('token-123');
-
-          await meeting.updateLLMConnection();
-
-          assert.calledWithExactly(
-            webex.internal.llm.registerAndConnect,
-            'a url',
-            'a datachannel url',
-            'token-123'
-          );
-          assert.notCalled(webex.internal.llm.setDatachannelToken);
-        });
-        it('passes undefined token when LLM has no token stored', async () => {
-          meeting.joinedWith = {state: 'JOINED'};
-          meeting.locusInfo = {
-            url: 'a url',
-            info: {datachannelUrl: 'a datachannel url'},
-          };
-
-          webex.internal.llm.getDatachannelToken.returns(undefined);
-
-          await meeting.updateLLMConnection();
-
-          assert.calledWithExactly(
-            webex.internal.llm.registerAndConnect,
-            'a url',
-            'a datachannel url',
-            undefined
-          );
-
-          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'},
-          };
-
-          webex.internal.llm.getDatachannelToken.returns(undefined);
-          webex.internal.llm.isDataChannelTokenEnabled = sinon.stub().resolves(false);
-
+          meeting.webinar.isJoinPracticeSessionDataChannel = sinon.stub().returns(true);
           await meeting.updateLLMConnection();
 
-          assert.calledWithExactly(
-            webex.internal.llm.registerAndConnect,
-            'a url',
-            'a datachannel url',
-            undefined
-          );
-          assert.notCalled(webex.internal.llm.setDatachannelToken);
-        });
-
-        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.clearDataChannelToken = sinon.stub();
-            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.isUndefined(meeting.transcription);
-            assert.calledOnce(meeting.clearDataChannelToken);
-            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.isUndefined(meeting.transcription);
-            assert.calledOnce(meeting.clearDataChannelToken);
-            assert.calledOnce(meeting.annotation.deregisterEvents);
-          });
-          it('always calls stopTranscription even when transcription is undefined', async () => {
-            meeting.transcription = undefined;
-
-            await meeting.clearMeetingData();
-
-            assert.calledOnce(meeting.stopTranscription);
-            assert.isUndefined(meeting.transcription);
-            assert.calledOnce(meeting.clearDataChannelToken);
-          });
+          assert.notCalled(webex.internal.llm.disconnectLLM);
+          assert.calledWith(webex.internal.llm.registerAndConnect, 'a url', 'a ps datachannel url');
         });
       });
 
@@ -13270,7 +12483,6 @@ 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],
@@ -13280,14 +12492,12 @@ 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);
@@ -14829,69 +14039,6 @@ 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';