@webex/contact-center 3.9.0-next.25 → 3.9.0-next.26

package/src/services/task/TaskUtils.ts

@@ -0,0 +1,81 @@
+/* eslint-disable import/prefer-default-export */
+import {ITask} from './types';
+
+/**
+ * Determines if the given agent is the primary agent (owner) of the task
+ * @param task - The task to check
+ * @param agentId - The agent ID to check for primary status
+ * @returns true if the agent is the primary agent, false otherwise
+ */
+export const isPrimary = (task: ITask, agentId: string): boolean => {
+  if (!task.data?.interaction?.owner) {
+    // Fall back to checking data.agentId when owner is not set
+    return task.data.agentId === agentId;
+  }
+
+  return task.data.interaction.owner === agentId;
+};
+
+/**
+ * Checks if the given agent is a participant in the main interaction (mainCall)
+ * @param task - The task to check
+ * @param agentId - The agent ID to check for participation
+ * @returns true if the agent is a participant in the main interaction, false otherwise
+ */
+export const isParticipantInMainInteraction = (task: ITask, agentId: string): boolean => {
+  if (!task?.data?.interaction?.media) {
+    return false;
+  }
+
+  return Object.values(task.data.interaction.media).some(
+    (mediaObj) =>
+      mediaObj && mediaObj.mType === 'mainCall' && mediaObj.participants?.includes(agentId)
+  );
+};
+
+/**
+ * Checks if the given agent is not in the interaction or has left the interaction
+ * @param task - The task to check
+ * @param agentId - The agent ID to check
+ * @returns true if the agent is not in the interaction or has left, false otherwise
+ */
+export const checkParticipantNotInInteraction = (task: ITask, agentId: string): boolean => {
+  if (!task?.data?.interaction?.participants) {
+    return true;
+  }
+  const {data} = task;
+
+  return (
+    !(agentId in data.interaction.participants) ||
+    (agentId in data.interaction.participants && data.interaction.participants[agentId].hasLeft)
+  );
+};
+
+/**
+ * Determines if a conference is currently in progress based on the number of active agent participants
+ * @param task - The task to check for conference status
+ * @returns true if there are 2 or more active agent participants in the main call, false otherwise
+ */
+export const getIsConferenceInProgress = (task: ITask): boolean => {
+  const mediaMainCall = task?.data?.interaction?.media?.[task?.data?.interactionId];
+  const participantsInMainCall = new Set(mediaMainCall?.participants);
+  const participants = task?.data?.interaction?.participants;
+
+  const agentParticipants = new Set();
+  if (participantsInMainCall.size > 0) {
+    participantsInMainCall.forEach((participantId: string) => {
+      const participant = participants?.[participantId];
+      if (
+        participant &&
+        participant.pType !== 'Customer' &&
+        participant.pType !== 'Supervisor' &&
+        !participant.hasLeft &&
+        participant.pType !== 'VVA'
+      ) {
+        agentParticipants.add(participantId);
+      }
+    });
+  }
+
+  return agentParticipants.size >= 2;
+};

package/src/services/task/constants.ts

@@ -23,6 +23,25 @@ export const CONFERENCE_TRANSFER = '/conference/transfer';
 export const TASK_MANAGER_FILE = 'taskManager';
 export const TASK_FILE = 'task';
 
