@webex/internal-plugin-voicea 3.12.0-task-refactor.1 → 3.12.0-webex-services-ready.2

package/test/unit/spec/voicea.js

@@ -7,7 +7,11 @@ import Mercury from '@webex/internal-plugin-mercury';
 import LLMChannel from '@webex/internal-plugin-llm';
 
 import VoiceaService from '../../../src/index';
-import {EVENT_TRIGGERS, TOGGLE_MANUAL_CAPTION_STATUS} from '../../../src/constants';
+import {
+  EVENT_TRIGGERS,
+  LLM_PRACTICE_SESSION,
+  TOGGLE_MANUAL_CAPTION_STATUS,
+} from '../../../src/constants';
 
 describe('plugin-voicea', () => {
   const locusUrl = 'locusUrl';
@@ -28,6 +32,7 @@ describe('plugin-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({
@@ -87,7 +92,34 @@ describe('plugin-voicea', () => {
 
         voiceaService.sendAnnouncement();
 
-        assert.calledOnceWithExactly(spy, 'event:relay.event', sinon.match.func);
+        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';
+
+        voiceaService.sendAnnouncement();
+
+        assert.calledOnceWithExactly(voiceaService.webex.internal.llm.socket.send, {
+          id: '1',
+          type: 'publishRequest',
+          recipients: {route: undefined},
+          headers: {to: 'svc-123'},
+          data: {
+            clientPayload: {
+              version: 'v2',
+            },
+            eventType: 'relay.event',
+            relayType: 'client.annc',
+          },
+          trackingId: sinon.match.string,
+        });
       });
     });
 
@@ -189,32 +221,32 @@ describe('plugin-voicea', () => {
         assert.notCalled(voiceaService.webex.internal.llm.socket.send);
       });
     });
