@webex/contact-center 3.9.0-next.9 → 3.10.0-multi-llms.1

package/src/services/core/Utils.ts

@@ -9,6 +9,7 @@ import {
   CONSULT_TRANSFER_DESTINATION_TYPE,
   Interaction,
 } from '../task/types';
+import {PARTICIPANT_TYPES, STATE_CONSULT} from './constants';
 
 /**
  * Extracts common error details from a Webex request payload.
@@ -216,59 +217,118 @@ export const createErrDetailsObject = (errObj: WebexRequestPayload) => {
 };
 
 /**
- * Derives the consult transfer destination type based on the provided task data.
+ * Gets the consulted agent ID from the media object by finding the agent
+ * in the consult media participants (excluding the current agent).
  *
- * Logic parity with desktop behavior:
- * - If agent action is dialing a number (DN/EPDN/ENTRYPOINT):
- *   - ENTRYPOINT/EPDN map to ENTRYPOINT
- *   - DN maps to DIALNUMBER
- * - Otherwise defaults to AGENT
+ * @param media - The media object from the interaction
+ * @param agentId - The current agent's ID to exclude from the search
+ * @returns The consulted agent ID, or empty string if none found
+ */
+export const getConsultedAgentId = (media: Interaction['media'], agentId: string): string => {
+  let consultParticipants: string[] = [];
+  let consultedParticipantId = '';
+
+  Object.keys(media).forEach((key) => {
+    if (media[key].mType === STATE_CONSULT) {
+      consultParticipants = media[key].participants;
+    }
+  });
+
+  if (consultParticipants.includes(agentId)) {
+    const id = consultParticipants.find((participant) => participant !== agentId);
+    consultedParticipantId = id || consultedParticipantId;
+  }
+
+  return consultedParticipantId;
+};
+
+/**
+ * Gets the destination agent ID for CBT (Capacity Based Team) scenarios.
+ * CBT refers to teams created in Control Hub with capacity-based routing
+ * (as opposed to agent-based routing). This handles cases where the consulted
+ * participant is not directly in participants but can be found by matching
+ * the dial number (dn).
  *
- * @param taskData - The task data used to infer the agent action and destination type
- * @returns The normalized destination type to be used for consult transfer
+ * @param interaction - The interaction object
+ * @param consultingAgent - The consulting agent identifier
+ * @returns The destination agent ID for CBT scenarios, or empty string if none found
  */
+export const getDestAgentIdForCBT = (interaction: Interaction, consultingAgent: string): string => {
+  const participants = interaction.participants;
+  let destAgentIdForCBT = '';
+
+  // Check if this is a CBT scenario (consultingAgent exists but not directly in participants)
+  if (consultingAgent && !participants[consultingAgent]) {
+    const foundEntry = Object.entries(participants).find(
+      ([, participant]: [string, Interaction['participants'][string]]) => {
+        return (
+          participant.pType.toLowerCase() === PARTICIPANT_TYPES.DN &&
+          participant.type === PARTICIPANT_TYPES.AGENT &&
+          participant.dn === consultingAgent
+        );
+      }
+    );
+
+    if (foundEntry) {
+      destAgentIdForCBT = foundEntry[0];
+    }
+  }
+
+  return destAgentIdForCBT;
+};
+
 /**
- * Checks if a participant type represents a non-customer participant.
- * Non-customer participants include agents, dial numbers, entry point dial numbers,
- * and entry points.
+ * Calculates the destination agent ID for consult operations.
+ *
+ * @param interaction - The interaction object
+ * @param agentId - The current agent's ID
+ * @returns The destination agent ID
  */
