@webex/contact-center 3.12.0-task-refactor.10 → 3.12.0-task-refactor.11

package/src/cc.ts

@@ -351,6 +351,7 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
     this.$webex.once(READY, () => {
       // @ts-ignore
       this.$config = this.config;
+      this.validatePluginConfig();
 
       /**
        * This is used for handling the async requests by sending webex.request and wait for corresponding websocket event.
@@ -406,6 +407,16 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
     this.trigger(TASK_EVENTS.TASK_HYDRATE, task);
   };
 
+  /**
+   * Handles multi-login hydrate events for SDK instances without Mobius registration
+   * @private
+   * @param {ITask} task The task object associated with the multi-login hydrate
+   */
+  private handleTaskMultiLoginHydrate = (task: ITask) => {
+    // @ts-ignore
+    this.trigger(TASK_EVENTS.TASK_MULTI_LOGIN_HYDRATE, task);
+  };
+
   /**
    * Handles task merged events when tasks are combined eg: EPDN merge/transfer
    * @private
@@ -424,6 +435,7 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
   private incomingTaskListener() {
     this.taskManager.on(TASK_EVENTS.TASK_INCOMING, this.handleIncomingTask);
     this.taskManager.on(TASK_EVENTS.TASK_HYDRATE, this.handleTaskHydrate);
+    this.taskManager.on(TASK_EVENTS.TASK_MULTI_LOGIN_HYDRATE, this.handleTaskMultiLoginHydrate);
     this.taskManager.on(TASK_EVENTS.TASK_MERGED, this.handleTaskMerged);
   }
 
@@ -553,6 +565,7 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
 
       this.taskManager.off(TASK_EVENTS.TASK_INCOMING, this.handleIncomingTask);
       this.taskManager.off(TASK_EVENTS.TASK_HYDRATE, this.handleTaskHydrate);
+      this.taskManager.off(TASK_EVENTS.TASK_MULTI_LOGIN_HYDRATE, this.handleTaskMultiLoginHydrate);
       this.taskManager.unregisterIncomingCallEvent();
 
       this.services.webSocketManager.off('message', this.handleWebsocketMessage);
@@ -769,7 +782,8 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
           }
           if (
             this.agentConfig.webRtcEnabled &&
-            this.agentConfig.loginVoiceOptions.includes(LoginOption.BROWSER)
+            this.agentConfig.loginVoiceOptions.includes(LoginOption.BROWSER) &&
+            !this.isWebRTCRegistrationDisabled()
           ) {
             this.$webex.internal.mercury
               .connect()
@@ -785,6 +799,14 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
                   method: METHODS.CONNECT_WEBSOCKET,
                 });
               });
+          } else if (this.isWebRTCRegistrationDisabled()) {
+            LoggerProxy.info(
+              'Skipping Mobius registration because disableWebRTCRegistration is enabled',
+              {
+                module: CC_FILE,
+                method: METHODS.CONNECT_WEBSOCKET,
+              }
+            );
           }
           if (this.$config && this.$config.allowAutomatedRelogin) {
             await this.silentRelogin();
@@ -868,8 +890,24 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
         },
       });
 
-      if (this.agentConfig.webRtcEnabled && data.loginOption === LoginOption.BROWSER) {
+      if (
+        this.agentConfig.webRtcEnabled &&
+        data.loginOption === LoginOption.BROWSER &&
+        !this.isWebRTCRegistrationDisabled()
+      ) {
         await this.webCallingService.registerWebCallingLine();
+      } else if (
+        this.agentConfig.webRtcEnabled &&
+        data.loginOption === LoginOption.BROWSER &&
+        this.isWebRTCRegistrationDisabled()
+      ) {
+        LoggerProxy.info(
+          'Skipping web calling line registration because disableWebRTCRegistration is enabled',
+          {
+            module: CC_FILE,
+            method: METHODS.STATION_LOGIN,
+          }
+        );
       }
 
       const resp = await loginResponse;
@@ -1235,6 +1273,30 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
     this.taskManager.handleRealtimeWebsocketEvent(event);
   };
 
+  /**
+   * Checks whether Mobius/WebRTC registration should be skipped by config
+   * @returns {boolean} True when browser WebRTC registration is disabled
+   * @private
+   */
+  private isWebRTCRegistrationDisabled(): boolean {
+    return this.$config?.disableWebRTCRegistration === true;
+  }
+
+  /**
+   * Validates contact-center plugin configuration before service initialization
+   * @private
+   */
+  private validatePluginConfig(): void {
+    if (
+      this.$config?.disableWebRTCRegistration === true &&
+      this.$config?.allowMultiLogin === false
+    ) {
+      throw new Error(
+        'Invalid Contact Center configuration: disableWebRTCRegistration cannot be true when allowMultiLogin is false. Enable allowMultiLogin or allow WebRTC registration so an SDK instance can receive Mobius/WebRTC task events.'
+      );
+    }
+  }
+
   /**
    * Initializes event listeners for the Contact Center service
    * Sets up handlers for connection state changes and other core events
@@ -1380,6 +1442,16 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
     this.agentConfig.deviceType = deviceType;
     switch (deviceType) {
       case LoginOption.BROWSER:
+        if (this.isWebRTCRegistrationDisabled()) {
+          LoggerProxy.info(
+            'Skipping web calling line registration because disableWebRTCRegistration is enabled',
+            {
+              module: CC_FILE,
+              method: METHODS.HANDLE_DEVICE_TYPE,
+            }
+          );
+          break;
+        }
         try {
           await this.webCallingService.registerWebCallingLine();
         } catch (error) {

package/src/config.ts

@@ -25,6 +25,12 @@ export default {
      * @default true
      */
     allowAutomatedRelogin: true,
+    /**
+     * Whether to skip Mobius/WebRTC registration for browser login flows.
+     * @type {boolean}
+     * @default false
+     */
+    disableWebRTCRegistration: false,
     /**
      * The type of client making the connection.
      * @type {string}

package/src/services/task/Task.ts

@@ -278,7 +278,9 @@ export default abstract class Task extends EventEmitter implements ITask {
     const currentState = snapshot.value as TaskState;
     const context = snapshot.context as TaskContext;
 
-    return computeUIControls(currentState, context, this.data);
+    const uiControls = computeUIControls(currentState, context, this.data);
+
+    return uiControls;
   }
 
   /**
@@ -418,9 +420,11 @@ export default abstract class Task extends EventEmitter implements ITask {
       emitTaskOfferContact: this.createEmitSelfAction(TASK_EVENTS.TASK_OFFER_CONTACT, {
         updateTaskData: true,
       }),
-      emitTaskAssigned: this.createEmitSelfAction(TASK_EVENTS.TASK_ASSIGNED, {
-        updateTaskData: true,
-      }),
+      emitTaskAssigned: ({event}: TaskActionArgs) => {
+        this.updateTaskFromEvent(event);
+        this.emit(TASK_EVENTS.TASK_ASSIGNED, this);
+        this.emit(TASK_EVENTS.TASK_MULTI_LOGIN_HYDRATE, this);
+      },
       emitTaskEnd: this.createEmitSelfAction(TASK_EVENTS.TASK_END, {updateTaskData: true}),
       emitTaskOfferConsult: this.createEmitSelfAction(TASK_EVENTS.TASK_OFFER_CONSULT, {
         updateTaskData: true,
@@ -435,6 +439,7 @@ export default abstract class Task extends EventEmitter implements ITask {
         } else {
           this.emit(TASK_EVENTS.TASK_CONSULTING, this);
         }
+        this.emit(TASK_EVENTS.TASK_MULTI_LOGIN_HYDRATE, this);
       },
       emitTaskConsultAccepted: this.createEmitSelfAction(TASK_EVENTS.TASK_CONSULT_ACCEPTED),
       emitTaskConsultEnd: this.createEmitSelfAction(TASK_EVENTS.TASK_CONSULT_END, {

package/src/services/task/TaskManager.ts

@@ -630,6 +630,10 @@ export default class TaskManager extends EventEmitter {
       this.emit(TASK_EVENTS.TASK_HYDRATE, t);
     });
 
+    task.on(TASK_EVENTS.TASK_MULTI_LOGIN_HYDRATE, (t: ITask) => {
+      this.emit(TASK_EVENTS.TASK_MULTI_LOGIN_HYDRATE, t);
+    });
+
     // Listen for internal cleanup signal emitted by the state machine
     task.on(TASK_EVENTS.TASK_CLEANUP, (t: ITask, options?: {removeFromCollection?: boolean}) => {
       this.handleTaskCleanup(t);

package/src/services/task/state-machine/uiControlsComputer.ts

@@ -438,7 +438,7 @@ function computeVoiceInteractionUIControls(
       if (allowHeldMainLegControlsForNonInitiator) return VISIBLE_ENABLED;
       if (showMainLegConferenceControlsDuringConsult) return VISIBLE_DISABLED;
       if (isHydratedConferenceConsultPending && currentLeg === 'main') return VISIBLE_DISABLED;
-      if (!config.isEndTaskEnabled) return DISABLED;
+      if (!config.isEndTaskEnabled && !isWebrtc) return DISABLED;
       if (hasParallelConsultLeg) {
         return isConnected && isEpDnConsult ? VISIBLE_ENABLED : VISIBLE_DISABLED;
       }

package/src/services/task/types.ts

@@ -628,6 +628,17 @@ export enum TASK_EVENTS {
    * ```
    */
   TASK_POST_CALL_ACTIVITY = 'task:postCallActivity',
+
+  /**
+   * Triggered when a multi-login task update should hydrate SDK instances without Mobius registration.
+   * @example
+   * ```typescript
+   * task.on(TASK_EVENTS.TASK_MULTI_LOGIN_HYDRATE, (task: ITask) => {
+   *   console.log('Multi-login hydrate:', task.data.interactionId);
+   * });
+   * ```
+   */
+  TASK_MULTI_LOGIN_HYDRATE = 'task:multiLoginHydrate',
 }
 
 /**

package/src/types.ts

@@ -156,6 +156,8 @@ export interface CCPluginConfig {
   };
   /** Configuration for the calling client */
   callingClientConfig: CallingClientConfig;
+  /** Whether to skip Mobius/WebRTC registration for browser login flows */
+  disableWebRTCRegistration?: boolean;
 }
 
 /**

package/test/unit/spec/cc.ts

@@ -195,6 +195,35 @@ describe('webex.cc', () => {
     webex.emit('ready');
   });
 
+  it('should throw when WebRTC registration is disabled without multi-login', () => {
+    const invalidWebex = MockWebex({
+      children: {
+        mercury: Mercury,
+      },
+      logger: {
+        log: jest.fn(),
+        error: jest.fn(),
+        info: jest.fn(),
+      },
+      credentials: {
+        getOrgId: jest.fn(() => 'mockOrgId'),
+      },
+      config: {
+        ...config,
+        cc: {
+          ...config.cc,
+          allowMultiLogin: false,
+          disableWebRTCRegistration: true,
+        },
+      },
+      once: jest.fn((event, callback) => callback()),
+    }) as unknown as WebexSDK;
+
+    expect(() => new ContactCenter({parent: invalidWebex})).toThrow(
+      'Invalid Contact Center configuration: disableWebRTCRegistration cannot be true when allowMultiLogin is false. Enable allowMultiLogin or allow WebRTC registration so an SDK instance can receive Mobius/WebRTC task events.'
+    );
+  });
+
   describe('cc.getDeviceId', () => {
     it('should return dialNumber when loginOption is EXTENSION', () => {
       const loginOption = LoginOption.EXTENSION;
@@ -328,6 +357,10 @@ describe('webex.cc', () => {
         TASK_EVENTS.TASK_HYDRATE,
         expect.any(Function)
       );
+      expect(mockTaskManager.on).toHaveBeenCalledWith(
+        TASK_EVENTS.TASK_MULTI_LOGIN_HYDRATE,
+        expect.any(Function)
+      );
       expect(mockWebSocketManager.on).toHaveBeenCalledWith('message', expect.any(Function));
 
       expect(configSpy).toHaveBeenCalled();
@@ -475,6 +508,10 @@ describe('webex.cc', () => {
         TASK_EVENTS.TASK_HYDRATE,
         expect.any(Function)
       );
+      expect(mockTaskManager.on).toHaveBeenCalledWith(
+        TASK_EVENTS.TASK_MULTI_LOGIN_HYDRATE,
+        expect.any(Function)
+      );
       expect(mockWebSocketManager.on).toHaveBeenCalledWith('message', expect.any(Function));
 
       expect(configSpy).toHaveBeenCalled();
@@ -486,6 +523,36 @@ describe('webex.cc', () => {
       expect(result).toEqual(mockAgentProfile);
     });
 
+    it('should skip mercury connection when disableWebRTCRegistration is enabled', async () => {
+      webex.cc.$config = {
+        ...webex.cc.$config,
+        allowAutomatedRelogin: false,
+        disableWebRTCRegistration: true,
+      };
+      mockAgentProfile.webRtcEnabled = true;
+      const mercurySpy = jest.spyOn(webex.internal.mercury, 'connect');
+      const connectWebsocketSpy = jest.spyOn(webex.cc, 'connectWebsocket');
+      const setupEventListenersSpy = jest.spyOn(webex.cc, 'setupEventListeners');
+      jest.spyOn(webex.cc.services.config, 'getAgentConfig').mockResolvedValue(mockAgentProfile);
+      mockWebSocketManager.initWebSocket.mockResolvedValue({
+        agentId: 'agent123',
+      });
+
+      const result = await webex.cc.register();
+
+      expect(connectWebsocketSpy).toHaveBeenCalled();
+      expect(setupEventListenersSpy).toHaveBeenCalled();
+      expect(mercurySpy).not.toHaveBeenCalled();
+      expect(LoggerProxy.info).toHaveBeenCalledWith(
+        'Skipping Mobius registration because disableWebRTCRegistration is enabled',
+        {
+          module: CC_FILE,
+          method: 'connectWebsocket',
+        }
+      );
+      expect(result).toEqual(mockAgentProfile);
+    });
+
     it('should not attempt for mercury connection when webrtc is disabled', async () => {
       mockAgentProfile.webRtcEnabled = false;
       const mercurySpy = jest.spyOn(webex.internal.mercury, 'connect');
@@ -658,6 +725,59 @@ describe('webex.cc', () => {
       );
     });
 
+    it('should skip web calling line registration when disableWebRTCRegistration is enabled', async () => {
+      const options = {
+        teamId: 'teamId',
+        loginOption: LoginOption.BROWSER,
+      };
+
+      webex.cc.$config = {
+        ...webex.cc.$config,
+        disableWebRTCRegistration: true,
+      };
+      webex.cc.agentConfig = {
+        agentId: 'agentId',
+        webRtcEnabled: true,
+        loginVoiceOptions: ['BROWSER', 'EXTENSION', 'AGENT_DN'],
+      };
+
+      const registerWebCallingLineSpy = jest.spyOn(
+        webex.cc.webCallingService,
+        'registerWebCallingLine'
+      );
+
+      jest.spyOn(webex.cc.services.agent, 'stationLogin').mockResolvedValue({
+        data: {
+          loginOption: LoginOption.BROWSER,
+          agentId: 'agentId',
+          teamId: 'teamId',
+          siteId: 'siteId',
+          roles: [AGENT],
+          channelsMap: {
+            chat: [],
+            email: [],
+            social: [],
+            telephony: [],
+          },
+        },
+        trackingId: 'notifs_52628',
+        orgId: 'orgId',
+        type: 'StationLoginSuccess',
+        eventType: 'STATION_LOGIN',
+      } as unknown as StationLoginSuccess);
+
+      await webex.cc.stationLogin(options);
+
+      expect(registerWebCallingLineSpy).not.toHaveBeenCalled();
+      expect(LoggerProxy.info).toHaveBeenCalledWith(
+        'Skipping web calling line registration because disableWebRTCRegistration is enabled',
+        {
+          module: CC_FILE,
+          method: 'stationLogin',
+        }
+      );
+    });
+
     it('should not attempt mobius registration for LoginOption.BROWSER if webrtc is disabled', async () => {
       const options = {
         teamId: 'teamId',
@@ -1568,6 +1688,10 @@ describe('webex.cc', () => {
         TASK_EVENTS.TASK_HYDRATE,
         expect.any(Function)
       );
+      expect(mockTaskManager.off).toHaveBeenCalledWith(
+        TASK_EVENTS.TASK_MULTI_LOGIN_HYDRATE,
+        expect.any(Function)
+      );
       expect(mockWebSocketManager.off).toHaveBeenCalledWith('message', expect.any(Function));
       expect(webex.cc.services.connectionService.off).toHaveBeenCalledWith(
         'connectionLost',
@@ -1617,6 +1741,13 @@ describe('webex.cc', () => {
       const [, hydrateCallback] = hydrateCalls[0];
       expect(hydrateCallback).toBe(webex.cc['handleTaskHydrate']);
 
+      const multiLoginHydrateCalls = mockTaskManager.off.mock.calls.filter(
+        ([evt]) => evt === TASK_EVENTS.TASK_MULTI_LOGIN_HYDRATE
+      );
+      expect(multiLoginHydrateCalls).toHaveLength(1);
+      const [, multiLoginHydrateCallback] = multiLoginHydrateCalls[0];
+      expect(multiLoginHydrateCallback).toBe(webex.cc['handleTaskMultiLoginHydrate']);
+
       const messageCalls = mockWebSocketManager.off.mock.calls.filter(([evt]) => evt === 'message');
       expect(messageCalls).toHaveLength(1);
       const [, messageCallback] = messageCalls[0];
@@ -1642,6 +1773,10 @@ describe('webex.cc', () => {
         TASK_EVENTS.TASK_HYDRATE,
         expect.any(Function)
       );
+      expect(mockTaskManager.off).toHaveBeenCalledWith(
+        TASK_EVENTS.TASK_MULTI_LOGIN_HYDRATE,
+        expect.any(Function)
+      );
       expect(mockWebSocketManager.off).toHaveBeenCalledWith('message', expect.any(Function));
       expect(webex.cc.services.connectionService.off).toHaveBeenCalledWith(
         'connectionLost',
@@ -1687,6 +1822,10 @@ describe('webex.cc', () => {
         TASK_EVENTS.TASK_HYDRATE,
         expect.any(Function)
       );
+      expect(mockTaskManager.off).toHaveBeenCalledWith(
+        TASK_EVENTS.TASK_MULTI_LOGIN_HYDRATE,
+        expect.any(Function)
+      );
 
       expect(LoggerProxy.error).toHaveBeenCalledWith(`Error during deregister: ${mockError}`, {
         module: CC_FILE,

package/test/unit/spec/services/task/TaskManager.ts

@@ -92,6 +92,10 @@ describe('TaskManager', () => {
         }
       }
 
+      if ([TaskEvent.ASSIGN, TaskEvent.CONSULTING_ACTIVE].includes(event.type as TaskEvent)) {
+        task.emit(TASK_EVENTS.TASK_MULTI_LOGIN_HYDRATE, task);
+      }
+
       // Auto-answer is now handled at the Task layer (triggered by state machine actions)
       if (
         [TaskEvent.TASK_OFFERED, TaskEvent.OFFER_CONSULT].includes(event.type as TaskEvent) &&
@@ -494,6 +498,7 @@ describe('TaskManager', () => {
       taskManager.getTask(payload.data.interactionId),
       'emit'
     );
+    const taskManagerEmitSpy = jest.spyOn(taskManager, 'emit');
 
     webSocketManagerMock.emit('message', JSON.stringify(assignedPayload));
 
@@ -501,6 +506,10 @@ describe('TaskManager', () => {
       TASK_EVENTS.TASK_ASSIGNED,
       taskManager.getTask(taskId)
     );
+    expect(taskManagerEmitSpy).toHaveBeenCalledWith(
+      TASK_EVENTS.TASK_MULTI_LOGIN_HYDRATE,
+      taskManager.getTask(taskId)
+    );
   });
 
   it('should handle WebSocket message for AGENT_CONTACT_RESERVED and emit task:incoming for extension case', () => {
@@ -1837,6 +1846,7 @@ describe('TaskManager', () => {
     taskManager.getTask(taskId).data.isConsulted = false;
     const task = taskManager.getTask(taskId);
     const sendStateMachineEventSpy = jest.spyOn(task, 'sendStateMachineEvent');
+    const taskManagerEmitSpy = jest.spyOn(taskManager, 'emit');
     const consultingPayload = {
       data: {
         ...initalPayload.data,
@@ -1846,6 +1856,10 @@ describe('TaskManager', () => {
     };
     webSocketManagerMock.emit('message', JSON.stringify(consultingPayload));
     expectLastStateMachineEvent(sendStateMachineEventSpy, TaskEvent.CONSULTING_ACTIVE);
+    expect(taskManagerEmitSpy).toHaveBeenCalledWith(
+      TASK_EVENTS.TASK_MULTI_LOGIN_HYDRATE,
+      taskManager.getTask(taskId)
+    );
     sendStateMachineEventSpy.mockRestore();
   });
 

package/test/unit/spec/services/task/state-machine/uiControlsComputer.ts

@@ -1784,6 +1784,53 @@ describe('uiControlsComputer outdial accept/decline controls', () => {
   });
 });
 
+describe('uiControlsComputer WebRTC call-control end button', () => {
+  function createConnectedContext(voiceVariant: 'webrtc' | 'pstn'): TaskContext {
+    const taskData = createTaskData({
+      interaction: {
+        state: 'connected',
+      } as any,
+    });
+
+    return {
+      taskData,
+      consultInitiator: false,
+      exitingConference: false,
+      consultFromConference: false,
+      transferConferenceRequested: false,
+      consultDestinationType: null,
+      consultDestinationAgentId: null,
+      consultDestinationAgentJoined: false,
+      consultCallHeld: false,
+      recordingControlsAvailable: true,
+      recordingInProgress: true,
+      uiControlConfig: {
+        isEndTaskEnabled: false,
+        isEndConsultEnabled: true,
+        channelType: TASK_CHANNEL_TYPE.VOICE,
+        isRecordingEnabled: true,
+        agentId: taskData.agentId,
+        voiceVariant,
+      },
+      uiControls: getDefaultUIControls(),
+    };
+  }
+
+  it('shows main end for connected WebRTC call-control tasks even when end task is disabled', () => {
+    const context = createConnectedContext('webrtc');
+    const uiControls = computeUIControls(TaskState.CONNECTED, context, context.taskData);
+
+    expect(uiControls.main.end).toEqual({isVisible: true, isEnabled: true});
+  });
+
+  it('keeps main end hidden for non-WebRTC voice tasks when end task is disabled', () => {
+    const context = createConnectedContext('pstn');
+    const uiControls = computeUIControls(TaskState.CONNECTED, context, context.taskData);
+
+    expect(uiControls.main.end).toEqual({isVisible: false, isEnabled: false});
+  });
+});
+
 describe('uiControlsComputer conference controls', () => {
   function createConferenceTaskData(participantCount: number) {
     const participants: Record<string, any> = {