-
     describe('#deregisterEvents', () => {
       beforeEach(async () => {
         const mockWebSocket = new MockWebSocket();
-
         voiceaService.webex.internal.llm.socket = mockWebSocket;
+        voiceaService.isCaptionBoxOn = true;
       });
 
-      it('deregisters voicea service', async () => {
+      it('deregisters voicea service and resets caption state', async () => {
         voiceaService.listenToEvents();
         await voiceaService.toggleTranscribing(true);
 
-        // eslint-disable-next-line no-underscore-dangle
         voiceaService.webex.internal.llm._emit('event:relay.event', {
           headers: {from: 'ws'},
           data: {relayType: 'voicea.annc', voiceaPayload: {}},
         });
 
         assert.equal(voiceaService.areCaptionsEnabled, true);
-        assert.equal(voiceaService.vmcDeviceId, 'ws');
+        assert.equal(voiceaService.captionServiceId, 'ws');
+        assert.equal(voiceaService.isCaptionBoxOn, true);
 
         voiceaService.deregisterEvents();
         assert.equal(voiceaService.areCaptionsEnabled, false);
-        assert.equal(voiceaService.vmcDeviceId, undefined);
+        assert.equal(voiceaService.captionServiceId, undefined);
         assert.equal(voiceaService.announceStatus, 'idle');
         assert.equal(voiceaService.captionStatus, 'idle');
+        assert.equal(voiceaService.isCaptionBoxOn, false);
       });
     });
     describe('#processAnnouncementMessage', () => {
@@ -244,7 +276,7 @@ describe('plugin-voicea', () => {
         });
       });
 
-      it('works on non-empty payload', async () => {
+      it('works on empty payload', async () => {
         const spy = sinon.spy();
 
         voiceaService.on(EVENT_TRIGGERS.VOICEA_ANNOUNCEMENT, spy);
@@ -286,6 +318,28 @@ describe('plugin-voicea', () => {
           trackingId: sinon.match.string,
         });
       });
+
+      it('uses captionServiceId as "to" header when set', () => {
+        voiceaService.captionServiceId = 'svc-456';
+
+        voiceaService.requestLanguage('fr');
+
+        assert.calledOnceWithExactly(voiceaService.webex.internal.llm.socket.send, {
+          id: '1',
+          type: 'publishRequest',
+          recipients: {route: undefined},
+          headers: {to: 'svc-456'},
+          data: {
+            clientPayload: {
+              translationLanguage: 'fr',
+              id: sinon.match.string,
+            },
+            eventType: 'relay.event',
+            relayType: 'voicea.transl.req',
+          },
+          trackingId: sinon.match.string,
+        });
+      });
     });
 
     describe('#setSpokenLanguage', () => {
@@ -354,6 +408,7 @@ describe('plugin-voicea', () => {
 
       it('turns on captions', async () => {
         const announcementSpy = sinon.spy(voiceaService, 'announce');
+        const updateSubchannelSubscriptionsAndSyncCaptionStateSpy = sinon.spy(voiceaService, 'updateSubchannelSubscriptionsAndSyncCaptionState');
 
         const triggerSpy = sinon.spy();
 
@@ -374,6 +429,11 @@ describe('plugin-voicea', () => {
         assert.calledOnceWithExactly(triggerSpy);
 
         assert.calledOnce(announcementSpy);
+        assert.calledOnceWithExactly(
+          updateSubchannelSubscriptionsAndSyncCaptionStateSpy,
+          { subscribe: ['transcription'] },
+          true
+        );
       });
 
       it("should handle request fail", async () => {
@@ -408,17 +468,61 @@ describe('plugin-voicea', () => {
       });
     });
 
+    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);
+      });
+
+      it('returns true when only the practice session llm connection is connected', () => {
+        voiceaService.webex.internal.llm.isConnected.callsFake((channel) =>
+          channel === LLM_PRACTICE_SESSION
+        );
+
+        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);
+      });
+    });
+
+    describe('#getIsCaptionBoxOn', () => {
+      beforeEach(() => {
+        voiceaService.isCaptionBoxOn = false;
+      });
+
+      it('returns false when captions are disabled', () => {
+        voiceaService.isCaptionBoxOn = false;
+
+        const result = voiceaService.getIsCaptionBoxOn();
+
+        assert.equal(result, false);
+      });
+
+      it('returns true when captions are enabled', () => {
+        voiceaService.isCaptionBoxOn = true;
+
+        const result = voiceaService.getIsCaptionBoxOn();
+
+        assert.equal(result, true);
+      });
+    });
+
     describe("#announce", () => {
-      let isAnnounceProcessing, sendAnnouncement;
+      let isAnnounceProcessed, sendAnnouncement;
       beforeEach(() => {
-        voiceaService.webex.internal.llm.isConnected.returns(true);
         sendAnnouncement = sinon.stub(voiceaService, 'sendAnnouncement');
-        isAnnounceProcessing = sinon.stub(voiceaService, 'isAnnounceProcessing').returns(false)
+        isAnnounceProcessed = sinon.stub(voiceaService, 'isAnnounceProcessed').returns(false)
       });
 
       afterEach(() => {
-        voiceaService.webex.internal.llm.isConnected.returns(true);
-        isAnnounceProcessing.restore();
+        isAnnounceProcessed.restore();
         sendAnnouncement.restore();
       });
 
@@ -433,8 +537,18 @@ describe('plugin-voicea', () => {
         assert.notCalled(sendAnnouncement);
       });
 
+      it('announce to llm data channel when only practice session is connected', ()=> {
+        voiceaService.webex.internal.llm.isConnected.callsFake((channel) =>
+          channel === LLM_PRACTICE_SESSION
+        );
+
+        voiceaService.announce();
+
+        assert.calledOnce(sendAnnouncement);
+      });
+
       it('should not announce duplicate', () => {
-        isAnnounceProcessing.returns(true);
+        isAnnounceProcessed.returns(true);
         voiceaService.announce();
         assert.notCalled(sendAnnouncement);
       })
@@ -463,13 +577,11 @@ describe('plugin-voicea', () => {
       beforeEach(() => {
         requestTurnOnCaptions = sinon.stub(voiceaService, 'requestTurnOnCaptions');
         voiceaService.captionStatus = 'idle';
-        voiceaService.webex.internal.llm.isConnected.returns(true);
       });
 
       afterEach(() => {
         requestTurnOnCaptions.restore();
         voiceaService.captionStatus = 'idle';
-        voiceaService.webex.internal.llm.isConnected.returns(true);
       });
 
       it('call request turn on captions', () => {
@@ -478,13 +590,27 @@ describe('plugin-voicea', () => {
         assert.calledOnce(requestTurnOnCaptions);
       });
 
-      it("turns on captions before llm connected", () => {
+      it('throws before turning on captions when llm is not connected', async () => {
         voiceaService.captionStatus = 'idle';
-        voiceaService.webex.internal.llm.isConnected.returns(true);
-        // assert.throws(() => voiceaService.turnOnCaptions(), "can not turn on captions before llm connected");
+        voiceaService.webex.internal.llm.isConnected.returns(false);
+
+        await assert.isRejected(
+          voiceaService.turnOnCaptions(),
+          'can not turn on captions before llm connected'
+        );
         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
+        );
+
+        voiceaService.turnOnCaptions();
+
+        assert.calledOnce(requestTurnOnCaptions);
+      });
+
       it('should not turn on duplicate when processing', () => {
         voiceaService.captionStatus = 'sending';
         voiceaService.turnOnCaptions();
@@ -1101,5 +1227,357 @@ describe('plugin-voicea', () => {
         assert.calledOnceWithExactly(triggerSpy, {languageCode, meetingId: '123'});
       });
     });
+
+    describe('#onCaptionServiceIdUpdate', () => {
+      let mockWebSocket;
+
+      beforeEach(() => {
+        mockWebSocket = new MockWebSocket();
+        voiceaService.webex.internal.llm.socket = mockWebSocket;
+        voiceaService.webex.internal.llm.isConnected.returns(true);
+        voiceaService.seqNum = 1;
+      });
+
+      it('does nothing when serviceId is falsy', () => {
+        voiceaService.captionServiceId = 'existing-id';
+        voiceaService.currentCaptionLanguage = 'en';
+
+        voiceaService.onCaptionServiceIdUpdate(undefined);
+        voiceaService.onCaptionServiceIdUpdate('');
+
+        assert.equal(voiceaService.captionServiceId, 'existing-id');
+        assert.notCalled(voiceaService.webex.internal.llm.socket.send);
+      });
+
+      it('sets captionServiceId when no currentCaptionLanguage', () => {
+        voiceaService.captionServiceId = undefined;
+        voiceaService.currentCaptionLanguage = undefined;
+
+        voiceaService.onCaptionServiceIdUpdate('svc-new');
+
+        assert.equal(voiceaService.captionServiceId, 'svc-new');
+        assert.notCalled(voiceaService.webex.internal.llm.socket.send);
+      });
+
+      it('re-sends language when serviceId changes and currentCaptionLanguage is set', () => {
+        voiceaService.captionServiceId = 'old-svc';
+        voiceaService.currentCaptionLanguage = 'es';
+
+        voiceaService.onCaptionServiceIdUpdate('new-svc');
+
+        assert.equal(voiceaService.captionServiceId, 'new-svc');
+        assert.calledOnce(voiceaService.webex.internal.llm.socket.send);
+
+        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');
+      });
+
+      it('does not re-send language when serviceId is unchanged', () => {
+        voiceaService.captionServiceId = 'same-svc';
+        voiceaService.currentCaptionLanguage = 'de';
+
+        voiceaService.onCaptionServiceIdUpdate('same-svc');
+
+        assert.equal(voiceaService.captionServiceId, 'same-svc');
+        assert.notCalled(voiceaService.webex.internal.llm.socket.send);
+      });
+    });
+
+    describe('#updateSubchannelSubscriptions', () => {
+      beforeEach(() => {
+        const mockWebSocket = new MockWebSocket();
+
+        sinon.stub(voiceaService, 'getPublishTransport').returns({
+          socket: mockWebSocket,
+          datachannelUrl: 'mock-datachannel-uri',
+        });
+
+        voiceaService.seqNum = 1;
+
+        voiceaService.isLLMConnected = sinon.stub().returns(true);
+        voiceaService.webex.internal.llm.isDataChannelTokenEnabled = sinon.stub().resolves(true);
+      });
+
+      it('sends subchannelSubscriptionRequest with subscribe and unsubscribe lists', async () => {
+        await voiceaService.updateSubchannelSubscriptions({
+          subscribe: ['transcription'],
+          unsubscribe: ['polls'],
+        });
+
+        const socket = voiceaService.getPublishTransport().socket;
+
+        sinon.assert.calledOnceWithExactly(
+          socket.send,
+          {
+            id: '1',
+            type: 'subchannelSubscriptionRequest',
+            data: {
+              datachannelUri: 'mock-datachannel-uri',
+              subscribe: ['transcription'],
+              unsubscribe: ['polls'],
+            },
+            trackingId: sinon.match.string,
+          }
+        );
+
+        sinon.assert.match(voiceaService.seqNum, 2);
+      });
+
+      it('sends empty arrays when no subscribe/unsubscribe provided', async () => {
+        await voiceaService.updateSubchannelSubscriptions({});
+
+        const socket = voiceaService.getPublishTransport().socket;
+
+        sinon.assert.calledOnceWithExactly(
+          socket.send,
+          {
+            id: '1',
+            type: 'subchannelSubscriptionRequest',
+            data: {
+              datachannelUri: 'mock-datachannel-uri',
+              subscribe: [],
+              unsubscribe: [],
+            },
+            trackingId: sinon.match.string,
+          }
+        );
+
+        sinon.assert.match(voiceaService.seqNum, 2);
+      });
+
+      it('does nothing when LLM is not connected', async () => {
+        voiceaService.isLLMConnected = sinon.stub().returns(false);
+
+        await voiceaService.updateSubchannelSubscriptions({
+          subscribe: ['transcription'],
+        });
+
+        const socket = voiceaService.getPublishTransport().socket;
+
+        sinon.assert.notCalled(socket.send);
+        sinon.assert.match(voiceaService.seqNum, 1);
+      });
+
+      it('does nothing when dataChannelToken is not enabled', async () => {
+        voiceaService.webex.internal.llm.isDataChannelTokenEnabled = sinon.stub().resolves(false);
+
+        await voiceaService.updateSubchannelSubscriptions({
+          subscribe: ['transcription'],
+        });
+
+        const socket = voiceaService.getPublishTransport().socket;
+
+        sinon.assert.notCalled(socket.send);
+        sinon.assert.match(voiceaService.seqNum, 1);
+      });
+    });
+
+
+    describe('#updateSubchannelSubscriptionsAndSyncCaptionState', () => {
+      beforeEach(() => {
+        const mockWebSocket = new MockWebSocket();
+        voiceaService.webex.internal.llm.socket = mockWebSocket;
+
+        voiceaService.webex.internal.llm.getDatachannelUrl = sinon.stub().returns('mock-datachannel-uri');
+
+        voiceaService.seqNum = 1;
+
+        voiceaService.isLLMConnected = sinon.stub().returns(true);
+        voiceaService.webex.internal.llm.isDataChannelTokenEnabled = sinon.stub().resolves(true);
+
+        sinon.spy(voiceaService, 'updateSubchannelSubscriptions');
+      });
+
+      afterEach(() => {
+        sinon.restore();
+      });
+
+      it('updates caption intent and forwards subscribe/unsubscribe to updateSubchannelSubscriptions', async () => {
+        await voiceaService.updateSubchannelSubscriptionsAndSyncCaptionState(
+          {
+            subscribe: ['transcription'],
+            unsubscribe: ['polls'],
+          },
+          true
+        );
+
+        assert.equal(voiceaService.isCaptionBoxOn, true);
+
+        assert.calledOnceWithExactly(
+          voiceaService.updateSubchannelSubscriptions,
+          {
+            subscribe: ['transcription'],
+            unsubscribe: ['polls'],
+          }
+        );
+      });
+
+      it('sets caption intent to false when isCCBoxOpen is false', async () => {
+        await voiceaService.updateSubchannelSubscriptionsAndSyncCaptionState(
+          { subscribe: ['transcription'] },
+          false
+        );
+
+        assert.equal(voiceaService.isCaptionBoxOn, false);
+
+        assert.calledOnceWithExactly(
+          voiceaService.updateSubchannelSubscriptions,
+          { subscribe: ['transcription'] }
+        );
+      });
+
+      it('defaults subscribe/unsubscribe to empty arrays when options is empty', async () => {
+        await voiceaService.updateSubchannelSubscriptionsAndSyncCaptionState({}, true);
+
+        assert.equal(voiceaService.isCaptionBoxOn, true);
+
+        assert.calledOnceWithExactly(
+          voiceaService.updateSubchannelSubscriptions,
+          {}
+        );
+      });
+
+      it('still updates caption intent even if updateSubchannelSubscriptions does nothing (e.g., LLM not connected)', async () => {
+        voiceaService.isLLMConnected = sinon.stub().returns(false);
+
+        await voiceaService.updateSubchannelSubscriptionsAndSyncCaptionState(
+          { subscribe: ['transcription'] },
+          true
+        );
+
+        assert.equal(voiceaService.isCaptionBoxOn, true);
+
+        assert.calledOnceWithExactly(
+          voiceaService.updateSubchannelSubscriptions,
+          { subscribe: ['transcription'] }
+        );
+      });
+    });
+
+    describe('#multiple llm connections', () => {
+      let defaultSocket;
+      let practiceSocket;
+      let isPracticeSessionConnected;
+
+      beforeEach(() => {
+        defaultSocket = new MockWebSocket();
+        practiceSocket = new MockWebSocket();
+        isPracticeSessionConnected = true;
+
+        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;
+      });
+
+      it('sendAnnouncement uses the practice session socket and binding when available', () => {
+        voiceaService.announceStatus = 'idle';
+
+        voiceaService.sendAnnouncement();
+
+        assert.calledOnce(practiceSocket.send);
+        assert.notCalled(defaultSocket.send);
+
+        const sent = practiceSocket.send.getCall(0).args[0];
+        expect(sent).to.have.nested.property('recipients.route', 'practice-binding');
+      });
+
+      it('sendAnnouncement falls back to the default socket and binding when the practice session is not connected', () => {
+        voiceaService.announceStatus = 'idle';
+        isPracticeSessionConnected = false;
+
+        voiceaService.sendAnnouncement();
+
+        assert.calledOnce(defaultSocket.send);
+        assert.notCalled(practiceSocket.send);
+
+        const sent = defaultSocket.send.getCall(0).args[0];
+        expect(sent).to.have.nested.property('recipients.route', 'default-binding');
+      });
+
+      it('requestLanguage uses the practice session socket and binding when available', () => {
+        voiceaService.requestLanguage('fr');
+
+        assert.calledOnce(practiceSocket.send);
+        assert.notCalled(defaultSocket.send);
+
+        const sent = practiceSocket.send.getCall(0).args[0];
+        expect(sent).to.have.nested.property('recipients.route', 'practice-binding');
+        expect(sent).to.have.nested.property('data.clientPayload.translationLanguage', 'fr');
+      });
+
+      it('requestLanguage falls back to the default socket and binding when the practice session is not connected', () => {
+        isPracticeSessionConnected = false;
+
+        voiceaService.requestLanguage('fr');
+
+        assert.calledOnce(defaultSocket.send);
+        assert.notCalled(practiceSocket.send);
+
+        const sent = defaultSocket.send.getCall(0).args[0];
+        expect(sent).to.have.nested.property('recipients.route', 'default-binding');
+        expect(sent).to.have.nested.property('data.clientPayload.translationLanguage', 'fr');
+      });
+
+      it('sendManualClosedCaption uses the practice session socket and binding when available', () => {
+        voiceaService.sendManualClosedCaption('caption', 123, [456], true);
+
+        assert.calledOnce(practiceSocket.send);
+        assert.notCalled(defaultSocket.send);
+
+        const sent = practiceSocket.send.getCall(0).args[0];
+        expect(sent).to.have.nested.property('recipients.route', 'practice-binding');
+        expect(sent).to.have.nested.property(
+          'data.transcriptPayload.type',
+          'manual_caption_final_result'
+        );
+      });
+
+      it('sendManualClosedCaption falls back to the default socket and binding when the practice session is not connected', () => {
+        isPracticeSessionConnected = false;
+
+        voiceaService.sendManualClosedCaption('caption', 123, [456], false);
+
+        assert.calledOnce(defaultSocket.send);
+        assert.notCalled(practiceSocket.send);
+
+        const sent = defaultSocket.send.getCall(0).args[0];
+        expect(sent).to.have.nested.property('recipients.route', 'default-binding');
+        expect(sent).to.have.nested.property(
+          'data.transcriptPayload.type',
+          'manual_caption_interim_result'
+        );
+      });
+
+      it('processes relay events from the practice session channel', async () => {
+        const announcementSpy = sinon.spy(voiceaService, 'processAnnouncementMessage');
+
+        voiceaService.listenToEvents();
+
+        // 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,
+        });
+
+        assert.calledOnce(announcementSpy);
+        assert.equal(voiceaService.captionServiceId, 'svc-practice');
+      });
+    });
   });
 });