-const isNonCustomerParticipant = (participantType: string): boolean => {
-  return (
-    participantType === 'Agent' ||
-    participantType === 'DN' ||
-    participantType === 'EpDn' ||
-    participantType === 'entryPoint'
-  );
+export const calculateDestAgentId = (interaction: Interaction, agentId: string): string => {
+  const consultingAgent = getConsultedAgentId(interaction.media, agentId);
+
+  // Check if this is a CBT (Capacity Based Team) scenario
+  // If not CBT, the function will return empty string and we'll use the normal flow
+  const destAgentIdCBT = getDestAgentIdForCBT(interaction, consultingAgent);
+  if (destAgentIdCBT) {
+    return destAgentIdCBT;
+  }
+
+  return interaction.participants[consultingAgent]?.type === PARTICIPANT_TYPES.EP_DN
+    ? interaction.participants[consultingAgent]?.epId
+    : interaction.participants[consultingAgent]?.id;
 };
 
 /**
- * Gets the destination agent ID from participants data by finding the first
- * non-customer participant that is not the current agent and is not in wrap-up state.
+ * Calculates the destination agent ID for fetching destination type.
  *
- * @param participants - The participants data from the interaction
- * @param agentId - The current agent's ID to exclude from the search
- * @returns The destination agent ID, or empty string if none found
+ * @param interaction - The interaction object
+ * @param agentId - The current agent's ID
+ * @returns The destination agent ID for determining destination type
  */
-export const getDestinationAgentId = (
-  participants: Interaction['participants'],
-  agentId: string
-): string => {
-  let id = '';
-
-  if (participants) {
-    Object.keys(participants).forEach((participant) => {
-      const participantData = participants[participant];
-      if (
-        isNonCustomerParticipant(participantData.type) &&
-        participantData.id !== agentId &&
-        !participantData.isWrapUp
-      ) {
-        id = participantData.id;
-      }
-    });
+export const calculateDestType = (interaction: Interaction, agentId: string): string => {
+  const consultingAgent = getConsultedAgentId(interaction.media, agentId);
+
+  // Check if this is a CBT (Capacity Based Team) scenario, otherwise use consultingAgent
+  const destAgentIdCBT = getDestAgentIdForCBT(interaction, consultingAgent);
+  const destinationaegntId = destAgentIdCBT || consultingAgent;
+  const destAgentType = destinationaegntId
+    ? interaction.participants[destinationaegntId]?.pType
+    : undefined;
+  if (destAgentType) {
+    if (destAgentType === 'DN') {
+      return CONSULT_TRANSFER_DESTINATION_TYPE.DIALNUMBER;
+    }
+    if (destAgentType === 'EP-DN') {
+      return CONSULT_TRANSFER_DESTINATION_TYPE.ENTRYPOINT;
+    }
+    // Keep the existing destinationType if it's something else (like "agent" or "Agent")
+    // Convert "Agent" to lowercase for consistency
+
+    return destAgentType.toLowerCase();
   }
 
-  return id;
+  return CONSULT_TRANSFER_DESTINATION_TYPE.AGENT;
 };
 
 export const deriveConsultTransferDestinationType = (

package/src/services/core/constants.ts

@@ -64,6 +64,22 @@ export const CONNECTIVITY_CHECK_INTERVAL = 5000;
  */
 export const CLOSE_SOCKET_TIMEOUT = 16000;
 
+/**
+ * Constants for participant types, destination types, and interaction states
+ * @ignore
+ */
+export const PARTICIPANT_TYPES = {
+  /** Participant type for Entry Point Dial Number */
+  EP_DN: 'EpDn',
+  /** Participant type for dial number */
+  DN: 'dn',
+  /** Participant type for Agent */
+  AGENT: 'Agent',
+};
+
+/** Interaction state for consultation */
+export const STATE_CONSULT = 'consult';
+
 // Method names for core services
 export const METHODS = {
   // WebexRequest methods

package/src/services/task/TaskManager.ts

@@ -12,6 +12,13 @@ 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,
+  isSecondaryEpDnAgent,
+} from './TaskUtils';
 
 /** @internal */
 export default class TaskManager extends EventEmitter {
@@ -28,6 +35,7 @@ export default class TaskManager extends EventEmitter {
   private metricsManager: MetricsManager;
   private static taskManager;
   private wrapupData: WrapupData;
+  private agentId: string;
   /**
    * @param contact - Routing Contact layer. Talks to AQMReq layer to convert events to promises
    * @param webCallingService - Webrtc Service Layer
@@ -52,6 +60,19 @@ export default class TaskManager extends EventEmitter {
     this.wrapupData = wrapupData;
   }
 
+  public setAgentId(agentId: string) {
+    this.agentId = agentId;
+  }
+
+  /**
+   * Gets the current agent ID
+   * @returns {string} The agent ID set for this task manager instance
+   * @public
+   */
+  public getAgentId(): string {
+    return this.agentId;
+  }
+
   private handleIncomingWebCall = (call: ICall) => {
     const currentTask = Object.values(this.taskCollection).find(
       (task) => task.data.interaction.mediaType === 'telephony'
@@ -108,16 +129,18 @@ export default class TaskManager extends EventEmitter {
                 method: METHODS.REGISTER_TASK_LISTENERS,
                 interactionId: payload.data.interactionId,
               });
+
               task = new Task(
                 this.contact,
                 this.webCallingService,
                 {
                   ...payload.data,
                   wrapUpRequired:
-                    payload.data.interaction?.participants?.[payload.data.agentId]?.isWrapUp ||
-                    false,
+                    payload.data.interaction?.participants?.[this.agentId]?.isWrapUp || false,
+                  isConferenceInProgress: getIsConferenceInProgress(payload.data),
                 },
-                this.wrapupData
+                this.wrapupData,
+                this.agentId
               );
               this.taskCollection[payload.data.interactionId] = task;
               // Condition 1: The state is=new i.e it is a incoming task
@@ -145,6 +168,7 @@ export default class TaskManager extends EventEmitter {
               }
             }
             break;
+
           case CC_EVENTS.AGENT_CONTACT_RESERVED:
             task = new Task(
               this.contact,
@@ -153,8 +177,9 @@ export default class TaskManager extends EventEmitter {
                 ...payload.data,
                 isConsulted: false,
               },
-              this.wrapupData
-            ); // Ensure isConsulted prop exists
+              this.wrapupData,
+              this.agentId
+            );
             this.taskCollection[payload.data.interactionId] = task;
             if (
               this.webCallingService.loginOption !== LoginOption.BROWSER ||
@@ -223,13 +248,22 @@ export default class TaskManager extends EventEmitter {
             break;
           }
           case CC_EVENTS.CONTACT_ENDED:
+            // Update task data
             task = this.updateTaskData(task, {
               ...payload.data,
-              wrapUpRequired: payload.data.interaction.state !== 'new',
+              wrapUpRequired:
+                payload.data.interaction.state !== 'new' &&
+                !isSecondaryEpDnAgent(payload.data.interaction),
             });
+
+            // Handle cleanup based on whether task should be deleted
             this.handleTaskCleanup(task);
-            task.emit(TASK_EVENTS.TASK_END, task);
+
+            task?.emit(TASK_EVENTS.TASK_END, task);
 
+            break;
+          case CC_EVENTS.CONTACT_MERGED:
+            task = this.handleContactMerged(task, payload.data);
             break;
           case CC_EVENTS.AGENT_CONTACT_HELD:
             // As soon as the main interaction is held, we need to emit TASK_HOLD
@@ -324,6 +358,89 @@ export default class TaskManager extends EventEmitter {
             task = this.updateTaskData(task, payload.data);
             task.emit(TASK_EVENTS.TASK_RECORDING_RESUME_FAILED, task);
             break;
+          case CC_EVENTS.AGENT_CONSULT_CONFERENCING:
+            // Conference is being established - update task state and emit establishing event
+            task = this.updateTaskData(task, payload.data);
+            task.emit(TASK_EVENTS.TASK_CONFERENCE_ESTABLISHING, task);
+            break;
+          case CC_EVENTS.AGENT_CONSULT_CONFERENCED:
+            // Conference started successfully - update task state and emit event
+            task = this.updateTaskData(task, payload.data);
+            task.emit(TASK_EVENTS.TASK_CONFERENCE_STARTED, task);
+            break;
+          case CC_EVENTS.AGENT_CONSULT_CONFERENCE_FAILED:
+            // Conference failed - update task state and emit failure event
+            task = this.updateTaskData(task, payload.data);
+            task.emit(TASK_EVENTS.TASK_CONFERENCE_FAILED, task);
+            break;
+          case CC_EVENTS.AGENT_CONSULT_CONFERENCE_ENDED:
+            // Conference ended - update task state and emit event
+            task = this.updateTaskData(task, payload.data);
+            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: {
+            task = this.updateTaskData(task, {
+              ...payload.data,
+              isConferenceInProgress: getIsConferenceInProgress(payload.data),
+            });
+            task.emit(TASK_EVENTS.TASK_PARTICIPANT_JOINED, task);
+            break;
+          }
+          case CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE: {
+            // Conference ended - update task state and emit event
+
+            task = this.updateTaskData(task, {
+              ...payload.data,
+              isConferenceInProgress: getIsConferenceInProgress(payload.data),
+            });
+            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);
+            task.emit(TASK_EVENTS.TASK_PARTICIPANT_LEFT_FAILED, task);
+            break;
+          case CC_EVENTS.AGENT_CONSULT_CONFERENCE_END_FAILED:
+            // Conference end failed - update task state with error details and emit failure event
+            task = this.updateTaskData(task, payload.data);
+            task.emit(TASK_EVENTS.TASK_CONFERENCE_END_FAILED, task);
+            break;
+          case CC_EVENTS.AGENT_CONFERENCE_TRANSFERRED:
+            // Conference was transferred - update task state and emit transfer success event
+            // Note: Backend should provide hasLeft and wrapUpRequired status
+            task = this.updateTaskData(task, payload.data);
+            task.emit(TASK_EVENTS.TASK_CONFERENCE_TRANSFERRED, task);
+            break;
+          case CC_EVENTS.AGENT_CONFERENCE_TRANSFER_FAILED:
+            // Conference transfer failed - update task state with error details and emit failure event
+            task = this.updateTaskData(task, payload.data);
+            task.emit(TASK_EVENTS.TASK_CONFERENCE_TRANSFER_FAILED, task);
+            break;
+          case CC_EVENTS.PARTICIPANT_POST_CALL_ACTIVITY:
+            // Post-call activity for participant - update task state with activity details
+            task = this.updateTaskData(task, payload.data);
+            task.emit(TASK_EVENTS.TASK_POST_CALL_ACTIVITY, task);
+            break;
           default:
             break;
         }
@@ -362,6 +479,54 @@ export default class TaskManager extends EventEmitter {
     }
   }
 
+  /**
+   * Handles CONTACT_MERGED event logic
+   * @param task - The task to process
+   * @param taskData - The task data from the event payload
+   * @returns Updated or newly created task
+   * @private
+   */
+  private handleContactMerged(task: ITask, taskData: TaskData): ITask {
+    if (taskData.childInteractionId) {
+      // remove the child task from collection
+      this.removeTaskFromCollection(this.taskCollection[taskData.childInteractionId]);
+    }
+
+    if (this.taskCollection[taskData.interactionId]) {
+      LoggerProxy.log(`Got CONTACT_MERGED: Task already exists in collection`, {
+        module: TASK_MANAGER_FILE,
+        method: METHODS.REGISTER_TASK_LISTENERS,
+        interactionId: taskData.interactionId,
+      });
+      // update the task data
+      task = this.updateTaskData(task, taskData);
+    } else {
+      // Case2 : Task is not present in taskCollection
+      LoggerProxy.log(`Got CONTACT_MERGED : Creating new task in taskManager`, {
+        module: TASK_MANAGER_FILE,
+        method: METHODS.REGISTER_TASK_LISTENERS,
+        interactionId: taskData.interactionId,
+      });
+
+      task = new Task(
+        this.contact,
+        this.webCallingService,
+        {
+          ...taskData,
+          wrapUpRequired: taskData.interaction?.participants?.[this.agentId]?.isWrapUp || false,
+          isConferenceInProgress: getIsConferenceInProgress(taskData),
+        },
+        this.wrapupData,
+        this.agentId
+      );
+      this.taskCollection[taskData.interactionId] = task;
+    }
+
+    this.emit(TASK_EVENTS.TASK_MERGED, task);
+
+    return task;
+  }
+
   private removeTaskFromCollection(task: ITask) {
     if (task?.data?.interactionId) {
       delete this.taskCollection[task.data.interactionId];
@@ -373,7 +538,13 @@ export default class TaskManager extends EventEmitter {
     }
   }
 
+  /**
+   * Handles cleanup of task resources including Desktop/WebRTC call cleanup and task removal
+   * @param task - The task to clean up
+   * @private
+   */
   private handleTaskCleanup(task: ITask) {
+    // Clean up Desktop/WebRTC calling resources for browser-based telephony tasks
     if (
       this.webCallingService.loginOption === LoginOption.BROWSER &&
       task.data.interaction.mediaType === 'telephony'
@@ -381,8 +552,9 @@ export default class TaskManager extends EventEmitter {
       task.unregisterWebCallListeners();
       this.webCallingService.cleanUpCall();
     }
-    if (task.data.interaction.state === 'new') {
-      // Only remove tasks in 'new' state immediately. For other states,
+
+    if (task.data.interaction.state === 'new' || isSecondaryEpDnAgent(task.data.interaction)) {
+      // Only remove tasks in 'new' state or isSecondaryEpDnAgent immediately. For other states,
       // retain tasks until they complete wrap-up, unless the task disconnected before being answered.
       this.removeTaskFromCollection(task);
     }

package/src/services/task/TaskUtils.ts

@@ -0,0 +1,113 @@
+/* eslint-disable import/prefer-default-export */
+import {Interaction, ITask, TaskData} 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 TaskData - The payLoad data 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 = (data: TaskData): boolean => {
+  const mediaMainCall = data.interaction.media?.[data?.interactionId];
+  const participantsInMainCall = new Set(mediaMainCall?.participants);
+  const participants = 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;
+};
+
+/**
+ * Checks if the current agent is a secondary agent in a consultation scenario.
+ * Secondary agents are those who were consulted (not the original call owner).
+ * @param task - The task object containing interaction details
+ * @returns true if this is a secondary agent (consulted party), false otherwise
+ */
+export const isSecondaryAgent = (interaction: Interaction): boolean => {
+  if (!interaction.callProcessingDetails) {
+    return false;
+  }
+
+  return (
+    interaction.callProcessingDetails.relationshipType === 'consult' &&
+    !!interaction.callProcessingDetails.parentInteractionId &&
+    interaction.callProcessingDetails.parentInteractionId !== interaction.interactionId
+  );
+};
+
+/**
+ * Checks if the current agent is a secondary EP-DN (Entry Point Dial Number) agent.
+ * This is specifically for telephony consultations to external numbers/entry points.
+ * @param task - The task object containing interaction details
+ * @returns true if this is a secondary EP-DN agent in telephony consultation, false otherwise
+ */
+export const isSecondaryEpDnAgent = (interaction: Interaction): boolean => {
+  if (!interaction) {
+    return false;
+  }
+
+  return interaction.mediaType === 'telephony' && isSecondaryAgent(interaction);
+};

package/src/services/task/constants.ts

@@ -17,9 +17,31 @@ export const PAUSE = '/record/pause';
 export const RESUME = '/record/resume';
 export const WRAPUP = '/wrapup';
 export const END = '/end';
+export const CONSULT_CONFERENCE = '/consult/conference';
+export const CONFERENCE_EXIT = '/conference/exit';
+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
@@ -36,6 +58,9 @@ export const METHODS = {
   END_CONSULT: 'endConsult',
   TRANSFER: 'transfer',
   CONSULT_TRANSFER: 'consultTransfer',
+  CONSULT_CONFERENCE: 'consultConference',
+  EXIT_CONFERENCE: 'exitConference',
+  TRANSFER_CONFERENCE: 'transferConference',
   UPDATE_TASK_DATA: 'updateTaskData',
   RECONCILE_DATA: 'reconcileData',