+/**
+ * Task data field names that should be preserved during reconciliation
+ * These fields are retained even if not present in new data during updates
+ */
+export const PRESERVED_TASK_DATA_FIELDS = {
+  /** Indicates if the task is in consultation state */
+  IS_CONSULTED: 'isConsulted',
+  /** Indicates if wrap-up is required for this task */
+  WRAP_UP_REQUIRED: 'wrapUpRequired',
+  /** Indicates if a conference is currently in progress (2+ active agents) */
+  IS_CONFERENCE_IN_PROGRESS: 'isConferenceInProgress',
+};
+
+/**
+ * Array of task data field names that should not be deleted during reconciliation
+ * Used by reconcileData method to preserve important task state fields
+ */
+export const KEYS_TO_NOT_DELETE: string[] = Object.values(PRESERVED_TASK_DATA_FIELDS);
+
 // METHOD NAMES
 export const METHODS = {
   // Task class methods

package/src/services/task/index.ts

@@ -10,7 +10,7 @@ import {
 import {Failure} from '../core/GlobalTypes';
 import {LoginOption} from '../../types';
 import {TASK_FILE} from '../../constants';
-import {METHODS} from './constants';
+import {METHODS, KEYS_TO_NOT_DELETE} from './constants';
 import routingContact from './contact';
 import LoggerProxy from '../../logger-proxy';
 import {
@@ -281,9 +281,24 @@ export default class Task extends EventEmitter implements ITask {
    * @private
    */
   private reconcileData(oldData: TaskData, newData: TaskData): TaskData {
+    // Remove keys from oldData that are not in newData
+    Object.keys(oldData).forEach((key) => {
+      if (!(key in newData) && !KEYS_TO_NOT_DELETE.includes(key as string)) {
+        delete oldData[key];
+      }
+    });
+
+    // Merge or update keys from newData
     Object.keys(newData).forEach((key) => {
-      if (newData[key] && typeof newData[key] === 'object' && !Array.isArray(newData[key])) {
-        oldData[key] = this.reconcileData({...oldData[key]}, newData[key]);
+      if (
+        newData[key] &&
+        typeof newData[key] === 'object' &&
+        !Array.isArray(newData[key]) &&
+        oldData[key] &&
+        typeof oldData[key] === 'object' &&
+        !Array.isArray(oldData[key])
+      ) {
+        this.reconcileData(oldData[key], newData[key]);
       } else {
         oldData[key] = newData[key];
       }
@@ -1684,9 +1699,6 @@ export default class Task extends EventEmitter implements ITask {
     }
   }
 
-  // TODO: Uncomment this method in future PR for Multi-Party Conference support (>3 participants)
-  // Conference transfer will be supported when implementing enhanced multi-party conference functionality
-  /*
   /**
    * Transfers the current conference to another agent
    *
@@ -1707,7 +1719,7 @@ export default class Task extends EventEmitter implements ITask {
    * }
    * ```
    */
-  /* public async transferConference(): Promise<TaskResponse> {
+  public async transferConference(): Promise<TaskResponse> {
     try {
       LoggerProxy.info(`Transferring conference`, {
         module: TASK_FILE,
@@ -1771,5 +1783,5 @@ export default class Task extends EventEmitter implements ITask {
 
       throw err;
     }
-  } */
+  }
 }

package/src/services/task/types.ts

@@ -733,6 +733,8 @@ export type TaskData = {
   isConsulted?: boolean;
   /** Indicates if the task is in conference state */
   isConferencing: boolean;
+  /** Indicates if a conference is currently in progress (2+ active agents) */
+  isConferenceInProgress?: boolean;
   /** Identifier of agent who last updated the task */
   updatedBy?: string;
   /** Type of destination for transfer/consult */
@@ -1135,16 +1137,16 @@ export interface ITask extends EventEmitter {
   autoWrapup?: AutoWrapup;
 
   /**
-   * cancels the auto-wrapup timer for the task
-   * This method stops the auto-wrapup process if it is currently active
+   * Cancels the auto-wrapup timer for the task.
+   * This method stops the auto-wrapup process if it is currently active.
    * Note: This is supported only in single session mode. Not supported in multi-session mode.
    * @returns void
    */
   cancelAutoWrapupTimer(): void;
 
   /**
-   * Deregisters all web call event listeners
-   * Used when cleaning up task resources
+   * Deregisters all web call event listeners.
+   * Used when cleaning up task resources.
    * @ignore
    */
   unregisterWebCallListeners(): void;
@@ -1164,7 +1166,7 @@ export interface ITask extends EventEmitter {
    * @returns Promise<TaskResponse>
    * @example
    * ```typescript
-   * task.accept();
+   * await task.accept();
    * ```
    */
   accept(): Promise<TaskResponse>;
@@ -1174,48 +1176,48 @@ export interface ITask extends EventEmitter {
    * @returns Promise<TaskResponse>
    * @example
    * ```typescript
-   * task.decline();
+   * await task.decline();
    * ```
    */
   decline(): Promise<TaskResponse>;
 
   /**
-   * Places the current task on hold
+   * Places the current task on hold.
    * @returns Promise<TaskResponse>
    * @example
    * ```typescript
-   * task.hold();
+   * await task.hold();
    * ```
    */
   hold(): Promise<TaskResponse>;
 
   /**
-   * Resumes a task that was previously on hold
+   * Resumes a task that was previously on hold.
    * @returns Promise<TaskResponse>
    * @example
    * ```typescript
-   * task.resume();
+   * await task.resume();
    * ```
    */
   resume(): Promise<TaskResponse>;
 
   /**
-   * Ends/terminates the current task
+   * Ends/terminates the current task.
    * @returns Promise<TaskResponse>
    * @example
    * ```typescript
-   * task.end();
+   * await task.end();
    * ```
    */
   end(): Promise<TaskResponse>;
 
   /**
-   * Initiates wrap-up process for the task with specified details
+   * Initiates wrap-up process for the task with specified details.
    * @param wrapupPayload - Wrap-up details including reason and auxiliary code
    * @returns Promise<TaskResponse>
    * @example
    * ```typescript
-   * task.wrapup({
+   * await task.wrapup({
    *   wrapUpReason: "Customer issue resolved",
    *   auxCodeId: "RESOLVED"
    * });
@@ -1224,25 +1226,109 @@ export interface ITask extends EventEmitter {
   wrapup(wrapupPayload: WrapupPayLoad): Promise<TaskResponse>;
 
   /**
-   * Pauses the recording for current task
+   * Pauses the recording for current task.
    * @returns Promise<TaskResponse>
    * @example
    * ```typescript
-   * task.pauseRecording();
+   * await task.pauseRecording();
    * ```
    */
   pauseRecording(): Promise<TaskResponse>;
 
   /**
-   * Resumes a previously paused recording
+   * Resumes a previously paused recording.
    * @param resumeRecordingPayload - Parameters for resuming the recording
    * @returns Promise<TaskResponse>
    * @example
    * ```typescript
-   * task.resumeRecording({
+   * await task.resumeRecording({
    *   autoResumed: false
    * });
    * ```
    */
   resumeRecording(resumeRecordingPayload: ResumeRecordingPayload): Promise<TaskResponse>;
+
+  /**
+   * Initiates a consultation with another agent or queue.
+   * @param consultPayload - Consultation details including destination and type
+   * @returns Promise<TaskResponse>
+   * @example
+   * ```typescript
+   * await task.consult({ to: "agentId", destinationType: "agent" });
+   * ```
+   */
+  consult(consultPayload: ConsultPayload): Promise<TaskResponse>;
+
+  /**
+   * Ends an ongoing consultation.
+   * @param consultEndPayload - Details for ending the consultation
+   * @returns Promise<TaskResponse>
+   * @example
+   * ```typescript
+   * await task.endConsult({ isConsult: true, taskId: "taskId" });
+   * ```
+   */
+  endConsult(consultEndPayload: ConsultEndPayload): Promise<TaskResponse>;
+
+  /**
+   * Transfers the task to another agent or queue.
+   * @param transferPayload - Transfer details including destination and type
+   * @returns Promise<TaskResponse>
+   * @example
+   * ```typescript
+   * await task.transfer({ to: "queueId", destinationType: "queue" });
+   * ```
+   */
+  transfer(transferPayload: TransferPayLoad): Promise<TaskResponse>;
+
+  /**
+   * Transfers the task after consultation.
+   * @param consultTransferPayload - Details for consult transfer (optional)
+   * @returns Promise<TaskResponse>
+   * @example
+   * ```typescript
+   * await task.consultTransfer({ to: "agentId", destinationType: "agent" });
+   * ```
+   */
+  consultTransfer(consultTransferPayload?: ConsultTransferPayLoad): Promise<TaskResponse>;
+
+  /**
+   * Initiates a consult conference (merge consult call with main call).
+   * @returns Promise<TaskResponse>
+   * @example
+   * ```typescript
+   * await task.consultConference();
+   * ```
+   */
+  consultConference(): Promise<TaskResponse>;
+
+  /**
+   * Exits from an ongoing conference.
+   * @returns Promise<TaskResponse>
+   * @example
+   * ```typescript
+   * await task.exitConference();
+   * ```
+   */
+  exitConference(): Promise<TaskResponse>;
+
+  /**
+   * Transfers the conference to another participant.
+   * @returns Promise<TaskResponse>
+   * @example
+   * ```typescript
+   * await task.transferConference();
+   * ```
+   */
+  transferConference(): Promise<TaskResponse>;
+
+  /**
+   * Toggles mute/unmute for the local audio stream during a WebRTC task.
+   * @returns Promise<void>
+   * @example
+   * ```typescript
+   * await task.toggleMute();
+   * ```
+   */
+  toggleMute(): Promise<void>;
 }

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

@@ -1357,8 +1357,12 @@ describe('TaskManager', () => {
 
   describe('Conference event handling', () => {
     let task;
+    const agentId = '723a8ffb-a26e-496d-b14a-ff44fb83b64f';
     
     beforeEach(() => {
+      // Set the agentId on taskManager before tests run
+      taskManager.setAgentId(agentId);
+      
       task = {
         data: { interactionId: taskId },
         emit: jest.fn(),
@@ -1434,19 +1438,260 @@ describe('TaskManager', () => {
       // No specific task event emission for participant joined - just data update
     });
 
-    it('should handle PARTICIPANT_LEFT_CONFERENCE event', () => {
-      const payload = {
-        data: {
-          type: CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE,
-          interactionId: taskId,
-          isConferencing: false,
-        },
-      };
+    describe('PARTICIPANT_LEFT_CONFERENCE event handling', () => {
+      it('should emit TASK_PARTICIPANT_LEFT event when participant leaves conference', () => {
+        const payload = {
+          data: {
+            type: CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE,
+            interactionId: taskId,
+            interaction: {
+              participants: {
+                [agentId]: {
+                  hasLeft: false,
+                },
+              },
+            },
+          },
+        };
 
-      webSocketManagerMock.emit('message', JSON.stringify(payload));
+        webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+        expect(task.emit).toHaveBeenCalledWith(TASK_EVENTS.TASK_PARTICIPANT_LEFT, task);
+      });
+
+      it('should NOT remove task when agent is still in interaction', () => {
+        const payload = {
+          data: {
+            type: CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE,
+            interactionId: taskId,
+            interaction: {
+              participants: {
+                [agentId]: {
+                  hasLeft: false,
+                },
+              },
+            },
+          },
+        };
+
+        webSocketManagerMock.emit('message', JSON.stringify(payload));
 
-      expect(task.data.isConferencing).toBe(false);
-      expect(task.emit).toHaveBeenCalledWith(TASK_EVENTS.TASK_PARTICIPANT_LEFT, task);
+        // Task should still exist in collection
+        expect(taskManager.getTask(taskId)).toBeDefined();
+        expect(task.emit).toHaveBeenCalledWith(TASK_EVENTS.TASK_PARTICIPANT_LEFT, task);
+      });
+
+      it('should NOT remove task when agent left but is in main interaction', () => {
+        const payload = {
+          data: {
+            type: CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE,
+            interactionId: taskId,
+            interaction: {
+              participants: {
+                [agentId]: {
+                  hasLeft: true,
+                },
+              },
+              media: {
+                [taskId]: {
+                  mType: 'mainCall',
+                  participants: [agentId],
+                },
+              },
+            },
+          },
+        };
+
+        const removeTaskSpy = jest.spyOn(taskManager, 'removeTaskFromCollection');
+
+        webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+        // Task should still exist - not removed
+        expect(removeTaskSpy).not.toHaveBeenCalled();
+        expect(taskManager.getTask(taskId)).toBeDefined();
+        expect(task.emit).toHaveBeenCalledWith(TASK_EVENTS.TASK_PARTICIPANT_LEFT, task);
+      });
+
+      it('should NOT remove task when agent left but is primary (owner)', () => {
+        const payload = {
+          data: {
+            type: CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE,
+            interactionId: taskId,
+            interaction: {
+              participants: {
+                [agentId]: {
+                  hasLeft: true,
+                },
+              },
+              owner: agentId,
+              media: {
+                [taskId]: {
+                  mType: 'consultCall',
+                  participants: ['other-agent'],
+                },
+              },
+            },
+          },
+        };
+
+        const removeTaskSpy = jest.spyOn(taskManager, 'removeTaskFromCollection');
+
+        webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+        // Task should still exist - not removed because agent is primary
+        expect(removeTaskSpy).not.toHaveBeenCalled();
+        expect(taskManager.getTask(taskId)).toBeDefined();
+        expect(task.emit).toHaveBeenCalledWith(TASK_EVENTS.TASK_PARTICIPANT_LEFT, task);
+      });
+
+      it('should remove task when agent left and is NOT in main interaction and is NOT primary', () => {
+        const payload = {
+          data: {
+            type: CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE,
+            interactionId: taskId,
+            interaction: {
+              participants: {
+                [agentId]: {
+                  hasLeft: true,
+                },
+              },
+              owner: 'another-agent-id',
+              media: {
+                [taskId]: {
+                  mType: 'mainCall',
+                  participants: ['another-agent-id'],
+                },
+              },
+            },
+          },
+        };
+
+        const removeTaskSpy = jest.spyOn(taskManager, 'removeTaskFromCollection');
+
+        webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+        // Task should be removed
+        expect(removeTaskSpy).toHaveBeenCalled();
+        expect(task.emit).toHaveBeenCalledWith(TASK_EVENTS.TASK_PARTICIPANT_LEFT, task);
+      });
+
+      it('should remove task when agent is not in participants list', () => {
+        const payload = {
+          data: {
+            type: CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE,
+            interactionId: taskId,
+            interaction: {
+              participants: {
+                'other-agent-id': {
+                  hasLeft: false,
+                },
+              },
+              owner: 'another-agent-id',
+            },
+          },
+        };
+
+        const removeTaskSpy = jest.spyOn(taskManager, 'removeTaskFromCollection');
+
+        webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+        // Task should be removed because agent is not in participants
+        expect(removeTaskSpy).toHaveBeenCalled();
+        expect(task.emit).toHaveBeenCalledWith(TASK_EVENTS.TASK_PARTICIPANT_LEFT, task);
+      });
+
+      it('should update isConferenceInProgress based on remaining active agents', () => {
+        const payload = {
+          data: {
+            type: CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE,
+            interactionId: taskId,
+            interaction: {
+              participants: {
+                [agentId]: {
+                  hasLeft: false,
+                  pType: 'Agent',
+                },
+                'agent-2': {
+                  hasLeft: false,
+                  pType: 'Agent',
+                },
+                'customer-1': {
+                  hasLeft: false,
+                  pType: 'Customer',
+                },
+              },
+              media: {
+                [taskId]: {
+                  mType: 'mainCall',
+                  participants: [agentId, 'agent-2', 'customer-1'],
+                },
+              },
+            },
+          },
+        };
+
+        webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+        // isConferenceInProgress should be true (2 active agents)
+        expect(task.data.isConferenceInProgress).toBe(true);
+        expect(task.emit).toHaveBeenCalledWith(TASK_EVENTS.TASK_PARTICIPANT_LEFT, task);
+      });
+
+      it('should set isConferenceInProgress to false when only one agent remains', () => {
+        const payload = {
+          data: {
+            type: CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE,
+            interactionId: taskId,
+            interaction: {
+              participants: {
+                [agentId]: {
+                  hasLeft: false,
+                  pType: 'Agent',
+                },
+                'agent-2': {
+                  hasLeft: true,
+                  pType: 'Agent',
+                },
+                'customer-1': {
+                  hasLeft: false,
+                  pType: 'Customer',
+                },
+              },
+              media: {
+                [taskId]: {
+                  mType: 'mainCall',
+                  participants: [agentId, 'customer-1'],
+                },
+              },
+            },
+          },
+        };
+
+        webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+        // isConferenceInProgress should be false (only 1 active agent)
+        expect(task.data.isConferenceInProgress).toBe(false);
+        expect(task.emit).toHaveBeenCalledWith(TASK_EVENTS.TASK_PARTICIPANT_LEFT, task);
+      });
+
+      it('should handle participant left when no participants data exists', () => {
+        const payload = {
+          data: {
+            type: CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE,
+            interactionId: taskId,
+            interaction: {},
+          },
+        };
+
+        const removeTaskSpy = jest.spyOn(taskManager, 'removeTaskFromCollection');
+
+        webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+        // When no participants data exists, checkParticipantNotInInteraction returns true
+        // Since agent won't be in main interaction either, task should be removed
+        expect(removeTaskSpy).toHaveBeenCalled();
+        expect(task.emit).toHaveBeenCalledWith(TASK_EVENTS.TASK_PARTICIPANT_LEFT, task);
+      });
     });
 
     it('should handle PARTICIPANT_LEFT_CONFERENCE_FAILED event', () => {