fix(multi-party-conference): implement-multi-party-conference-feature

docs/samples/contact-center/index.html

@@ -184,6 +184,16 @@ <h2 class="collapsible">
             <button onclick="answer()" disabled="" id="answer" class="btn--green">Answer</button>
             <button onclick="decline()" disabled="" id="decline" class="btn--red">Decline</button>
           </div>
+          <div id="participant-list"></div>
+
+          <!-- MPC: Allow participants to interact checkbox for testing -->
+          <div id="allow-interact" style="margin-top:10px;padding:8px;border:1px solid #ddd;background:#f0f8ff;display:none;">
+            <label>
+              <input type="checkbox" id="allow-participants-interact" checked>
+              🔄 Allow participants to continue interacting with each other
+            </label>
+            <br/><small style="color:#666;">📝 MPC Testing: Simulates the consultation interaction behavior</small>
+          </div>
         </fieldset>
         <fieldset>
           <legend>Remote Audio</legend>

packages/@webex/contact-center/src/cc.ts

@@ -784,7 +784,7 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
         throw error;
       }
 
-      const loginResponse = this.services.agent.stationLogin({
+      const loginResponse = await this.services.agent.stationLogin({
         data: {
           dialNumber:
             data.loginOption === LoginOption.BROWSER ? this.agentConfig.agentId : data.dialNumber,

packages/@webex/contact-center/src/services/task/TaskManager.ts

@@ -12,6 +12,12 @@ import LoggerProxy from '../../logger-proxy';
 import Task from '.';
 import MetricsManager from '../../metrics/MetricsManager';
 import {METRIC_EVENT_NAMES} from '../../metrics/constants';
+import {
+  checkParticipantNotInInteraction,
+  getIsConferenceInProgress,
+  isParticipantInMainInteraction,
+  isPrimary,
+} from './TaskUtils';
 
 /** @internal */
 export default class TaskManager extends EventEmitter {
@@ -128,8 +134,7 @@ export default class TaskManager extends EventEmitter {
                 {
                   ...payload.data,
                   wrapUpRequired:
-                    payload.data.interaction?.participants?.[payload.data.agentId]?.isWrapUp ||
-                    false,
+                    payload.data.interaction?.participants?.[this.agentId]?.isWrapUp || false,
                 },
                 this.wrapupData,
                 this.agentId
@@ -358,18 +363,55 @@ export default class TaskManager extends EventEmitter {
           case CC_EVENTS.AGENT_CONSULT_CONFERENCE_ENDED:
             // Conference ended - update task state and emit event
             task = this.updateTaskData(task, payload.data);
-            task.emit(TASK_EVENTS.TASK_CONFERENCE_ENDED, task);
+            if (
+              !task ||
+              isPrimary(task, this.agentId) ||
+              isParticipantInMainInteraction(task, this.agentId)
+            ) {
+              LoggerProxy.log('Primary or main interaction participant leaving conference');
+            } else {
+              this.removeTaskFromCollection(task);
+            }
+            task?.emit(TASK_EVENTS.TASK_CONFERENCE_ENDED, task);
             break;
-          case CC_EVENTS.PARTICIPANT_JOINED_CONFERENCE:
+          case CC_EVENTS.PARTICIPANT_JOINED_CONFERENCE: {
             // Participant joined conference - update task state with participant information and emit event
-            task = this.updateTaskData(task, payload.data);
+            // Pre-calculate isConferenceInProgress with updated data to avoid double update
+            const simulatedTaskForJoin = {
+              ...task,
+              data: {...task.data, ...payload.data},
+            };
+            task = this.updateTaskData(task, {
+              ...payload.data,
+              isConferenceInProgress: getIsConferenceInProgress(simulatedTaskForJoin),
+            });
             task.emit(TASK_EVENTS.TASK_PARTICIPANT_JOINED, task);
             break;
-          case CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE:
+          }
+          case CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE: {
             // Conference ended - update task state and emit event
-            task = this.updateTaskData(task, payload.data);
+            // Pre-calculate isConferenceInProgress with updated data to avoid double update
+            const simulatedTaskForLeft = {
+              ...task,
+              data: {...task.data, ...payload.data},
+            };
+            task = this.updateTaskData(task, {
+              ...payload.data,
+              isConferenceInProgress: getIsConferenceInProgress(simulatedTaskForLeft),
+            });
+            if (checkParticipantNotInInteraction(task, this.agentId)) {
+              if (
+                isParticipantInMainInteraction(task, this.agentId) ||
+                isPrimary(task, this.agentId)
+              ) {
+                LoggerProxy.log('Primary or main interaction participant leaving conference');
+              } else {
+                this.removeTaskFromCollection(task);
+              }
+            }
             task.emit(TASK_EVENTS.TASK_PARTICIPANT_LEFT, task);
             break;
+          }
           case CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE_FAILED:
             // Conference exit failed - update task state and emit failure event
             task = this.updateTaskData(task, payload.data);

packages/@webex/contact-center/src/services/task/TaskUtils.ts

@@ -0,0 +1,94 @@
+/* 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: any) => 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)
+  );
+};
+
+/**
+ * Gets the participant status for a given agent in a task
+ * @param task - The task to check
+ * @param agentId - The agent ID to get status for
+ * @returns Object containing various status flags for the agent
+ */
+export const getParticipantStatus = (task: ITask, agentId: string) => ({
+  isPrimary: isPrimary(task, agentId),
+  isInMainInteraction: isParticipantInMainInteraction(task, agentId),
+  isNotInInteraction: checkParticipantNotInInteraction(task, agentId),
+  isOwner: task?.data?.interaction?.owner === agentId,
+  hasLeft: task?.data?.interaction?.participants?.[agentId]?.hasLeft || false,
+});
+
+/**
+ * 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;
+};

packages/@webex/contact-center/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

packages/@webex/contact-center/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;
     }
-  } */
+  }
 }