@webex/internal-plugin-voicea 3.12.0-auth-prejoin-fetch.1 → 3.12.0-llmrefactor.10

package/test/unit/spec/voicea.js

@@ -4,75 +4,90 @@ import MockWebSocket from '@webex/test-helper-mock-web-socket';
 import {assert, expect} from '@webex/test-helper-chai';
 import sinon from 'sinon';
 import Mercury from '@webex/internal-plugin-mercury';
-import LLMChannel from '@webex/internal-plugin-llm';
 
-import VoiceaService from '../../../src/index';
-import {
-  EVENT_TRIGGERS,
-  LLM_PRACTICE_SESSION,
-  TOGGLE_MANUAL_CAPTION_STATUS,
-} from '../../../src/constants';
+import {VoiceaChannel} from '../../../src/voicea';
+import {EVENT_TRIGGERS, TOGGLE_MANUAL_CAPTION_STATUS} from '../../../src/constants';
+
+const flushPromises = () => new Promise(setImmediate);
+
+/**
+ * Creates a mock LLM channel for testing
+ * @param {Object} [options] - Options for the mock channel
+ * @param {boolean} [options.isConnected=true] - Whether the channel is connected
+ * @param {string} [options.locusUrl] - The locus URL
+ * @returns {Object} Mock channel
+ */
+function createMockLLMChannel(options = {}) {
+  const mockWebSocket = new MockWebSocket();
+  const {isConnected = true, locusUrl = 'locusUrl'} = options;
+
+  return {
+    isConnected: sinon.stub().returns(isConnected),
+    getSocket: sinon.stub().returns(mockWebSocket),
+    getBinding: sinon.stub().returns('binding'),
+    getDatachannelUrl: sinon.stub().returns('datachannelUrl'),
+    getLocusUrl: sinon.stub().returns(locusUrl),
+    isDataChannelTokenEnabled: sinon.stub().resolves(true),
+    on: sinon.stub(),
+    off: sinon.stub(),
+    once: sinon.stub(),
+    socket: mockWebSocket,
+  };
+}
 
 describe('plugin-voicea', () => {
   const locusUrl = 'locusUrl';
 
-  describe('voicea', () => {
-    let webex, voiceaService;
+  describe('VoiceaChannel', () => {
+    let webex, voiceaChannel, mockLLMChannel, requestStub;
 
     beforeEach(() => {
       webex = new MockWebex({
         children: {
           mercury: Mercury,
-          llm: LLMChannel,
-          voicea: VoiceaService,
         },
       });
 
-      voiceaService = webex.internal.voicea;
-      voiceaService.connect = sinon.stub().resolves(true);
-      voiceaService.webex.internal.llm.isConnected = sinon.stub().returns(true);
-      voiceaService.webex.internal.llm.getBinding = sinon.stub().returns(undefined);
-      voiceaService.webex.internal.llm.getSocket = sinon.stub().returns(undefined);
-      voiceaService.webex.internal.llm.getLocusUrl = sinon.stub().returns(locusUrl);
-
-      voiceaService.request = sinon.stub().resolves({
+      requestStub = sinon.stub().resolves({
         headers: {},
         body: '',
       });
-      voiceaService.register = sinon.stub().resolves({
-        body: {
-          binding: 'binding',
-          webSocketUrl: 'url',
-        },
-      });
+
+      mockLLMChannel = createMockLLMChannel({locusUrl});
+      voiceaChannel = new VoiceaChannel(mockLLMChannel, requestStub);
     });
 
-    describe("#constructor", () => {
+    afterEach(() => {
+      voiceaChannel.deregisterEvents();
+      sinon.restore();
+    });
+
+    describe('#constructor', () => {
       it('should init status', () => {
-        assert.equal(voiceaService.announceStatus, 'idle');
-        assert.equal(voiceaService.captionStatus, 'idle');
+        assert.equal(voiceaChannel.getAnnounceStatus(), 'idle');
+        assert.equal(voiceaChannel.getCaptionStatus(), 'idle');
       });
-    });
 
-    describe('#sendAnnouncement', () => {
-      beforeEach(async () => {
-        const mockWebSocket = new MockWebSocket();
+      it('should subscribe to relay events when llmChannel is provided', () => {
+        assert.calledWith(mockLLMChannel.on, 'event:relay.event', sinon.match.func);
+      });
 
-        voiceaService.webex.internal.llm.socket = mockWebSocket;
-        voiceaService.announceStatus = "idle";
+      it('should not subscribe to events when llmChannel is undefined', () => {
+        const channelWithoutLLM = new VoiceaChannel(undefined, requestStub);
+        // No llmChannel means no subscription, just verify it doesn't throw
+        assert.equal(channelWithoutLLM.getAnnounceStatus(), 'idle');
       });
+    });
 
+    describe('#sendAnnouncement', () => {
       it("sends announcement if voicea hasn't joined", () => {
-        const spy = sinon.spy(voiceaService, 'listenToEvents');
+        voiceaChannel.sendAnnouncement();
+        assert.equal(voiceaChannel.getAnnounceStatus(), 'joining');
 
-        voiceaService.sendAnnouncement();
-        assert.equal(voiceaService.announceStatus, 'joining');
-        assert.calledOnce(spy);
-
-        assert.calledOnceWithExactly(voiceaService.webex.internal.llm.socket.send, {
+        assert.calledOnceWithExactly(mockLLMChannel.socket.send, {
           id: '1',
           type: 'publishRequest',
-          recipients: [{route: undefined}],
+          recipients: [{route: 'binding'}],
           headers: {},
           data: {
             clientPayload: {
@@ -85,31 +100,15 @@ describe('plugin-voicea', () => {
         });
       });
 
-      it('listens to events once', () => {
-        const spy = sinon.spy(webex.internal.llm, 'on');
-
-        voiceaService.sendAnnouncement();
-
-        voiceaService.sendAnnouncement();
-
-        assert.calledTwice(spy);
-        assert.calledWith(spy, 'event:relay.event', sinon.match.func);
-        assert.calledWith(spy, `event:relay.event:${LLM_PRACTICE_SESSION}`, sinon.match.func);
-      });
-
       it('includes captionServiceId in headers when set', () => {
-        const mockWebSocket = new MockWebSocket();
-
-        voiceaService.webex.internal.llm.socket = mockWebSocket;
-        voiceaService.announceStatus = 'idle';
-        voiceaService.captionServiceId = 'svc-123';
+        voiceaChannel.captionServiceId = 'svc-123';
 
-        voiceaService.sendAnnouncement();
+        voiceaChannel.sendAnnouncement();
 
-        assert.calledOnceWithExactly(voiceaService.webex.internal.llm.socket.send, {
+        assert.calledOnceWithExactly(mockLLMChannel.socket.send, {
           id: '1',
           type: 'publishRequest',
-          recipients: [{route: undefined}],
+          recipients: [{route: 'binding'}],
           headers: {to: 'svc-123'},
           data: {
             clientPayload: {
@@ -124,49 +123,38 @@ describe('plugin-voicea', () => {
     });
 
     describe('#sendManualClosedCaption', () => {
-      beforeEach(async () => {
-        const mockWebSocket = new MockWebSocket();
-        voiceaService.webex.internal.llm.socket = mockWebSocket;
-        voiceaService.seqNum = 1;
-      });
-
       it('sends interim manual closed caption when connected', () => {
         const text = 'Test interim caption';
         const timeStamp = 1234567890;
         const csis = [123456];
         const isFinal = false;
 
-        voiceaService.sendManualClosedCaption(text, timeStamp, csis, isFinal);
-
-        assert.calledOnceWithExactly(
-          voiceaService.webex.internal.llm.socket.send,
-          {
-            id: '1',
-            type: 'publishRequest',
-            recipients: [{route: undefined}],
-            headers: {},
-            data: {
-              eventType: 'relay.event',
-              relayType: 'client.manual_transcription',
-              transcriptPayload: {
-                type: 'manual_caption_interim_result',
-                id: sinon.match.string,
-                transcripts: [
-                  {
-                    text: 'Test interim caption',
-                    start_millis: 1234567890,
-                    end_millis: 1234567890,
-                    csis: [123456],
-                  },
-                ],
-                transcript_id: sinon.match.string,
-              },
+        voiceaChannel.sendManualClosedCaption(text, timeStamp, csis, isFinal);
+
+        assert.calledOnceWithExactly(mockLLMChannel.socket.send, {
+          id: '1',
+          type: 'publishRequest',
+          recipients: [{route: 'binding'}],
+          headers: {},
+          data: {
+            eventType: 'relay.event',
+            relayType: 'client.manual_transcription',
+            transcriptPayload: {
+              type: 'manual_caption_interim_result',
+              id: sinon.match.string,
+              transcripts: [
+                {
+                  text: 'Test interim caption',
+                  start_millis: 1234567890,
+                  end_millis: 1234567890,
+                  csis: [123456],
+                },
+              ],
+              transcript_id: sinon.match.string,
             },
-            trackingId: sinon.match.string,
-          }
-        );
-        // seqNum should increment
-        assert.equal(voiceaService.seqNum, 2);
+          },
+          trackingId: sinon.match.string,
+        });
       });
 
       it('sends final manual closed caption when connected', () => {
@@ -175,137 +163,87 @@ describe('plugin-voicea', () => {
         const csis = [654321];
         const isFinal = true;
 
-        voiceaService.sendManualClosedCaption(text, timeStamp, csis, isFinal);
-
-        assert.calledOnceWithExactly(
-          voiceaService.webex.internal.llm.socket.send,
-          {
-            id: '1',
-            type: 'publishRequest',
-            recipients: [{route: undefined}],
-            headers: {},
-            data: {
-              eventType: 'relay.event',
-              relayType: 'client.manual_transcription',
-              transcriptPayload: {
-                type: 'manual_caption_final_result',
-                id: sinon.match.string,
-                transcripts: [
-                  {
-                    text: 'Test final caption',
-                    start_millis: 9876543210,
-                    end_millis: 9876543210,
-                    csis: [654321],
-                  },
-                ],
-                transcript_id: sinon.match.string,
-              },
+        voiceaChannel.sendManualClosedCaption(text, timeStamp, csis, isFinal);
+
+        assert.calledOnceWithExactly(mockLLMChannel.socket.send, {
+          id: '1',
+          type: 'publishRequest',
+          recipients: [{route: 'binding'}],
+          headers: {},
+          data: {
+            eventType: 'relay.event',
+            relayType: 'client.manual_transcription',
+            transcriptPayload: {
+              type: 'manual_caption_final_result',
+              id: sinon.match.string,
+              transcripts: [
+                {
+                  text: 'Test final caption',
+                  start_millis: 9876543210,
+                  end_millis: 9876543210,
+                  csis: [654321],
+                },
+              ],
+              transcript_id: sinon.match.string,
             },
-            trackingId: sinon.match.string,
-          }
-        );
-        // seqNum should increment
-        assert.equal(voiceaService.seqNum, 2);
+          },
+          trackingId: sinon.match.string,
+        });
       });
 
       it('does not send if not connected', () => {
-        voiceaService.webex.internal.llm.isConnected.returns(false);
-
-        const text = 'Should not send';
-        const timeStamp = 111;
-        const csis = [1];
-        const isFinal = true;
+        const disconnectedChannel = createMockLLMChannel({isConnected: false});
+        const channel = new VoiceaChannel(disconnectedChannel, requestStub);
 
-        voiceaService.sendManualClosedCaption(text, timeStamp, csis, isFinal);
+        channel.sendManualClosedCaption('Should not send', 111, [1], true);
 
-        assert.notCalled(voiceaService.webex.internal.llm.socket.send);
+        assert.notCalled(disconnectedChannel.socket.send);
       });
     });
+
     describe('#deregisterEvents', () => {
       beforeEach(async () => {
-        const mockWebSocket = new MockWebSocket();
-        voiceaService.webex.internal.llm.socket = mockWebSocket;
-        voiceaService.keepTranscriptionSubscribed = true;
+        voiceaChannel.keepTranscriptionSubscribed = true;
       });
 
-      it('deregisters voicea service and resets caption state', async () => {
-        voiceaService.listenToEvents();
-        await voiceaService.toggleTranscribing(true);
-
-        voiceaService.webex.internal.llm._emit('event:relay.event', {
-          headers: {from: 'ws'},
-          data: {relayType: 'voicea.annc', voiceaPayload: {}},
-        });
+      it('works when llmChannel is undefined', () => {
+        const channelWithoutLLM = new VoiceaChannel(undefined, requestStub);
+        channelWithoutLLM.areCaptionsEnabled = true;
+        channelWithoutLLM.keepTranscriptionSubscribed = true;
+        channelWithoutLLM.hasSubscribedToEvents = true;
 
-        assert.equal(voiceaService.areCaptionsEnabled, true);
-        assert.equal(voiceaService.captionServiceId, 'ws');
-        assert.equal(voiceaService.keepTranscriptionSubscribed, true);
+        // Should not throw
+        channelWithoutLLM.deregisterEvents();
 
-        voiceaService.deregisterEvents();
-        assert.equal(voiceaService.areCaptionsEnabled, false);
-        assert.equal(voiceaService.captionServiceId, undefined);
-        assert.equal(voiceaService.announceStatus, 'idle');
-        assert.equal(voiceaService.captionStatus, 'idle');
-        assert.equal(voiceaService.keepTranscriptionSubscribed, false);
+        assert.equal(channelWithoutLLM.areCaptionsEnabled, false);
+        assert.equal(channelWithoutLLM.keepTranscriptionSubscribed, false);
+        assert.equal(channelWithoutLLM.hasSubscribedToEvents, false);
       });
-    });
-    describe('#processAnnouncementMessage', () => {
-      it('works on non-empty payload', async () => {
-        const voiceaPayload = {
-          translation: {
-            allowed_languages: ['af', 'am'],
-            max_languages: 5,
-          },
-          ASR: {
-            spoken_languages: ['en'],
-          },
-
-          version: 'v2',
-        };
-
-        const spy = sinon.spy();
 
-        voiceaService.on(EVENT_TRIGGERS.VOICEA_ANNOUNCEMENT, spy);
-        voiceaService.listenToEvents();
-        voiceaService.processAnnouncementMessage(voiceaPayload);
-        assert.calledOnceWithExactly(spy, {
-          captionLanguages: ['af', 'am'],
-          spokenLanguages: ['en'],
-          maxLanguages: 5,
-          currentSpokenLanguage: 'en',
-        });
-      });
+      it('deregisters voicea channel and resets state', () => {
+        voiceaChannel.areCaptionsEnabled = true;
+        voiceaChannel.captionServiceId = 'ws';
+        voiceaChannel.keepTranscriptionSubscribed = true;
 
-      it('works on empty payload', async () => {
-        const spy = sinon.spy();
+        voiceaChannel.deregisterEvents();
 
-        voiceaService.on(EVENT_TRIGGERS.VOICEA_ANNOUNCEMENT, spy);
-        voiceaService.listenToEvents();
-        voiceaService.currentSpokenLanguage = 'fr';
-        await voiceaService.processAnnouncementMessage({});
-        assert.calledOnceWithExactly(spy, {
-          captionLanguages: [],
-          spokenLanguages: [],
-          maxLanguages: 0,
-          currentSpokenLanguage: 'fr',
-        });
+        assert.equal(voiceaChannel.areCaptionsEnabled, false);
+        assert.equal(voiceaChannel.captionServiceId, undefined);
+        assert.equal(voiceaChannel.getAnnounceStatus(), 'idle');
+        assert.equal(voiceaChannel.getCaptionStatus(), 'idle');
+        assert.equal(voiceaChannel.keepTranscriptionSubscribed, false);
+        assert.calledWith(mockLLMChannel.off, 'event:relay.event', sinon.match.func);
       });
     });
 
     describe('#requestLanguage', () => {
-      beforeEach(async () => {
-        const mockWebSocket = new MockWebSocket();
-
-        voiceaService.webex.internal.llm.socket = mockWebSocket;
-      });
-
       it('requests caption language', () => {
-        voiceaService.requestLanguage('en');
+        voiceaChannel.requestLanguage('en');
 
-        assert.calledOnceWithExactly(voiceaService.webex.internal.llm.socket.send, {
+        assert.calledOnceWithExactly(mockLLMChannel.socket.send, {
           id: '1',
           type: 'publishRequest',
-          recipients: [{route: undefined}],
+          recipients: [{route: 'binding'}],
           headers: {to: undefined},
           data: {
             clientPayload: {
@@ -320,14 +258,14 @@ describe('plugin-voicea', () => {
       });
 
       it('uses captionServiceId as "to" header when set', () => {
-        voiceaService.captionServiceId = 'svc-456';
+        voiceaChannel.captionServiceId = 'svc-456';
 
-        voiceaService.requestLanguage('fr');
+        voiceaChannel.requestLanguage('fr');
 
-        assert.calledOnceWithExactly(voiceaService.webex.internal.llm.socket.send, {
+        assert.calledOnceWithExactly(mockLLMChannel.socket.send, {
           id: '1',
           type: 'publishRequest',
-          recipients: [{route: undefined}],
+          recipients: [{route: 'binding'}],
           headers: {to: 'svc-456'},
           data: {
             clientPayload: {
@@ -340,6 +278,15 @@ describe('plugin-voicea', () => {
           trackingId: sinon.match.string,
         });
       });
+
+      it('does not send when not connected', () => {
+        const disconnectedChannel = createMockLLMChannel({isConnected: false});
+        const channel = new VoiceaChannel(disconnectedChannel, requestStub);
+
+        channel.requestLanguage('en');
+
+        assert.notCalled(disconnectedChannel.socket.send);
+      });
     });
 
     describe('#setSpokenLanguage', () => {
@@ -347,38 +294,33 @@ describe('plugin-voicea', () => {
         const languageCode = 'en';
         const triggerSpy = sinon.spy();
 
-        voiceaService.on(EVENT_TRIGGERS.SPOKEN_LANGUAGE_UPDATE, triggerSpy);
-        voiceaService.listenToEvents();
-        await voiceaService.setSpokenLanguage(languageCode);
+        voiceaChannel.on(EVENT_TRIGGERS.SPOKEN_LANGUAGE_UPDATE, triggerSpy);
+        await voiceaChannel.setSpokenLanguage(languageCode);
 
         assert.calledOnceWithExactly(triggerSpy, {languageCode});
 
         sinon.assert.calledWith(
-          voiceaService.request,
+          requestStub,
           sinon.match({
             method: 'PUT',
             url: `${locusUrl}/controls/`,
             body: {
               transcribe: {
                 spokenLanguage: languageCode,
-              }
+              },
             },
           })
         );
       });
+
       it('sets spoken language with language assignment', async () => {
         const languageCode = 'zh';
         const languageAssignment = 'DEFAULT';
-        const triggerSpy = sinon.spy();
-
-        voiceaService.on(EVENT_TRIGGERS.SPOKEN_LANGUAGE_UPDATE, triggerSpy);
-        voiceaService.listenToEvents();
-        await voiceaService.setSpokenLanguage(languageCode, languageAssignment);
 
-        assert.calledOnceWithExactly(triggerSpy, {languageCode});
+        await voiceaChannel.setSpokenLanguage(languageCode, languageAssignment);
 
         sinon.assert.calledWith(
-          voiceaService.request,
+          requestStub,
           sinon.match({
             method: 'PUT',
             url: `${locusUrl}/controls/`,
@@ -386,1197 +328,966 @@ describe('plugin-voicea', () => {
               transcribe: {
                 spokenLanguage: languageCode,
                 languageAssignment,
-              }
+              },
             },
           })
         );
       });
-
     });
 
-    describe('#requestTurnOnCaptions', () => {
-      beforeEach(async () => {
-        const mockWebSocket = new MockWebSocket();
-
-        voiceaService.webex.internal.llm.socket = mockWebSocket;
-        voiceaService.captionStatus = 'idle';
+    describe('#isLLMConnected', () => {
+      it('returns true when the LLM channel is connected', () => {
+        assert.equal(voiceaChannel.isLLMConnected(), true);
       });
 
-      afterEach( () => {
-        voiceaService.captionStatus = 'idle';
-      })
-
-      it('turns on captions', async () => {
-        const announcementSpy = sinon.spy(voiceaService, 'announce');
-        const updateSubchannelSubscriptionsAndSyncCaptionStateSpy = sinon.spy(voiceaService, 'updateSubchannelSubscriptionsAndSyncCaptionState');
-
-        const triggerSpy = sinon.spy();
-
-        voiceaService.on(EVENT_TRIGGERS.CAPTIONS_TURNED_ON, triggerSpy);
-        voiceaService.listenToEvents();
-
-        await voiceaService.requestTurnOnCaptions();
-        assert.equal(voiceaService.captionStatus, 'enabled');
-        sinon.assert.calledWith(
-          voiceaService.request,
-          sinon.match({
-            method: 'PUT',
-            url: `${locusUrl}/controls/`,
-            body: {transcribe: {caption: true}},
-          })
-        );
-
-        assert.calledOnceWithExactly(triggerSpy);
-
-        assert.calledOnce(announcementSpy);
-        assert.calledOnceWithExactly(
-          updateSubchannelSubscriptionsAndSyncCaptionStateSpy,
-          { subscribe: ['transcription'] },
-          true
-        );
+      it('returns false when the LLM channel is not connected', () => {
+        mockLLMChannel.isConnected.returns(false);
+        assert.equal(voiceaChannel.isLLMConnected(), false);
       });
 
-      it("should handle request fail", async () => {
-        voiceaService.captionStatus = 'sending';
-        voiceaService.request = sinon.stub().rejects();
-
-        try {
-          await voiceaService.requestTurnOnCaptions();
-        } catch (error) {
-          expect(error.message).to.include('turn on captions fail');
-          return;
-        }
-        assert.equal(voiceaService.captionStatus, 'idle');
+      it('returns false when the LLM channel is undefined', () => {
+        const channelWithoutLLM = new VoiceaChannel(undefined, requestStub);
+        assert.equal(channelWithoutLLM.isLLMConnected(), false);
       });
     });
 
-    describe("#isAnnounceProcessing", () => {
-      afterEach(() => {
-        voiceaService.announceStatus = 'idle';
-      });
-
-      ['joining', 'joined'].forEach((status) => {
-        it(`should return true when status is ${status}`, () => {
-          voiceaService.announceStatus = status;
-          assert.equal(voiceaService.isAnnounceProcessing(), true);
-        });
+    describe('#getKeepTranscriptionSubscribed', () => {
+      it('returns false when keepTranscriptionSubscribed is false', () => {
+        voiceaChannel.keepTranscriptionSubscribed = false;
+        assert.equal(voiceaChannel.getKeepTranscriptionSubscribed(), false);
       });
 
-      it('should return false when status is not processing status', () => {
-        voiceaService.announceStatus = 'idle';
-          assert.equal(voiceaService.isAnnounceProcessing(), false);
+      it('returns true when keepTranscriptionSubscribed is true', () => {
+        voiceaChannel.keepTranscriptionSubscribed = true;
+        assert.equal(voiceaChannel.getKeepTranscriptionSubscribed(), true);
       });
     });
 
-    describe('#isLLMConnected', () => {
-      it('returns true when the default llm connection is connected', () => {
-        voiceaService.webex.internal.llm.isConnected.callsFake((channel) =>
-          channel === LLM_PRACTICE_SESSION ? false : true
-        );
-
-        assert.equal(voiceaService.isLLMConnected(), true);
+    describe('#announce', () => {
+      it('announce to llm data channel', () => {
+        const sendAnnouncementSpy = sinon.spy(voiceaChannel, 'sendAnnouncement');
+        voiceaChannel.announce();
+        assert.calledOnce(sendAnnouncementSpy);
       });
 
-      it('returns true when only the practice session llm connection is connected', () => {
-        voiceaService.webex.internal.llm.isConnected.callsFake((channel) =>
-          channel === LLM_PRACTICE_SESSION
+      it('throws when llm is not connected', () => {
+        mockLLMChannel.isConnected.returns(false);
+        assert.throws(
+          () => voiceaChannel.announce(),
+          'voicea can not announce before llm connected'
         );
-
-        assert.equal(voiceaService.isLLMConnected(), true);
       });
 
-      it('returns false when neither llm connection is connected', () => {
-        voiceaService.webex.internal.llm.isConnected.returns(false);
-
-        assert.equal(voiceaService.isLLMConnected(), false);
+      it('should not announce duplicate when already processed', () => {
+        voiceaChannel.announceStatus = 'joined';
+        const sendAnnouncementSpy = sinon.spy(voiceaChannel, 'sendAnnouncement');
+        voiceaChannel.announce();
+        assert.notCalled(sendAnnouncementSpy);
       });
     });
 
-    describe('#getKeepTranscriptionSubscribed', () => {
-      beforeEach(() => {
-        voiceaService.keepTranscriptionSubscribed = false;
-      });
-
-      it('returns false when captions are disabled', () => {
-        voiceaService.keepTranscriptionSubscribed = false;
-
-        const result = voiceaService.getKeepTranscriptionSubscribed();
-
-        assert.equal(result, false);
-      });
-
-      it('returns true when captions are enabled', () => {
-        voiceaService.keepTranscriptionSubscribed = true;
-
-        const result = voiceaService.getKeepTranscriptionSubscribed();
-
-        assert.equal(result, true);
-      });
-    });
+    describe('#turnOnCaptions', () => {
+      it('turns on captions', async () => {
+        const announceSpy = sinon.spy(voiceaChannel, 'announce');
+        const triggerSpy = sinon.spy();
 
-    describe("#announce", () => {
-      let isAnnounceProcessed, sendAnnouncement;
-      beforeEach(() => {
-        sendAnnouncement = sinon.stub(voiceaService, 'sendAnnouncement');
-        isAnnounceProcessed = sinon.stub(voiceaService, 'isAnnounceProcessed').returns(false)
-      });
+        voiceaChannel.on(EVENT_TRIGGERS.CAPTIONS_TURNED_ON, triggerSpy);
 
-      afterEach(() => {
-        isAnnounceProcessed.restore();
-        sendAnnouncement.restore();
-      });
+        await voiceaChannel.turnOnCaptions();
 
-      it('announce to llm data channel', ()=> {
-        voiceaService.announce();
-        assert.calledOnce(sendAnnouncement);
+        assert.equal(voiceaChannel.getCaptionStatus(), 'enabled');
+        assert.calledOnce(announceSpy);
+        assert.calledOnce(triggerSpy);
       });
 
-      it('announce to llm data channel before llm connected', ()=> {
-        voiceaService.webex.internal.llm.isConnected.returns(false);
-        assert.throws(() =>  voiceaService.announce(), "voicea can not announce before llm connected");
-        assert.notCalled(sendAnnouncement);
-      });
+      it('throws when llm is not connected', async () => {
+        mockLLMChannel.isConnected.returns(false);
 
-      it('announce to llm data channel when only practice session is connected', ()=> {
-        voiceaService.webex.internal.llm.isConnected.callsFake((channel) =>
-          channel === LLM_PRACTICE_SESSION
+        await assert.isRejected(
+          voiceaChannel.turnOnCaptions(),
+          'can not turn on captions before llm connected'
         );
-
-        voiceaService.announce();
-
-        assert.calledOnce(sendAnnouncement);
-      });
-
-      it('should not announce duplicate', () => {
-        isAnnounceProcessed.returns(true);
-        voiceaService.announce();
-        assert.notCalled(sendAnnouncement);
-      })
-    });
-
-    describe("#isCaptionProcessing", () => {
-      afterEach(() => {
-        voiceaService.captionStatus = 'idle';
-      });
-
-      ['sending', 'enabled'].forEach((status) => {
-        it(`should return true when status is ${status}`, () => {
-          voiceaService.captionStatus = status;
-          assert.equal(voiceaService.isCaptionProcessing(), true);
-        });
       });
 
-      it('should return false when status is not processing status', () => {
-        voiceaService.captionStatus = 'idle';
-          assert.equal(voiceaService.isCaptionProcessing(), false);
+      it('returns undefined when already sending', async () => {
+        voiceaChannel.captionStatus = 'sending';
+        const result = await voiceaChannel.turnOnCaptions();
+        assert.equal(result, undefined);
       });
-    });
 
-    describe('#turnOnCaptions', () => {
-      let requestTurnOnCaptions;
-      beforeEach(() => {
-        requestTurnOnCaptions = sinon.stub(voiceaService, 'requestTurnOnCaptions');
-        voiceaService.captionStatus = 'idle';
-      });
+      it('returns undefined when already enabled', async () => {
+        voiceaChannel.captionStatus = 'enabled';
 
-      afterEach(() => {
-        requestTurnOnCaptions.restore();
-        voiceaService.captionStatus = 'idle';
-      });
+        const result = await voiceaChannel.turnOnCaptions();
 
-      it('call request turn on captions', () => {
-        voiceaService.captionStatus = 'idle';
-        voiceaService.turnOnCaptions();
-        assert.calledOnce(requestTurnOnCaptions);
+        assert.equal(result, undefined);
+        assert.notCalled(requestStub);
       });
 
-      it('throws before turning on captions when llm is not connected', async () => {
-        voiceaService.captionStatus = 'idle';
-        voiceaService.webex.internal.llm.isConnected.returns(false);
+      it('throws error on request failure', async () => {
+        const requestError = new Error('Request failed');
+        requestStub.rejects(requestError);
 
-        await assert.isRejected(
-          voiceaService.turnOnCaptions(),
-          'can not turn on captions before llm connected'
+        const error = await assert.isRejected(
+          voiceaChannel.turnOnCaptions(),
+          'turn on captions fail'
         );
-        assert.notCalled(requestTurnOnCaptions);
-      });
 
-      it('turns on captions when only the practice session llm connection is connected', () => {
-        voiceaService.webex.internal.llm.isConnected.callsFake((channel) =>
-          channel === LLM_PRACTICE_SESSION
-        );
+        assert.equal(error.cause, requestError);
+      });
 
-        voiceaService.turnOnCaptions();
+      it('resets caption status to idle on error', async () => {
+        requestStub.rejects(new Error('Request failed'));
 
-        assert.calledOnce(requestTurnOnCaptions);
-      });
+        try {
+          await voiceaChannel.turnOnCaptions();
+        } catch {
+          // expected
+        }
 
-      it('should not turn on duplicate when processing', () => {
-        voiceaService.captionStatus = 'sending';
-        voiceaService.turnOnCaptions();
-        assert.notCalled(voiceaService.requestTurnOnCaptions);
+        assert.equal(voiceaChannel.getCaptionStatus(), 'idle');
       });
     });
 
     describe('#toggleTranscribing', () => {
-      beforeEach(async () => {
-        const mockWebSocket = new MockWebSocket();
-
-        voiceaService.webex.internal.llm.socket = mockWebSocket;
-      });
-
-      it('turns on transcribing with CC enabled', async () => {
-        // Turn on captions
-        await voiceaService.turnOnCaptions();
-        const announcementSpy = sinon.spy(voiceaService, 'sendAnnouncement');
-
-        // eslint-disable-next-line no-underscore-dangle
-        voiceaService.webex.internal.llm._emit('event:relay.event', {
-          headers: {from: 'ws'},
-          data: {relayType: 'voicea.annc', voiceaPayload: {}},
-        });
+      it('turns on transcribing', async () => {
+        await voiceaChannel.toggleTranscribing(true);
 
-        voiceaService.listenToEvents();
-
-        await voiceaService.toggleTranscribing(true);
         sinon.assert.calledWith(
-          voiceaService.request,
+          requestStub,
           sinon.match({
             method: 'PUT',
             url: `${locusUrl}/controls/`,
             body: {transcribe: {transcribing: true}},
           })
         );
-
-        assert.notCalled(announcementSpy);
       });
 
-      it('turns on transcribing with CC disabled', async () => {
-        const announcementSpy = sinon.spy(voiceaService, 'sendAnnouncement');
-
-        voiceaService.listenToEvents();
+      it('turns off transcribing', async () => {
+        await voiceaChannel.toggleTranscribing(false);
 
-        await voiceaService.toggleTranscribing(true);
         sinon.assert.calledWith(
-          voiceaService.request,
+          requestStub,
           sinon.match({
             method: 'PUT',
             url: `${locusUrl}/controls/`,
-            body: {transcribe: {transcribing: true}},
+            body: {transcribe: {transcribing: false}},
           })
         );
-
-        assert.calledOnce(announcementSpy);
       });
 
-      it('turns off transcribing', async () => {
-        await voiceaService.toggleTranscribing(true);
+      it('calls turnOnCaptions when activating and captions not enabled', async () => {
+        voiceaChannel.areCaptionsEnabled = false;
+        const turnOnCaptionsSpy = sinon.spy(voiceaChannel, 'turnOnCaptions');
+
+        await voiceaChannel.toggleTranscribing(true, 'en');
 
-        const announcementSpy = sinon.spy(voiceaService, 'sendAnnouncement');
+        assert.calledOnceWithExactly(turnOnCaptionsSpy, 'en');
+      });
 
-        voiceaService.listenToEvents();
+      it('does not call turnOnCaptions when captions already enabled', async () => {
+        voiceaChannel.areCaptionsEnabled = true;
+        const turnOnCaptionsSpy = sinon.spy(voiceaChannel, 'turnOnCaptions');
 
-        await voiceaService.toggleTranscribing(false);
-        sinon.assert.calledWith(
-          voiceaService.request,
-          sinon.match({
-            method: 'PUT',
-            url: `${locusUrl}/controls/`,
-            body: {transcribe: {transcribing: true}},
-          })
-        );
+        await voiceaChannel.toggleTranscribing(true);
 
-        assert.notCalled(announcementSpy);
+        assert.notCalled(turnOnCaptionsSpy);
       });
     });
 
     describe('#toggleManualCaption', () => {
-      beforeEach(async () => {
-        const mockWebSocket = new MockWebSocket();
-
-        voiceaService.webex.internal.llm.socket = mockWebSocket;
-        voiceaService.toggleManualCaptionStatus = TOGGLE_MANUAL_CAPTION_STATUS.IDLE;
-      });
-
       it('turns on manual caption', async () => {
-        await voiceaService.toggleManualCaption(true);
+        await voiceaChannel.toggleManualCaption(true);
+
         sinon.assert.calledWith(
-          voiceaService.request,
+          requestStub,
           sinon.match({
             method: 'PUT',
             url: `${locusUrl}/controls/`,
             body: {manualCaption: {enable: true}},
           })
         );
-
       });
 
-
       it('turns off manual caption', async () => {
-        await voiceaService.toggleManualCaption(false);
+        await voiceaChannel.toggleManualCaption(false);
+
         sinon.assert.calledWith(
-          voiceaService.request,
+          requestStub,
           sinon.match({
             method: 'PUT',
             url: `${locusUrl}/controls/`,
             body: {manualCaption: {enable: false}},
           })
         );
+      });
+
+      it('ignores when already sending', async () => {
+        voiceaChannel.toggleManualCaptionStatus = TOGGLE_MANUAL_CAPTION_STATUS.SENDING;
+        await voiceaChannel.toggleManualCaption(true);
+        sinon.assert.notCalled(requestStub);
+      });
+
+      it('throws error on request failure', async () => {
+        requestStub.rejects(new Error('Request failed'));
 
+        await assert.isRejected(
+          voiceaChannel.toggleManualCaption(true),
+          'toggle manual captions fail'
+        );
       });
 
-      it('ignore toggle manual caption', async () => {
-        voiceaService.toggleManualCaptionStatus = TOGGLE_MANUAL_CAPTION_STATUS.SENDING;
-        await voiceaService.toggleManualCaption(true);
+      it('resets status to idle on error', async () => {
+        requestStub.rejects(new Error('Request failed'));
+
+        try {
+          await voiceaChannel.toggleManualCaption(true);
+        } catch {
+          // expected
+        }
+
+        assert.equal(voiceaChannel.toggleManualCaptionStatus, TOGGLE_MANUAL_CAPTION_STATUS.IDLE);
+      });
+    });
 
-        sinon.assert.notCalled(voiceaService.request);
+    describe('#getCaptionStatus', () => {
+      it('returns current caption status', () => {
+        voiceaChannel.captionStatus = 'enabled';
+        assert.equal(voiceaChannel.getCaptionStatus(), 'enabled');
+      });
+    });
 
+    describe('#getAnnounceStatus', () => {
+      it('returns current announce status', () => {
+        voiceaChannel.announceStatus = 'joined';
+        assert.equal(voiceaChannel.getAnnounceStatus(), 'joined');
       });
     });
 
-    describe('#processCaptionLanguageResponse', () => {
-      it('responds to process caption language', async () => {
+    describe('#onSpokenLanguageUpdate', () => {
+      it('should trigger SPOKEN_LANGUAGE_UPDATE event', () => {
         const triggerSpy = sinon.spy();
-        const functionSpy = sinon.spy(voiceaService, 'processCaptionLanguageResponse');
+        voiceaChannel.on(EVENT_TRIGGERS.SPOKEN_LANGUAGE_UPDATE, triggerSpy);
 
-        voiceaService.on(EVENT_TRIGGERS.CAPTION_LANGUAGE_UPDATE, triggerSpy);
-        voiceaService.listenToEvents();
+        voiceaChannel.onSpokenLanguageUpdate('fr', '123');
 
-        // eslint-disable-next-line no-underscore-dangle
-        voiceaService.webex.internal.llm._emit('event:relay.event', {
-          headers: {from: 'ws'},
-          data: {
-            relayType: 'voicea.transl.rsp',
-            voiceaPayload: {
-              statusCode: 200,
-            },
-          },
-        });
+        assert.equal(voiceaChannel.currentSpokenLanguage, 'fr');
+        assert.calledOnceWithExactly(triggerSpy, {languageCode: 'fr', meetingId: '123'});
+      });
+    });
 
-        assert.calledOnceWithExactly(triggerSpy, {statusCode: 200});
-        assert.calledOnce(functionSpy);
+    describe('#onCaptionServiceIdUpdate', () => {
+      it('does nothing when serviceId is falsy', () => {
+        voiceaChannel.captionServiceId = 'existing-id';
+        voiceaChannel.onCaptionServiceIdUpdate(undefined);
+        voiceaChannel.onCaptionServiceIdUpdate('');
+        assert.equal(voiceaChannel.captionServiceId, 'existing-id');
       });
 
-      it('responds to process caption language for a failed response', async () => {
-        const triggerSpy = sinon.spy();
-        const functionSpy = sinon.spy(voiceaService, 'processCaptionLanguageResponse');
+      it('sets captionServiceId when no currentCaptionLanguage', () => {
+        voiceaChannel.captionServiceId = undefined;
+        voiceaChannel.currentCaptionLanguage = undefined;
+        voiceaChannel.onCaptionServiceIdUpdate('svc-new');
+        assert.equal(voiceaChannel.captionServiceId, 'svc-new');
+      });
 
-        voiceaService.on(EVENT_TRIGGERS.CAPTION_LANGUAGE_UPDATE, triggerSpy);
-        voiceaService.listenToEvents();
+      it('re-sends language when serviceId changes and currentCaptionLanguage is set', () => {
+        voiceaChannel.captionServiceId = 'old-svc';
+        voiceaChannel.currentCaptionLanguage = 'es';
 
-        const payload = {
-          errorCode: 300,
-          message: 'error text',
-        };
+        voiceaChannel.onCaptionServiceIdUpdate('new-svc');
 
-        // eslint-disable-next-line no-underscore-dangle
-        voiceaService.webex.internal.llm._emit('event:relay.event', {
-          headers: {from: 'ws'},
-          data: {relayType: 'voicea.transl.rsp', voiceaPayload: payload},
-        });
-        assert.calledOnce(functionSpy);
-        assert.calledOnceWithExactly(triggerSpy, {statusCode: 300, errorMessage: 'error text'});
+        assert.equal(voiceaChannel.captionServiceId, 'new-svc');
+        assert.calledOnce(mockLLMChannel.socket.send);
       });
     });
 
-    describe('#processTranscription', () => {
-      let triggerSpy, functionSpy;
+    describe('#updateSubchannelSubscriptions', () => {
+      it('sends subchannelSubscriptionRequest', async () => {
+        await voiceaChannel.updateSubchannelSubscriptions({
+          subscribe: ['transcription'],
+          unsubscribe: ['polls'],
+        });
 
-      beforeEach(() => {
-        triggerSpy = sinon.spy();
-        functionSpy = sinon.spy(voiceaService, 'processTranscription');
-        voiceaService.listenToEvents();
-      });
-
-      it('processes interim transcription', async () => {
-        voiceaService.on(EVENT_TRIGGERS.NEW_CAPTION, triggerSpy);
-        const transcripts = [
-          {
-            text: 'Hello.',
-            csis: [3556942592],
-            transcript_language_code: 'en',
-            translations: {
-              fr: 'Bonjour.',
-            },
-          },
-          {
-            text: 'This is Webex',
-            csis: [3556942593],
-            transcript_language_code: 'en',
-            translations: {
-              fr: "C'est Webex",
-            },
+        sinon.assert.calledOnceWithExactly(mockLLMChannel.socket.send, {
+          id: '1',
+          type: 'subchannelSubscriptionRequest',
+          data: {
+            datachannelUri: 'datachannelUrl',
+            subscribe: ['transcription'],
+            unsubscribe: ['polls'],
           },
-        ];
-        const voiceaPayload = {
-          audio_received_millis: 0,
-          command_response: '',
-          csis: [3556942592],
-          data: 'Hello.',
-          id: '38093ff5-f6a8-581c-9e59-035ec027994b',
-          meeting: '61d4e269-8419-42ab-9e56-3917974cda01',
-          transcript_id: '3ec73890-bffb-f28b-e77f-99dc13caea7e',
-          ts: 1611653204.3147924,
-          type: 'transcript_interim_results',
-
-          transcripts,
-        };
-
-        // eslint-disable-next-line no-underscore-dangle
-        await voiceaService.webex.internal.llm._emit('event:relay.event', {
-          headers: {from: 'ws'},
-          data: {relayType: 'voicea.transcription', voiceaPayload},
+          trackingId: sinon.match.string,
         });
+      });
 
-        assert.calledOnceWithExactly(functionSpy, voiceaPayload);
-        assert.calledOnceWithExactly(triggerSpy, {
-          isFinal: false,
-          transcriptId: '3ec73890-bffb-f28b-e77f-99dc13caea7e',
-          transcripts,
-        });
+      it('does nothing when LLM is not connected', async () => {
+        mockLLMChannel.isConnected.returns(false);
+
+        await voiceaChannel.updateSubchannelSubscriptions({subscribe: ['transcription']});
+
+        sinon.assert.notCalled(mockLLMChannel.socket.send);
       });
 
-      it('processes final transcription', async () => {
-        voiceaService.on(EVENT_TRIGGERS.NEW_CAPTION, triggerSpy);
+      it('does nothing when dataChannelToken is not enabled', async () => {
+        mockLLMChannel.isDataChannelTokenEnabled.resolves(false);
 
-        const voiceaPayload = {
-          audio_received_millis: 0,
-          command_response: '',
-          csis: [3556942592],
-          data: 'Hello. This is Webex',
-          id: '38093ff5-f6a8-581c-9e59-035ec027994b',
-          meeting: '61d4e269-8419-42ab-9e56-3917974cda01',
-          transcript_id: '3ec73890-bffb-f28b-e77f-99dc13caea7e',
-          ts: 1611653204.3147924,
-          type: 'transcript_final_result',
-          translations: {
-            en: "Hello?",
-          },
-          transcript: {
-            alignments: [
-              {
-                end_millis: 12474,
-                start_millis: 12204,
-                word: 'Hello?',
-              },
-            ],
-            csis: [3556942592],
-            end_millis: 13044,
-            last_packet_timestamp_ms: 1611653206784,
-            start_millis: 12204,
-            text: 'Hello?',
-            transcript_language_code: 'en',
-            timestamp: '0:13'
-          },
-          transcripts: [
-            {
-              start_millis: 12204,
-              end_millis: 13044,
-              text: 'Hello.',
-              csis: [3556942592],
-              transcript_language_code: 'en',
-              translations: {
-                fr: 'Bonjour.',
-              },
-              timestamp: '0:13'
-            },
-            {
-              start_millis: 12204,
-              end_millis: 13044,
-              text: 'This is Webex',
-              csis: [3556942593],
-              transcript_language_code: 'en',
-              translations: {
-                fr: "C'est Webex",
-              },
-              timestamp: '0:13'
-            },
-          ],
-        };
+        await voiceaChannel.updateSubchannelSubscriptions({subscribe: ['transcription']});
 
-        // eslint-disable-next-line no-underscore-dangle
-        await voiceaService.webex.internal.llm._emit('event:relay.event', {
-          headers: {from: 'ws'},
-          data: {relayType: 'voicea.transcription', voiceaPayload},
-        });
-
-        assert.calledOnceWithExactly(functionSpy, voiceaPayload);
-        assert.calledOnceWithExactly(triggerSpy, {
-          isFinal: true,
-          transcriptId: '3ec73890-bffb-f28b-e77f-99dc13caea7e',
-          transcripts: voiceaPayload.transcripts,
-        });
+        sinon.assert.notCalled(mockLLMChannel.socket.send);
       });
+    });
 
-      it('processes a eva wake up', async () => {
-        voiceaService.on(EVENT_TRIGGERS.EVA_COMMAND, triggerSpy);
-
-        const voiceaPayload = {
-          audio_received_millis: 1616137504810,
-          command_response: '',
-          id: '31fb2f81-fb55-4257-32a0-f421ef8ba4b0',
-          meeting: 'fd5bd0fc-06fb-4fd1-982b-554c4368f101',
-          trigger: {
-            detected_at: '2021-03-19T07:05:04.810669662Z',
-            ews_confidence: 0.99497044086456299,
-            ews_keyphrase: 'OkayWebEx',
-            model_version: 'WebEx',
-            offset_seconds: 2336.5900000000001,
-            recording_file_name:
-              'OkayWebEx_fd5bd0fc-06fb-4fd1-982b-554c4368f101_47900f3f-8579-25eb-3f6a-74d81a3c66a4_2335.8900000000003_2336.79.raw',
-            type: 'live-hotword',
-          },
-          ts: 1616137504.8107769,
-          type: 'eva_wake',
-        };
+    describe('#updateSubchannelSubscriptionsAndSyncCaptionState', () => {
+      it('updates caption intent and forwards to updateSubchannelSubscriptions', async () => {
+        const updateSpy = sinon.spy(voiceaChannel, 'updateSubchannelSubscriptions');
 
-        // eslint-disable-next-line no-underscore-dangle
-        await voiceaService.webex.internal.llm._emit('event:relay.event', {
-          headers: {from: 'ws'},
-          data: {relayType: 'voicea.transcription', voiceaPayload},
-        });
+        await voiceaChannel.updateSubchannelSubscriptionsAndSyncCaptionState(
+          {subscribe: ['transcription']},
+          true
+        );
 
-        assert.calledOnceWithExactly(functionSpy, voiceaPayload);
-        assert.calledOnceWithExactly(triggerSpy, {
-          isListening: true,
-        });
+        assert.equal(voiceaChannel.getKeepTranscriptionSubscribed(), true);
+        assert.calledOnceWithExactly(updateSpy, {subscribe: ['transcription']});
       });
 
-      it('processes a eva thanks', async () => {
-        voiceaService.on(EVENT_TRIGGERS.EVA_COMMAND, triggerSpy);
-
-        const voiceaPayload = {
-          audio_received_millis: 0,
-          command_response: 'OK! Decision created.',
-          id: '9bc51440-1a22-7c81-6add-4b6ff7b59f7c',
-          intent: 'decision',
-          meeting: 'fd5bd0fc-06fb-4fd1-982b-554c4368f101',
-          ts: 1616135828.2552843,
-          type: 'eva_thanks',
-        };
+      it('sets caption intent to false when isCCBoxOpen is false', async () => {
+        const updateSpy = sinon.spy(voiceaChannel, 'updateSubchannelSubscriptions');
 
-        // eslint-disable-next-line no-underscore-dangle
-        await voiceaService.webex.internal.llm._emit('event:relay.event', {
-          headers: {from: 'ws'},
-          data: {relayType: 'voicea.transcription', voiceaPayload},
-        });
+        await voiceaChannel.updateSubchannelSubscriptionsAndSyncCaptionState(
+          {subscribe: ['transcription']},
+          false
+        );
 
-        assert.calledOnceWithExactly(functionSpy, voiceaPayload);
-        assert.calledOnceWithExactly(triggerSpy, {
-          isListening: false,
-          text: 'OK! Decision created.',
-        });
+        assert.equal(voiceaChannel.getKeepTranscriptionSubscribed(), false);
+        assert.calledOnceWithExactly(updateSpy, {subscribe: ['transcription']});
       });
 
-      it('processes a eva cancel', async () => {
-        voiceaService.on(EVENT_TRIGGERS.EVA_COMMAND, triggerSpy);
-
-        const voiceaPayload = {
-          audio_received_millis: 0,
-          command_response: '',
-          id: '9bc51440-1a22-7c81-6add-4b6ff7b59f7c',
-          intent: 'decision',
-          meeting: 'fd5bd0fc-06fb-4fd1-982b-554c4368f101',
-          ts: 1616135828.2552843,
-          type: 'eva_cancel',
-        };
-
-        // eslint-disable-next-line no-underscore-dangle
-        await voiceaService.webex.internal.llm._emit('event:relay.event', {
-          headers: {from: 'ws'},
-          data: {relayType: 'voicea.transcription', voiceaPayload},
-        });
+      it('defaults subscribe/unsubscribe to empty arrays when options is empty', async () => {
+        const updateSpy = sinon.spy(voiceaChannel, 'updateSubchannelSubscriptions');
 
-        assert.calledOnceWithExactly(functionSpy, voiceaPayload);
+        await voiceaChannel.updateSubchannelSubscriptionsAndSyncCaptionState({}, true);
 
-        assert.calledOnceWithExactly(triggerSpy, {
-          isListening: false,
-        });
+        assert.equal(voiceaChannel.getKeepTranscriptionSubscribed(), true);
+        assert.calledOnceWithExactly(updateSpy, {});
       });
 
-      it('processes a highlight', async () => {
-        voiceaService.on(EVENT_TRIGGERS.HIGHLIGHT_CREATED, triggerSpy);
-        const voiceaPayload = {
-          audio_received_millis: 0,
-          command_response: '',
-          highlight: {
-            created_by_email: '',
-            csis: [3932881920],
-            end_millis: 660160,
-            highlight_id: '219af4b1-1579-5106-53ab-f621094a0c5a',
-            highlight_label: 'Decision',
-            highlight_source: 'voice-command',
-            start_millis: 652756,
-            transcript: 'Create a decision to move ahead with the last proposal.',
-            trigger_info: {type: 'live-hotword'},
-          },
-          id: 'e6df0262-6289-db2e-581a-d44bb41b1c9c',
-          meeting: 'fd5bd0fc-06fb-4fd1-982b-554c4368f101',
-          ts: 1616135858.5349569,
-          type: 'highlight_created',
-        };
+      it('still updates caption intent even if updateSubchannelSubscriptions does nothing (e.g., LLM not connected)', async () => {
+        mockLLMChannel.isConnected.returns(false);
+        const updateSpy = sinon.spy(voiceaChannel, 'updateSubchannelSubscriptions');
 
-        // eslint-disable-next-line no-underscore-dangle
-        await voiceaService.webex.internal.llm._emit('event:relay.event', {
-          headers: {from: 'ws'},
-          data: {relayType: 'voicea.transcription', voiceaPayload},
-        });
+        await voiceaChannel.updateSubchannelSubscriptionsAndSyncCaptionState(
+          {subscribe: ['transcription']},
+          true
+        );
 
-        assert.calledOnceWithExactly(functionSpy, voiceaPayload);
-        assert.calledOnceWithExactly(triggerSpy, {
-          csis: [3932881920],
-          highlightId: '219af4b1-1579-5106-53ab-f621094a0c5a',
-          text: 'Create a decision to move ahead with the last proposal.',
-          highlightLabel: 'Decision',
-          highlightSource: 'voice-command',
-          timestamp: '11:00',
-        });
+        assert.equal(voiceaChannel.getKeepTranscriptionSubscribed(), true);
+        assert.calledOnceWithExactly(updateSpy, {subscribe: ['transcription']});
       });
+    });
 
-      it('processes a language detected if language is in spoken languages', async () => {
-        voiceaService.on(EVENT_TRIGGERS.LANGUAGE_DETECTED, triggerSpy);
-
-        const voiceaPayload = {
-          id: '9bc51440-1a22-7c81-6add-4b6ff7b59f7c',
-          meeting: 'fd5bd0fc-06fb-4fd1-982b-554c4368f101',
-          type: 'language_detected',
-          language: 'en',
-          translation: {
-            allowed_languages: ['af', 'am'],
-            max_languages: 5,
-          },
-          ASR: {
-            spoken_languages: ['en', 'pl'],
-          },
-
-          version: 'v2',
-        };
+    describe('event processor', () => {
+      let eventHandler;
 
-          const spy = sinon.spy();
+      beforeEach(() => {
+        // Get the registered event handler
+        const onCall = mockLLMChannel.on
+          .getCalls()
+          .find((call) => call.args[0] === 'event:relay.event');
+        eventHandler = onCall?.args[1];
+      });
 
-        voiceaService.on(EVENT_TRIGGERS.VOICEA_ANNOUNCEMENT, spy);
-        voiceaService.listenToEvents();
-        voiceaService.processAnnouncementMessage(voiceaPayload);
+      it('processes voicea announcement events', () => {
+        const spy = sinon.spy();
+        voiceaChannel.on(EVENT_TRIGGERS.VOICEA_ANNOUNCEMENT, spy);
 
-          // eslint-disable-next-line no-underscore-dangle
-        await voiceaService.webex.internal.llm._emit('event:relay.event', {
-          headers: {from: 'ws'},
-          data: {relayType: 'voicea.transcription', voiceaPayload},
+        eventHandler({
+          sequenceNumber: 1,
+          headers: {from: 'ws-service'},
+          data: {
+            relayType: 'voicea.annc',
+            voiceaPayload: {
+              translation: {allowed_languages: ['en', 'es'], max_languages: 3},
+              ASR: {spoken_languages: ['en']},
+            },
+          },
         });
 
-        assert.calledOnceWithExactly(functionSpy, voiceaPayload);
-        assert.calledOnceWithExactly(triggerSpy, {
-            languageCode: 'en',
+        assert.equal(voiceaChannel.getAnnounceStatus(), 'joined');
+        assert.calledOnceWithExactly(spy, {
+          captionLanguages: ['en', 'es'],
+          maxLanguages: 3,
+          spokenLanguages: ['en'],
+          currentSpokenLanguage: 'en',
         });
       });
 
-    });
-
-    describe('#processManualTranscription', () => {
-      let triggerSpy, functionSpy;
-
-      beforeEach(() => {
-        triggerSpy = sinon.spy();
-        functionSpy = sinon.spy(voiceaService, 'processManualTranscription');
-        voiceaService.listenToEvents();
-      });
-
-      it('processes interim manual transcription from aibridge', async () => {
-        voiceaService.on(EVENT_TRIGGERS.NEW_MANUAL_CAPTION, triggerSpy);
-
-        const transcriptPayload = {
-          id: "747d711d-3414-fd69-7081-e842649f2d28",
-          transcripts: [
-            {
-              text: "Good",
-            }
-          ],
-          type: "manual_caption_interim_result",
-        };
+      it('processes voicea announcement with empty payload', () => {
+        const spy = sinon.spy();
+        voiceaChannel.on(EVENT_TRIGGERS.VOICEA_ANNOUNCEMENT, spy);
 
-        // eslint-disable-next-line no-underscore-dangle
-        await voiceaService.webex.internal.llm._emit('event:relay.event', {
-          headers: {from: 'ws'},
-          data: {relayType: 'aibridge.manual_transcription', transcriptPayload},
+        eventHandler({
+          sequenceNumber: 1,
+          headers: {from: 'ws-service'},
+          data: {
+            relayType: 'voicea.annc',
+            voiceaPayload: {},
+          },
         });
 
-        assert.calledOnceWithExactly(functionSpy, {...transcriptPayload, sender: 'ws', data_source: 'aibridge.manual_transcription'});
-        assert.calledOnceWithExactly(triggerSpy, {
-          isFinal: false,
-          transcriptId: '747d711d-3414-fd69-7081-e842649f2d28',
-          transcripts: transcriptPayload.transcripts,
-          sender: 'ws',
-          source: 'aibridge.manual_transcription'
+        assert.calledOnceWithExactly(spy, {
+          captionLanguages: [],
+          maxLanguages: 0,
+          spokenLanguages: [],
+          currentSpokenLanguage: 'en',
         });
       });
 
-      it('processes final manual transcription from aibridge', async () => {
-        voiceaService.on(EVENT_TRIGGERS.NEW_MANUAL_CAPTION, triggerSpy);
-
-        const transcriptPayload = {
-          id: "8d226d31-044a-8d11-cc39-cedbde183154",
-          transcripts: [
+      it('processes speaker name updates and advances the message sequence', () => {
+        const spy = sinon.spy();
+        const voiceaPayload = {
+          id: 'speaker-name-update-1',
+          taggedSpeakers: [
             {
-              text: "Good Morning",
-              start_millis: 10420,
-              end_millis: 11380,
-            }
+              csiId: 3556942592,
+              speakerId: '1',
+              newName: 'Alice',
+            },
           ],
-          type: "manual_caption_final_result",
         };
 
-        // eslint-disable-next-line no-underscore-dangle
-        await voiceaService.webex.internal.llm._emit('event:relay.event', {
+        voiceaChannel.on(EVENT_TRIGGERS.SPEAKER_NAME_UPDATED, spy);
+
+        eventHandler({
+          sequenceNumber: 23,
           headers: {from: 'ws'},
-          data: {relayType: 'aibridge.manual_transcription', transcriptPayload},
+          data: {
+            relayType: 'voicea.update_speakername',
+            voiceaPayload,
+          },
         });
 
-        assert.calledOnceWithExactly(functionSpy, {...transcriptPayload, sender: 'ws', data_source: 'aibridge.manual_transcription'});
-        assert.calledOnceWithExactly(triggerSpy, {
-          isFinal: true,
-          transcriptId: '8d226d31-044a-8d11-cc39-cedbde183154',
-          transcripts: transcriptPayload.transcripts,
-          sender: 'ws',
-          source: 'aibridge.manual_transcription'
+        assert.calledOnceWithExactly(spy, voiceaPayload);
+
+        voiceaChannel.sendAnnouncement();
+
+        assert.calledOnceWithExactly(mockLLMChannel.socket.send, {
+          id: '24',
+          type: 'publishRequest',
+          recipients: [{route: 'binding'}],
+          headers: {},
+          data: {
+            clientPayload: {
+              version: 'v2',
+            },
+            eventType: 'relay.event',
+            relayType: 'client.annc',
+          },
+          trackingId: sinon.match.string,
         });
       });
 
-      it('processes interim manual transcription from captioner', async () => {
-        voiceaService.on(EVENT_TRIGGERS.NEW_MANUAL_CAPTION, triggerSpy);
-
-        const transcriptPayload = {
-          id: "747d711d-3414-fd69-7081-e842649f2d28",
-          transcripts: [
-            {
-              text: "Good",
-            }
-          ],
-          type: "manual_caption_interim_result",
-        };
+      it('processes transcription interim results', () => {
+        const spy = sinon.spy();
+        voiceaChannel.on(EVENT_TRIGGERS.NEW_CAPTION, spy);
 
-        // eslint-disable-next-line no-underscore-dangle
-        await voiceaService.webex.internal.llm._emit('event:relay.event', {
-          headers: {from: '654321'},
-          data: {relayType: 'client.manual_transcription', transcriptPayload},
+        eventHandler({
+          sequenceNumber: 1,
+          headers: {},
+          data: {
+            relayType: 'voicea.transcription',
+            voiceaPayload: {
+              type: 'transcript_interim_results',
+              transcript_id: 'tid-1',
+              transcripts: [{text: 'Hello'}],
+            },
+          },
         });
 
-        assert.calledOnceWithExactly(functionSpy, {...transcriptPayload, sender: '654321', data_source: 'client.manual_transcription'});
-        assert.calledOnceWithExactly(triggerSpy, {
+        assert.calledOnceWithExactly(spy, {
           isFinal: false,
-          transcriptId: '747d711d-3414-fd69-7081-e842649f2d28',
-          transcripts: transcriptPayload.transcripts,
-          sender: '654321',
-          source: 'client.manual_transcription'
+          transcriptId: 'tid-1',
+          transcripts: [{text: 'Hello'}],
         });
       });
 
-      it('processes final manual transcription from captioner', async () => {
-        voiceaService.on(EVENT_TRIGGERS.NEW_MANUAL_CAPTION, triggerSpy);
-
-        const transcriptPayload = {
-          id: "8d226d31-044a-8d11-cc39-cedbde183154",
-          transcripts: [
-            {
-              text: "Good Morning",
-              start_millis: 10420,
-              end_millis: 11380,
-            }
-          ],
-          type: "manual_caption_final_result",
-        };
+      it('processes transcription final results', () => {
+        const spy = sinon.spy();
+        voiceaChannel.on(EVENT_TRIGGERS.NEW_CAPTION, spy);
 
-        // eslint-disable-next-line no-underscore-dangle
-        await voiceaService.webex.internal.llm._emit('event:relay.event', {
-          headers: {from: '654321'},
-          data: {relayType: 'client.manual_transcription', transcriptPayload},
+        eventHandler({
+          sequenceNumber: 1,
+          headers: {},
+          data: {
+            relayType: 'voicea.transcription',
+            voiceaPayload: {
+              type: 'transcript_final_result',
+              transcript_id: 'tid-2',
+              transcripts: [{text: 'Hello world', end_millis: 60000}],
+            },
+          },
         });
 
-        assert.calledOnceWithExactly(functionSpy, {...transcriptPayload, sender: '654321', data_source: 'client.manual_transcription'});
-        assert.calledOnceWithExactly(triggerSpy, {
-          isFinal: true,
-          transcriptId: '8d226d31-044a-8d11-cc39-cedbde183154',
-          transcripts: transcriptPayload.transcripts,
-          sender: '654321',
-          source: 'client.manual_transcription'
-        });
+        assert.calledOnce(spy);
+        const call = spy.getCall(0);
+        assert.equal(call.args[0].isFinal, true);
+        assert.equal(call.args[0].transcriptId, 'tid-2');
       });
-    });
 
-    describe("#getCaptionStatus", () => {
-      it('works correctly', () => {
-        voiceaService.captionStatus = "enabled"
-        assert.equal(voiceaService.getCaptionStatus(), "enabled");
-      });
-    });
+      it('processes caption language response success', () => {
+        const spy = sinon.spy();
+        voiceaChannel.on(EVENT_TRIGGERS.CAPTION_LANGUAGE_UPDATE, spy);
 
-    describe("#getAnnounceStatus", () => {
-      it('works correctly', () => {
-        voiceaService.announceStatus = "joined"
-        assert.equal(voiceaService.getAnnounceStatus(), "joined");
+        eventHandler({
+          sequenceNumber: 1,
+          headers: {},
+          data: {
+            relayType: 'voicea.transl.rsp',
+            voiceaPayload: {statusCode: 200},
+          },
+        });
+
+        assert.calledOnceWithExactly(spy, {statusCode: 200});
       });
-    });
 
-    describe('#onSpokenLanguageUpdate', () => {
-      it('should trigger SPOKEN_LANGUAGE_UPDATE event with correct languageCode', () => {
-        const triggerSpy = sinon.spy();
-        voiceaService.on(EVENT_TRIGGERS.SPOKEN_LANGUAGE_UPDATE, triggerSpy);
+      it('processes caption language response error', () => {
+        const spy = sinon.spy();
+        voiceaChannel.on(EVENT_TRIGGERS.CAPTION_LANGUAGE_UPDATE, spy);
 
-        const languageCode = 'fr';
-        voiceaService.onSpokenLanguageUpdate(languageCode, '123');
-        assert.equal(voiceaService.currentSpokenLanguage, languageCode);
-        assert.calledOnceWithExactly(triggerSpy, {languageCode, meetingId: '123'});
+        eventHandler({
+          sequenceNumber: 1,
+          headers: {},
+          data: {
+            relayType: 'voicea.transl.rsp',
+            voiceaPayload: {statusCode: 400, errorCode: 400, message: 'Bad request'},
+          },
+        });
+
+        assert.calledOnceWithExactly(spy, {statusCode: 400, errorMessage: 'Bad request'});
       });
-    });
 
-    describe('#onCaptionServiceIdUpdate', () => {
-      let mockWebSocket;
+      it('processes manual transcription events', () => {
+        const spy = sinon.spy();
+        voiceaChannel.on(EVENT_TRIGGERS.NEW_MANUAL_CAPTION, spy);
 
-      beforeEach(() => {
-        mockWebSocket = new MockWebSocket();
-        voiceaService.webex.internal.llm.socket = mockWebSocket;
-        voiceaService.webex.internal.llm.isConnected.returns(true);
-        voiceaService.seqNum = 1;
+        eventHandler({
+          sequenceNumber: 1,
+          headers: {from: 'user-1'},
+          data: {
+            relayType: 'client.manual_transcription',
+            transcriptPayload: {
+              type: 'manual_caption_final_result',
+              id: 'manual-id',
+              transcripts: [{text: 'Manual caption'}],
+            },
+          },
+        });
+
+        assert.calledOnce(spy);
+        const call = spy.getCall(0);
+        assert.equal(call.args[0].isFinal, true);
+        assert.equal(call.args[0].transcriptId, 'manual-id');
       });
 
-      it('does nothing when serviceId is falsy', () => {
-        voiceaService.captionServiceId = 'existing-id';
-        voiceaService.currentCaptionLanguage = 'en';
+      it('processes highlight created events', () => {
+        const spy = sinon.spy();
+        voiceaChannel.on(EVENT_TRIGGERS.HIGHLIGHT_CREATED, spy);
 
-        voiceaService.onCaptionServiceIdUpdate(undefined);
-        voiceaService.onCaptionServiceIdUpdate('');
+        eventHandler({
+          sequenceNumber: 1,
+          headers: {},
+          data: {
+            relayType: 'voicea.transcription',
+            voiceaPayload: {
+              type: 'highlight_created',
+              highlight: {
+                csis: [123],
+                highlight_id: 'h-1',
+                transcript: 'Highlighted text',
+                highlight_label: 'important',
+                highlight_source: 'user',
+                end_millis: 30000,
+              },
+            },
+          },
+        });
 
-        assert.equal(voiceaService.captionServiceId, 'existing-id');
-        assert.notCalled(voiceaService.webex.internal.llm.socket.send);
+        assert.calledOnce(spy);
       });
 
-      it('sets captionServiceId when no currentCaptionLanguage', () => {
-        voiceaService.captionServiceId = undefined;
-        voiceaService.currentCaptionLanguage = undefined;
+      it('processes eva wake events', () => {
+        const spy = sinon.spy();
+        voiceaChannel.on(EVENT_TRIGGERS.EVA_COMMAND, spy);
 
-        voiceaService.onCaptionServiceIdUpdate('svc-new');
+        eventHandler({
+          sequenceNumber: 1,
+          headers: {},
+          data: {
+            relayType: 'voicea.transcription',
+            voiceaPayload: {type: 'eva_wake'},
+          },
+        });
 
-        assert.equal(voiceaService.captionServiceId, 'svc-new');
-        assert.notCalled(voiceaService.webex.internal.llm.socket.send);
+        assert.calledOnceWithExactly(spy, {isListening: true});
       });
 
-      it('re-sends language when serviceId changes and currentCaptionLanguage is set', () => {
-        voiceaService.captionServiceId = 'old-svc';
-        voiceaService.currentCaptionLanguage = 'es';
-
-        voiceaService.onCaptionServiceIdUpdate('new-svc');
+      it('processes eva cancel events', () => {
+        const spy = sinon.spy();
+        voiceaChannel.on(EVENT_TRIGGERS.EVA_COMMAND, spy);
 
-        assert.equal(voiceaService.captionServiceId, 'new-svc');
-        assert.calledOnce(voiceaService.webex.internal.llm.socket.send);
+        eventHandler({
+          sequenceNumber: 1,
+          headers: {},
+          data: {
+            relayType: 'voicea.transcription',
+            voiceaPayload: {type: 'eva_cancel'},
+          },
+        });
 
-        const callArgs = voiceaService.webex.internal.llm.socket.send.getCall(0).args[0];
-        expect(callArgs).to.have.nested.property('headers.to', 'new-svc');
-        expect(callArgs).to.have.nested.property('data.clientPayload.translationLanguage', 'es');
+        assert.calledOnceWithExactly(spy, {isListening: false});
       });
 
-      it('does not re-send language when serviceId is unchanged', () => {
-        voiceaService.captionServiceId = 'same-svc';
-        voiceaService.currentCaptionLanguage = 'de';
+      it('processes eva thanks events', () => {
+        const spy = sinon.spy();
+        voiceaChannel.on(EVENT_TRIGGERS.EVA_COMMAND, spy);
 
-        voiceaService.onCaptionServiceIdUpdate('same-svc');
+        eventHandler({
+          sequenceNumber: 1,
+          headers: {},
+          data: {
+            relayType: 'voicea.transcription',
+            voiceaPayload: {type: 'eva_thanks', command_response: 'OK, noted'},
+          },
+        });
 
-        assert.equal(voiceaService.captionServiceId, 'same-svc');
-        assert.notCalled(voiceaService.webex.internal.llm.socket.send);
+        assert.calledOnceWithExactly(spy, {isListening: false, text: 'OK, noted'});
       });
-    });
 
-    describe('#updateSubchannelSubscriptions', () => {
-      beforeEach(() => {
-        const mockWebSocket = new MockWebSocket();
+      it('processes language detected when in spoken languages', () => {
+        const spy = sinon.spy();
+        voiceaChannel.on(EVENT_TRIGGERS.LANGUAGE_DETECTED, spy);
 
-        sinon.stub(voiceaService, 'getPublishTransport').returns({
-          socket: mockWebSocket,
-          datachannelUrl: 'mock-datachannel-uri',
+        // First set up spoken languages via announcement
+        eventHandler({
+          sequenceNumber: 1,
+          headers: {from: 'ws-service'},
+          data: {
+            relayType: 'voicea.annc',
+            voiceaPayload: {
+              ASR: {spoken_languages: ['en', 'es', 'fr']},
+            },
+          },
         });
 
-        voiceaService.seqNum = 1;
+        // Then emit language detected
+        eventHandler({
+          sequenceNumber: 2,
+          headers: {},
+          data: {
+            relayType: 'voicea.transcription',
+            voiceaPayload: {type: 'language_detected', language: 'es'},
+          },
+        });
 
-        voiceaService.isLLMConnected = sinon.stub().returns(true);
-        voiceaService.webex.internal.llm.isDataChannelTokenEnabled = sinon.stub().resolves(true);
+        assert.calledOnceWithExactly(spy, {languageCode: 'es'});
       });
 
-      it('sends subchannelSubscriptionRequest with subscribe and unsubscribe lists', async () => {
-        await voiceaService.updateSubchannelSubscriptions({
-          subscribe: ['transcription'],
-          unsubscribe: ['polls'],
-        });
+      it('does not emit language detected when not in spoken languages', () => {
+        const spy = sinon.spy();
+        voiceaChannel.on(EVENT_TRIGGERS.LANGUAGE_DETECTED, spy);
 
-        const socket = voiceaService.getPublishTransport().socket;
-
-        sinon.assert.calledOnceWithExactly(
-          socket.send,
-          {
-            id: '1',
-            type: 'subchannelSubscriptionRequest',
-            data: {
-              datachannelUri: 'mock-datachannel-uri',
-              subscribe: ['transcription'],
-              unsubscribe: ['polls'],
+        // First set up spoken languages via announcement
+        eventHandler({
+          sequenceNumber: 1,
+          headers: {from: 'ws-service'},
+          data: {
+            relayType: 'voicea.annc',
+            voiceaPayload: {
+              ASR: {spoken_languages: ['en', 'es']},
             },
-            trackingId: sinon.match.string,
-          }
-        );
+          },
+        });
 
-        sinon.assert.match(voiceaService.seqNum, 2);
+        // Then emit language detected for unsupported language
+        eventHandler({
+          sequenceNumber: 2,
+          headers: {},
+          data: {
+            relayType: 'voicea.transcription',
+            voiceaPayload: {type: 'language_detected', language: 'de'},
+          },
+        });
+
+        assert.notCalled(spy);
       });
+    });
 
-      it('sends empty arrays when no subscribe/unsubscribe provided', async () => {
-        await voiceaService.updateSubchannelSubscriptions({});
+    describe('#switchLLMChannel', () => {
+      it('switches to a new LLM channel and preserves caption state', async () => {
+        // First enable captions
+        voiceaChannel.keepTranscriptionSubscribed = true;
+        voiceaChannel.currentSpokenLanguage = 'es';
 
-        const socket = voiceaService.getPublishTransport().socket;
+        const newMockLLMChannel = createMockLLMChannel({locusUrl: 'newLocusUrl'});
 
-        sinon.assert.calledOnceWithExactly(
-          socket.send,
-          {
-            id: '1',
-            type: 'subchannelSubscriptionRequest',
-            data: {
-              datachannelUri: 'mock-datachannel-uri',
-              subscribe: [],
-              unsubscribe: [],
-            },
-            trackingId: sinon.match.string,
-          }
-        );
+        await voiceaChannel.switchLLMChannel(newMockLLMChannel);
 
-        sinon.assert.match(voiceaService.seqNum, 2);
-      });
+        // Should have unsubscribed from old channel
+        assert.calledWith(mockLLMChannel.off, 'event:relay.event', sinon.match.func);
 
-      it('does nothing when LLM is not connected', async () => {
-        voiceaService.isLLMConnected = sinon.stub().returns(false);
+        // Should have subscribed to new channel
+        assert.calledWith(newMockLLMChannel.on, 'event:relay.event', sinon.match.func);
 
-        await voiceaService.updateSubchannelSubscriptions({
-          subscribe: ['transcription'],
-        });
+        // Should have reset announcement state to joining (since captions were on and it re-announced)
+        assert.equal(voiceaChannel.getAnnounceStatus(), 'joining');
 
-        const socket = voiceaService.getPublishTransport().socket;
+        // turnOnCaptions sends both an announcement and a subchannel subscription
+        assert.calledTwice(newMockLLMChannel.socket.send);
 
-        sinon.assert.notCalled(socket.send);
-        sinon.assert.match(voiceaService.seqNum, 1);
+        // First call should be the announcement
+        assert.calledWithExactly(newMockLLMChannel.socket.send.getCall(0), {
+          id: '1',
+          type: 'publishRequest',
+          recipients: [{route: 'binding'}],
+          headers: {},
+          data: {
+            clientPayload: {
+              version: 'v2',
+            },
+            eventType: 'relay.event',
+            relayType: 'client.annc',
+          },
+          trackingId: sinon.match.string,
+        });
       });
 
-      it('does nothing when dataChannelToken is not enabled', async () => {
-        voiceaService.webex.internal.llm.isDataChannelTokenEnabled = sinon.stub().resolves(false);
+      it('resolves after caption restoration completes', async () => {
+        let resolveRequest;
+        requestStub.returns(
+          new Promise((resolve) => {
+            resolveRequest = resolve;
+          })
+        );
+        voiceaChannel.keepTranscriptionSubscribed = true;
 
-        await voiceaService.updateSubchannelSubscriptions({
-          subscribe: ['transcription'],
+        const newMockLLMChannel = createMockLLMChannel({locusUrl: 'newLocusUrl'});
+        const switchPromise = voiceaChannel.switchLLMChannel(newMockLLMChannel);
+        let hasSwitchResolved = false;
+        switchPromise.then(() => {
+          hasSwitchResolved = true;
         });
 
-        const socket = voiceaService.getPublishTransport().socket;
+        await flushPromises();
 
-        sinon.assert.notCalled(socket.send);
-        sinon.assert.match(voiceaService.seqNum, 1);
-      });
-    });
+        assert.isFalse(hasSwitchResolved);
 
+        resolveRequest();
+        await switchPromise;
 
-    describe('#updateSubchannelSubscriptionsAndSyncCaptionState', () => {
-      beforeEach(() => {
-        const mockWebSocket = new MockWebSocket();
-        voiceaService.webex.internal.llm.socket = mockWebSocket;
+        assert.isTrue(hasSwitchResolved);
+      });
 
-        voiceaService.webex.internal.llm.getDatachannelUrl = sinon.stub().returns('mock-datachannel-uri');
+      it('skips switch when already on the same channel', async () => {
+        // Enable captions to verify they are NOT re-enabled on no-op switch
+        voiceaChannel.keepTranscriptionSubscribed = true;
+        voiceaChannel.currentSpokenLanguage = 'es';
 
-        voiceaService.seqNum = 1;
+        // Switch to the same channel that voiceaChannel is already using
+        await voiceaChannel.switchLLMChannel(mockLLMChannel);
 
-        voiceaService.isLLMConnected = sinon.stub().returns(true);
-        voiceaService.webex.internal.llm.isDataChannelTokenEnabled = sinon.stub().resolves(true);
+        // Should NOT have unsubscribed (no-op)
+        assert.notCalled(mockLLMChannel.off);
 
-        sinon.spy(voiceaService, 'updateSubchannelSubscriptions');
+        // Should NOT have re-subscribed
+        // The 'on' was already called in the constructor, but no NEW calls should happen
+        // Since constructor already called 'on', we check it wasn't called again after construction
+        // The mock was created fresh, so we just verify no additional sends
+        assert.notCalled(mockLLMChannel.socket.send);
       });
 
-      afterEach(() => {
-        sinon.restore();
-      });
+      it('does not turn on captions if they were not on before switching', async () => {
+        // Captions are off
+        voiceaChannel.keepTranscriptionSubscribed = false;
 
-      it('updates caption intent and forwards subscribe/unsubscribe to updateSubchannelSubscriptions', async () => {
-        await voiceaService.updateSubchannelSubscriptionsAndSyncCaptionState(
-          {
-            subscribe: ['transcription'],
-            unsubscribe: ['polls'],
-          },
-          true
-        );
+        const newMockLLMChannel = createMockLLMChannel({locusUrl: 'newLocusUrl'});
 
-        assert.equal(voiceaService.keepTranscriptionSubscribed, true);
+        await voiceaChannel.switchLLMChannel(newMockLLMChannel);
 
-        assert.calledOnceWithExactly(
-          voiceaService.updateSubchannelSubscriptions,
-          {
-            subscribe: ['transcription'],
-            unsubscribe: ['polls'],
-          }
-        );
-      });
+        // Should have unsubscribed from old channel
+        assert.calledWith(mockLLMChannel.off, 'event:relay.event', sinon.match.func);
 
-      it('sets caption intent to false when isCCBoxOpen is false', async () => {
-        await voiceaService.updateSubchannelSubscriptionsAndSyncCaptionState(
-          { subscribe: ['transcription'] },
-          false
-        );
+        // Should have subscribed to new channel
+        assert.calledWith(newMockLLMChannel.on, 'event:relay.event', sinon.match.func);
 
-        assert.equal(voiceaService.keepTranscriptionSubscribed, false);
+        // Should NOT have sent any messages (no announcement for captions)
+        assert.notCalled(newMockLLMChannel.socket.send);
 
-        assert.calledOnceWithExactly(
-          voiceaService.updateSubchannelSubscriptions,
-          { subscribe: ['transcription'] }
-        );
+        // State should be idle since captions weren't re-enabled
+        assert.equal(voiceaChannel.getAnnounceStatus(), 'idle');
       });
 
-      it('defaults subscribe/unsubscribe to empty arrays when options is empty', async () => {
-        await voiceaService.updateSubchannelSubscriptionsAndSyncCaptionState({}, true);
+      it('handles case when not previously subscribed to events', async () => {
+        // Create a new channel that hasn't subscribed to events
+        const freshVoiceaChannel = new VoiceaChannel(mockLLMChannel, requestStub);
+        freshVoiceaChannel.hasSubscribedToEvents = false;
 
-        assert.equal(voiceaService.keepTranscriptionSubscribed, true);
+        const newMockLLMChannel = createMockLLMChannel({locusUrl: 'newLocusUrl'});
 
-        assert.calledOnceWithExactly(
-          voiceaService.updateSubchannelSubscriptions,
-          {}
-        );
-      });
+        await freshVoiceaChannel.switchLLMChannel(newMockLLMChannel);
 
-      it('still updates caption intent even if updateSubchannelSubscriptions does nothing (e.g., LLM not connected)', async () => {
-        voiceaService.isLLMConnected = sinon.stub().returns(false);
+        // Should NOT have tried to unsubscribe from old channel (wasn't subscribed)
+        assert.neverCalledWith(mockLLMChannel.off, 'event:relay.event', sinon.match.func);
 
-        await voiceaService.updateSubchannelSubscriptionsAndSyncCaptionState(
-          { subscribe: ['transcription'] },
-          true
-        );
+        // Should have subscribed to new channel
+        assert.calledWith(newMockLLMChannel.on, 'event:relay.event', sinon.match.func);
+      });
 
-        assert.equal(voiceaService.keepTranscriptionSubscribed, true);
+      it('switches from undefined llmChannel to a valid one', async () => {
+        // Create a channel without llmChannel
+        const channelWithoutLLM = new VoiceaChannel(undefined, requestStub);
 
-        assert.calledOnceWithExactly(
-          voiceaService.updateSubchannelSubscriptions,
-          { subscribe: ['transcription'] }
-        );
-      });
-    });
+        const newMockLLMChannel = createMockLLMChannel({locusUrl: 'newLocusUrl'});
 
-    describe('#multiple llm connections', () => {
-      let defaultSocket;
-      let practiceSocket;
-      let isPracticeSessionConnected;
+        await channelWithoutLLM.switchLLMChannel(newMockLLMChannel);
 
-      beforeEach(() => {
-        defaultSocket = new MockWebSocket();
-        practiceSocket = new MockWebSocket();
-        isPracticeSessionConnected = true;
+        // Should have subscribed to new channel
+        assert.calledWith(newMockLLMChannel.on, 'event:relay.event', sinon.match.func);
 
-        voiceaService.webex.internal.llm.socket = defaultSocket;
-        voiceaService.webex.internal.llm.isConnected.callsFake((channel) =>
-          channel === LLM_PRACTICE_SESSION ? isPracticeSessionConnected : true
-        );
-        voiceaService.webex.internal.llm.getSocket.callsFake((channel) =>
-          channel === LLM_PRACTICE_SESSION ? practiceSocket : undefined
-        );
-        voiceaService.webex.internal.llm.getBinding.callsFake((channel) =>
-          channel === LLM_PRACTICE_SESSION ? 'practice-binding' : 'default-binding'
-        );
-        voiceaService.seqNum = 1;
+        // isLLMConnected should now return true
+        assert.equal(channelWithoutLLM.isLLMConnected(), true);
       });
 
-      it('sendAnnouncement uses the practice session socket and binding when available', () => {
-        voiceaService.announceStatus = 'idle';
+      it('defers caption restoration when new channel is not connected', async () => {
+        // Enable captions
+        voiceaChannel.keepTranscriptionSubscribed = true;
+        voiceaChannel.currentSpokenLanguage = 'fr';
 
-        voiceaService.sendAnnouncement();
+        // Create a new channel that is NOT connected yet
+        const newMockLLMChannel = createMockLLMChannel({
+          isConnected: false,
+          locusUrl: 'newLocusUrl',
+        });
 
-        assert.calledOnce(practiceSocket.send);
-        assert.notCalled(defaultSocket.send);
+        await voiceaChannel.switchLLMChannel(newMockLLMChannel);
 
-        const sent = practiceSocket.send.getCall(0).args[0];
-        expect(sent).to.have.nested.property('recipients[0].route', 'practice-binding');
+        // Should have subscribed to new channel events
+        assert.calledWith(newMockLLMChannel.on, 'event:relay.event', sinon.match.func);
+
+        // Should have registered a 'once' listener for 'online' event
+        assert.calledWith(newMockLLMChannel.once, 'online', sinon.match.func);
+
+        // Should NOT have sent any messages yet (waiting for connection)
+        assert.notCalled(newMockLLMChannel.socket.send);
       });
 
-      it('sendAnnouncement falls back to the default socket and binding when the practice session is not connected', () => {
-        voiceaService.announceStatus = 'idle';
-        isPracticeSessionConnected = false;
+      it('restores captions when deferred channel comes online', async () => {
+        // Enable captions
+        voiceaChannel.keepTranscriptionSubscribed = true;
+        voiceaChannel.currentSpokenLanguage = 'de';
 
-        voiceaService.sendAnnouncement();
+        // Create a new channel that is NOT connected yet
+        const newMockLLMChannel = createMockLLMChannel({
+          isConnected: false,
+          locusUrl: 'newLocusUrl',
+        });
 
-        assert.calledOnce(defaultSocket.send);
-        assert.notCalled(practiceSocket.send);
+        await voiceaChannel.switchLLMChannel(newMockLLMChannel);
 
-        const sent = defaultSocket.send.getCall(0).args[0];
-        expect(sent).to.have.nested.property('recipients[0].route', 'default-binding');
-      });
+        // Get the 'online' listener that was registered
+        const onlineListener = newMockLLMChannel.once.getCall(0).args[1];
 
-      it('requestLanguage uses the practice session socket and binding when available', () => {
-        voiceaService.requestLanguage('fr');
+        // Simulate channel coming online
+        newMockLLMChannel.isConnected.returns(true);
+        onlineListener();
 
-        assert.calledOnce(practiceSocket.send);
-        assert.notCalled(defaultSocket.send);
+        // Wait for async turnOnCaptions to complete
+        await flushPromises();
 
-        const sent = practiceSocket.send.getCall(0).args[0];
-        expect(sent).to.have.nested.property('recipients[0].route', 'practice-binding');
-        expect(sent).to.have.nested.property('data.clientPayload.translationLanguage', 'fr');
+        // Now it should have sent messages (announcement + subchannel subscription)
+        assert.calledTwice(newMockLLMChannel.socket.send);
       });
 
-      it('requestLanguage falls back to the default socket and binding when the practice session is not connected', () => {
-        isPracticeSessionConnected = false;
+      it('removes pending online listener when deregisterEvents is called', async () => {
+        // Enable captions
+        voiceaChannel.keepTranscriptionSubscribed = true;
 
-        voiceaService.requestLanguage('fr');
+        // Create a new channel that is NOT connected yet
+        const newMockLLMChannel = createMockLLMChannel({
+          isConnected: false,
+          locusUrl: 'newLocusUrl',
+        });
 
-        assert.calledOnce(defaultSocket.send);
-        assert.notCalled(practiceSocket.send);
+        await voiceaChannel.switchLLMChannel(newMockLLMChannel);
 
-        const sent = defaultSocket.send.getCall(0).args[0];
-        expect(sent).to.have.nested.property('recipients[0].route', 'default-binding');
-        expect(sent).to.have.nested.property('data.clientPayload.translationLanguage', 'fr');
+        // Get the 'online' listener that was registered
+        const onlineListener = newMockLLMChannel.once.getCall(0).args[1];
+
+        // Now deregister events
+        voiceaChannel.deregisterEvents();
+
+        // Should have removed the 'online' listener
+        assert.calledWith(newMockLLMChannel.off, 'online', onlineListener);
       });
 
-      it('sendManualClosedCaption uses the practice session socket and binding when available', () => {
-        voiceaService.sendManualClosedCaption('caption', 123, [456], true);
+      it('removes old pending online listener when switching channels again', async () => {
+        // Enable captions
+        voiceaChannel.keepTranscriptionSubscribed = true;
 
-        assert.calledOnce(practiceSocket.send);
-        assert.notCalled(defaultSocket.send);
+        // Create first new channel that is NOT connected
+        const firstNewChannel = createMockLLMChannel({isConnected: false, locusUrl: 'firstUrl'});
 
-        const sent = practiceSocket.send.getCall(0).args[0];
-        expect(sent).to.have.nested.property('recipients[0].route', 'practice-binding');
-        expect(sent).to.have.nested.property(
-          'data.transcriptPayload.type',
-          'manual_caption_final_result'
-        );
-      });
+        await voiceaChannel.switchLLMChannel(firstNewChannel);
 
-      it('sendManualClosedCaption falls back to the default socket and binding when the practice session is not connected', () => {
-        isPracticeSessionConnected = false;
+        // Get the 'online' listener registered on first channel
+        const firstOnlineListener = firstNewChannel.once.getCall(0).args[1];
 
-        voiceaService.sendManualClosedCaption('caption', 123, [456], false);
+        // Now switch to another channel (also not connected)
+        const secondNewChannel = createMockLLMChannel({isConnected: false, locusUrl: 'secondUrl'});
 
-        assert.calledOnce(defaultSocket.send);
-        assert.notCalled(practiceSocket.send);
+        await voiceaChannel.switchLLMChannel(secondNewChannel);
 
-        const sent = defaultSocket.send.getCall(0).args[0];
-        expect(sent).to.have.nested.property('recipients[0].route', 'default-binding');
-        expect(sent).to.have.nested.property(
-          'data.transcriptPayload.type',
-          'manual_caption_interim_result'
-        );
+        // Should have removed the 'online' listener from first channel
+        assert.calledWith(firstNewChannel.off, 'online', firstOnlineListener);
+
+        // Should have registered a new 'online' listener on second channel
+        assert.calledWith(secondNewChannel.once, 'online', sinon.match.func);
       });
 
-      it('processes relay events from the practice session channel', async () => {
-        const announcementSpy = sinon.spy(voiceaService, 'processAnnouncementMessage');
+      it('does not duplicate caption HTTP requests on concurrent same-channel switches', async () => {
+        // Enable captions
+        voiceaChannel.keepTranscriptionSubscribed = true;
+        voiceaChannel.currentSpokenLanguage = 'en';
 
-        voiceaService.listenToEvents();
+        const newMockLLMChannel = createMockLLMChannel({locusUrl: 'newLocusUrl'});
 
-        // eslint-disable-next-line no-underscore-dangle
-        await voiceaService.webex.internal.llm._emit(`event:relay.event:${LLM_PRACTICE_SESSION}`, {
-          headers: {from: 'svc-practice'},
-          data: {
-            relayType: 'voicea.annc',
-            voiceaPayload: {
-              translation: {allowed_languages: ['en'], max_languages: 1},
-              ASR: {spoken_languages: ['en']},
-            },
-          },
-          sequenceNumber: 10,
-        });
+        // Simulate concurrent switches to the same channel
+        const switch1 = voiceaChannel.switchLLMChannel(newMockLLMChannel);
+        const switch2 = voiceaChannel.switchLLMChannel(newMockLLMChannel);
+
+        await Promise.all([switch1, switch2]);
+
+        // Wait for fire-and-forget turnOnCaptions to complete
+        await new Promise((resolve) => setTimeout(resolve, 0));
+
+        // Should only have sent 2 messages total (announcement + subchannel subscription)
+        // NOT 4 messages (which would indicate duplicate switches)
+        assert.calledTwice(newMockLLMChannel.socket.send);
+      });
+    });
+
+    describe('#requireLLMChannel', () => {
+      it('throws when llmChannel is undefined', () => {
+        const channelWithoutLLM = new VoiceaChannel(undefined, requestStub);
+
+        assert.throws(
+          () => channelWithoutLLM.sendAnnouncement(),
+          'VoiceaChannel: LLM channel not available'
+        );
+      });
 
-        assert.calledOnce(announcementSpy);
-        assert.equal(voiceaService.captionServiceId, 'svc-practice');
+      it('does not throw when llmChannel is defined', () => {
+        // voiceaChannel has a mockLLMChannel, so this should not throw
+        assert.doesNotThrow(() => voiceaChannel.sendAnnouncement());
       });
     });
   });