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

package/src/services/core/Utils.ts

@@ -1,8 +1,15 @@
 import * as Err from './Err';
 import {LoginOption, WebexRequestPayload} from '../../types';
-import {Failure} from './GlobalTypes';
+import {Failure, AugmentedError} from './GlobalTypes';
 import LoggerProxy from '../../logger-proxy';
 import WebexRequest from './WebexRequest';
+import {
+  TaskData,
+  ConsultTransferPayLoad,
+  CONSULT_TRANSFER_DESTINATION_TYPE,
+  Interaction,
+} from '../task/types';
+import {PARTICIPANT_TYPES, STATE_CONSULT} from './constants';
 
 /**
  * Extracts common error details from a Webex request payload.
@@ -19,6 +26,28 @@ const getCommonErrorDetails = (errObj: WebexRequestPayload) => {
   };
 };
 
+/**
+ * Checks if the destination type represents an entry point variant (EPDN or ENTRYPOINT).
+ */
+const isEntryPointOrEpdn = (destAgentType?: string): boolean => {
+  return destAgentType === 'EPDN' || destAgentType === 'ENTRYPOINT';
+};
+
+/**
+ * Determines if the task involves dialing a number based on the destination type.
+ * Returns 'DIAL_NUMBER' for dial-related destinations, empty string otherwise.
+ */
+const getAgentActionTypeFromTask = (taskData?: TaskData): 'DIAL_NUMBER' | '' => {
+  const destAgentType = taskData?.destinationType;
+
+  // Check if destination requires dialing: direct dial number or entry point variants
+  const isDialNumber = destAgentType === 'DN';
+  const isEntryPointVariant = isEntryPointOrEpdn(destAgentType);
+
+  // If the destination type is a dial number or an entry point variant, return 'DIAL_NUMBER'
+  return isDialNumber || isEntryPointVariant ? 'DIAL_NUMBER' : '';
+};
+
 export const isValidDialNumber = (input: string): boolean => {
   // This regex checks for a valid dial number format for only few countries such as US, Canada.
   const regexForDn = /1[0-9]{3}[2-9][0-9]{6}([,]{1,10}[0-9]+){0,1}/;
@@ -115,6 +144,62 @@ export const getErrorDetails = (error: any, methodName: string, moduleName: stri
   };
 };
 
+/**
+ * Extracts error details from task API errors and logs them. Also uploads logs for the error.
+ * This handles the specific error format returned by task API calls.
+ *
+ * @param error - The error object from task API calls with structure: {id: string, details: {trackingId: string, msg: {...}}}
+ * @param methodName - The name of the method where the error occurred.
+ * @param moduleName - The name of the module where the error occurred.
+ * @returns AugmentedError containing structured error details on err.data for metrics and logging
+ * @public
+ * @example
+ * const taskError = generateTaskErrorObject(error, 'transfer', 'TaskModule');
+ * throw taskError.error;
+ * @ignore
+ */
+export const generateTaskErrorObject = (
+  error: any,
+  methodName: string,
+  moduleName: string
+): AugmentedError => {
+  const trackingId = error?.details?.trackingId || error?.trackingId || '';
+  const errorMsg = error?.details?.msg;
+
+  const fallbackMessage =
+    (error && typeof error.message === 'string' && error.message) ||
+    `Error while performing ${methodName}`;
+  const errorMessage = errorMsg?.errorMessage || fallbackMessage;
+  const errorType =
+    errorMsg?.errorType ||
+    (error && typeof error.name === 'string' && error.name) ||
+    'Unknown Error';
+  const errorData = errorMsg?.errorData || '';
+  const reasonCode = errorMsg?.reasonCode || 0;
+
+  // Log and upload for Task API formatted errors
+  LoggerProxy.error(`${methodName} failed: ${errorMessage} (${errorType})`, {
+    module: moduleName,
+    method: methodName,
+    trackingId,
+  });
+  WebexRequest.getInstance().uploadLogs({
+    correlationId: trackingId,
+  });
+
+  const reason = `${errorType}: ${errorMessage}${errorData ? ` (${errorData})` : ''}`;
+  const err: AugmentedError = new Error(reason);
+  err.data = {
+    message: errorMessage,
+    errorType,
+    errorData,
+    reasonCode,
+    trackingId,
+  };
+
+  return err;
+};
+
 /**
  * Creates an error details object suitable for use with the Err.Details class.
  *
@@ -130,3 +215,132 @@ export const createErrDetailsObject = (errObj: WebexRequestPayload) => {
 
   return new Err.Details('Service.reqs.generic.failure', details);
 };
+
+/**
+ * Gets the consulted agent ID from the media object by finding the agent
+ * in the consult media participants (excluding the current 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 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;
+};
+
+/**
+ * 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
+ */
+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;
+};
+
+/**
+ * Calculates the destination agent ID for fetching destination type.
+ *
+ * @param interaction - The interaction object
+ * @param agentId - The current agent's ID
+ * @returns The destination agent ID for determining destination type
+ */
+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 CONSULT_TRANSFER_DESTINATION_TYPE.AGENT;
+};
+
+export const deriveConsultTransferDestinationType = (
+  taskData?: TaskData
+): ConsultTransferPayLoad['destinationType'] => {
+  const agentActionType = getAgentActionTypeFromTask(taskData);
+
+  if (agentActionType === 'DIAL_NUMBER') {
+    return isEntryPointOrEpdn(taskData?.destinationType)
+      ? CONSULT_TRANSFER_DESTINATION_TYPE.ENTRYPOINT
+      : CONSULT_TRANSFER_DESTINATION_TYPE.DIALNUMBER;
+  }
+
+  return CONSULT_TRANSFER_DESTINATION_TYPE.AGENT;
+};

package/src/services/core/aqm-reqs.ts

@@ -224,11 +224,6 @@ export default class AqmReqs {
     }
 
     if (event.keepalive === 'true') {
-      LoggerProxy.info(`Keepalive from web socket`, {
-        module: AQM_REQS_FILE,
-        method: METHODS.ON_MESSAGE,
-      });
-
       return;
     }
 

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/core/websocket/WebSocketManager.ts

@@ -178,10 +178,6 @@ export class WebSocketManager extends EventEmitter {
         issueReason = 'WebSocket auto close timed out. Forcefully closed websocket.';
       } else {
         const onlineStatus = navigator.onLine;
-        LoggerProxy.info(`[WebSocketStatus] | desktop online status is ${onlineStatus}`, {
-          module: WEB_SOCKET_MANAGER_FILE,
-          method: METHODS.WEB_SOCKET_ON_CLOSE_HANDLER,
-        });
         issueReason = !onlineStatus
           ? 'network issue'
           : 'missing keepalive from either desktop or notif service';

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
@@ -270,6 +304,7 @@ export default class TaskManager extends EventEmitter {
             break;
           case CC_EVENTS.AGENT_CONSULTING:
             // Received when agent is in an active consult state
+            // TODO: Check if we can use backend consult state instead of isConsulted
             task = this.updateTaskData(task, payload.data);
             if (task.data.isConsulted) {
               // Fire only if you are the agent who received the consult request
@@ -323,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;
         }
@@ -361,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];
@@ -372,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'
@@ -380,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);
+};