@webex/contact-center 3.10.0-next.1 → 3.10.0-next.11

package/src/services/core/Utils.ts

@@ -6,11 +6,10 @@ import WebexRequest from './WebexRequest';
 import {
   TaskData,
   ConsultTransferPayLoad,
-  ConsultConferenceData,
-  consultConferencePayloadData,
   CONSULT_TRANSFER_DESTINATION_TYPE,
   Interaction,
 } from '../task/types';
+import {PARTICIPANT_TYPES, STATE_CONSULT} from './constants';
 
 /**
  * Extracts common error details from a Webex request payload.
@@ -218,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 = (
@@ -286,45 +344,3 @@ export const deriveConsultTransferDestinationType = (
 
   return CONSULT_TRANSFER_DESTINATION_TYPE.AGENT;
 };
-
-/**
- * Builds consult conference parameter data using EXACT Agent Desktop logic.
- * This matches the Agent Desktop's consultConference implementation exactly.
- *
- * @param dataPassed - Original consultation data from Agent Desktop format
- * @param interactionIdPassed - The interaction ID for the task
- * @returns Object with interactionId and ConsultConferenceData matching Agent Desktop format
- * @public
- */
-export const buildConsultConferenceParamData = (
-  dataPassed: consultConferencePayloadData,
-  interactionIdPassed: string
-): {interactionId: string; data: ConsultConferenceData} => {
-  const data: ConsultConferenceData = {
-    // Include agentId if present in input data
-    ...('agentId' in dataPassed && {agentId: dataPassed.agentId}),
-    // Handle destAgentId from consultation data
-    to: dataPassed.destAgentId,
-    destinationType: '',
-  };
-
-  // Agent Desktop destination type logic
-  if ('destinationType' in dataPassed) {
-    if (dataPassed.destinationType === 'DN') {
-      data.destinationType = CONSULT_TRANSFER_DESTINATION_TYPE.DIALNUMBER;
-    } else if (dataPassed.destinationType === 'EP_DN') {
-      data.destinationType = CONSULT_TRANSFER_DESTINATION_TYPE.ENTRYPOINT;
-    } else {
-      // Keep the existing destinationType if it's something else (like "agent" or "Agent")
-      // Convert "Agent" to lowercase for consistency
-      data.destinationType = dataPassed.destinationType.toLowerCase();
-    }
-  } else {
-    data.destinationType = CONSULT_TRANSFER_DESTINATION_TYPE.AGENT;
-  }
-
-  return {
-    interactionId: interactionIdPassed,
-    data,
-  };
-};

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

@@ -17,6 +17,7 @@ import {
   getIsConferenceInProgress,
   isParticipantInMainInteraction,
   isPrimary,
+  isSecondaryEpDnAgent,
 } from './TaskUtils';
 
 /** @internal */
@@ -128,6 +129,7 @@ export default class TaskManager extends EventEmitter {
                 method: METHODS.REGISTER_TASK_LISTENERS,
                 interactionId: payload.data.interactionId,
               });
+
               task = new Task(
                 this.contact,
                 this.webCallingService,
@@ -135,6 +137,7 @@ export default class TaskManager extends EventEmitter {
                   ...payload.data,
                   wrapUpRequired:
                     payload.data.interaction?.participants?.[this.agentId]?.isWrapUp || false,
+                  isConferenceInProgress: getIsConferenceInProgress(payload.data),
                 },
                 this.wrapupData,
                 this.agentId
@@ -165,6 +168,7 @@ export default class TaskManager extends EventEmitter {
               }
             }
             break;
+
           case CC_EVENTS.AGENT_CONTACT_RESERVED:
             task = new Task(
               this.contact,
@@ -244,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
@@ -372,32 +385,22 @@ export default class TaskManager extends EventEmitter {
             } else {
               this.removeTaskFromCollection(task);
             }
-            task?.emit(TASK_EVENTS.TASK_CONFERENCE_ENDED, task);
+            task.emit(TASK_EVENTS.TASK_CONFERENCE_ENDED, task);
             break;
           case CC_EVENTS.PARTICIPANT_JOINED_CONFERENCE: {
-            // Participant joined conference - update task state with participant information and emit event
-            // 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),
+              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
-            // 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),
+              isConferenceInProgress: getIsConferenceInProgress(payload.data),
             });
             if (checkParticipantNotInInteraction(task, this.agentId)) {
               if (
@@ -433,13 +436,10 @@ export default class TaskManager extends EventEmitter {
             task = this.updateTaskData(task, payload.data);
             task.emit(TASK_EVENTS.TASK_CONFERENCE_TRANSFER_FAILED, task);
             break;
-          case CC_EVENTS.CONSULTED_PARTICIPANT_MOVING:
-            // Participant is being moved/transferred - update task state with movement info
-            task = this.updateTaskData(task, payload.data);
-            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;
@@ -479,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];
@@ -490,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'
@@ -498,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

@@ -1,5 +1,5 @@
 /* eslint-disable import/prefer-default-export */
-import {ITask} from './types';
+import {Interaction, ITask, TaskData} from './types';
 
 /**
  * Determines if the given agent is the primary agent (owner) of the task
@@ -53,13 +53,13 @@ export const checkParticipantNotInInteraction = (task: ITask, agentId: string):
 
 /**
  * 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
+ * @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 = (task: ITask): boolean => {
-  const mediaMainCall = task?.data?.interaction?.media?.[task?.data?.interactionId];
+export const getIsConferenceInProgress = (data: TaskData): boolean => {
+  const mediaMainCall = data.interaction.media?.[data?.interactionId];
   const participantsInMainCall = new Set(mediaMainCall?.participants);
-  const participants = task?.data?.interaction?.participants;
+  const participants = data.interaction.participants;
 
   const agentParticipants = new Set();
   if (participantsInMainCall.size > 0) {
@@ -79,3 +79,35 @@ export const getIsConferenceInProgress = (task: ITask): boolean => {
 
   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/index.ts

@@ -1,12 +1,7 @@
 import EventEmitter from 'events';
 import {CALL_EVENT_KEYS, LocalMicrophoneStream} from '@webex/calling';
 import {CallId} from '@webex/calling/dist/types/common/types';
-import {
-  generateTaskErrorObject,
-  deriveConsultTransferDestinationType,
-  getDestinationAgentId,
-  buildConsultConferenceParamData,
-} from '../core/Utils';
+import {generateTaskErrorObject, calculateDestAgentId, calculateDestType} from '../core/Utils';
 import {Failure} from '../core/GlobalTypes';
 import {LoginOption} from '../../types';
 import {TASK_FILE} from '../../constants';
@@ -1447,35 +1442,31 @@ export default class Task extends EventEmitter implements ITask {
   public async consultTransfer(
     consultTransferPayload?: ConsultTransferPayLoad
   ): Promise<TaskResponse> {
-    try {
-      // Get the destination agent ID using custom logic from participants data
-      const destAgentId = getDestinationAgentId(
-        this.data.interaction?.participants,
-        this.data.agentId
-      );
-
-      // Resolve the target id (queue consult transfers go to the accepted agent)
-      if (!destAgentId) {
-        throw new Error('No agent has accepted this queue consult yet');
-      }
+    // Get the destination agent ID using custom logic from participants data
+    const destAgentId = calculateDestAgentId(this.data.interaction, this.agentId);
 
-      LoggerProxy.info(
-        `Initiating consult transfer to ${consultTransferPayload?.to || destAgentId}`,
-        {
-          module: TASK_FILE,
-          method: METHODS.CONSULT_TRANSFER,
-          interactionId: this.data.interactionId,
-        }
-      );
-      // Obtain payload based on desktop logic using TaskData
-      const finalDestinationType = deriveConsultTransferDestinationType(this.data);
-
-      // By default we always use the computed destAgentId as the target id
-      const consultTransferRequest: ConsultTransferPayLoad = {
-        to: destAgentId,
-        destinationType: finalDestinationType,
-      };
+    // Resolve the target id (queue consult transfers go to the accepted agent)
+    if (!destAgentId) {
+      throw new Error('No agent has accepted this queue consult yet');
+    }
 
+    LoggerProxy.info(
+      `Initiating consult transfer to ${consultTransferPayload?.to || destAgentId}`,
+      {
+        module: TASK_FILE,
+        method: METHODS.CONSULT_TRANSFER,
+        interactionId: this.data.interactionId,
+      }
+    );
+
+    // Derive destination type from the participant's type property
+    const destType = calculateDestType(this.data.interaction, this.agentId);
+    // By default we always use the computed destAgentId as the target id
+    const consultTransferRequest: ConsultTransferPayLoad = {
+      to: destAgentId,
+      destinationType: destType,
+    };
+    try {
       const result = await this.contact.consultTransfer({
         interactionId: this.data.interactionId,
         data: consultTransferRequest,
@@ -1513,17 +1504,12 @@ export default class Task extends EventEmitter implements ITask {
         errorData: err.data?.errorData,
         reasonCode: err.data?.reasonCode,
       };
-      const failedDestinationType = deriveConsultTransferDestinationType(this.data);
-      const failedDestAgentId = getDestinationAgentId(
-        this.data.interaction?.participants,
-        this.data.agentId
-      );
       this.metricsManager.trackEvent(
         METRIC_EVENT_NAMES.TASK_TRANSFER_FAILED,
         {
           taskId: this.data.interactionId,
-          destination: failedDestAgentId || '',
-          destinationType: failedDestinationType,
+          destination: destAgentId || '',
+          destinationType: destType,
           isConsultTransfer: true,
           error: error.toString(),
           ...taskErrorProps,
@@ -1556,28 +1542,36 @@ export default class Task extends EventEmitter implements ITask {
    * ```
    */
   public async consultConference(): Promise<TaskResponse> {
+    // Get the destination agent ID dynamically from participants
+    // This handles multi-party conference scenarios, CBT (Capacity Based Team), and EP-DN cases
+    const destAgentId = calculateDestAgentId(this.data.interaction, this.agentId);
+
+    // Validate that we have a destination agent (for queue consult scenarios)
+    if (!destAgentId) {
+      throw new Error('No agent has accepted this queue consult yet');
+    }
+
+    // Get the destination agent ID for fetching destination type
+    // This helps determine the correct participant type for CBT (Capacity Based Team) and EP-DN scenarios
+    const destAgentType = calculateDestType(this.data.interaction, this.agentId);
+
     // Extract consultation conference data from task data (used in both try and catch)
     const consultationData = {
       agentId: this.agentId,
-      destAgentId: this.data.destAgentId,
-      destinationType: this.data.destinationType || 'agent',
+      to: destAgentId,
+      destinationType: destAgentType || this.data.destinationType || 'agent',
     };
 
     try {
-      LoggerProxy.info(`Initiating consult conference to ${consultationData.destAgentId}`, {
+      LoggerProxy.info(`Initiating consult conference to ${destAgentId}`, {
         module: TASK_FILE,
         method: METHODS.CONSULT_CONFERENCE,
         interactionId: this.data.interactionId,
       });
 
-      const paramsDataForConferenceV2 = buildConsultConferenceParamData(
-        consultationData,
-        this.data.interactionId
-      );
-
       const response = await this.contact.consultConference({
-        interactionId: paramsDataForConferenceV2.interactionId,
-        data: paramsDataForConferenceV2.data,
+        interactionId: this.data.interactionId,
+        data: consultationData,
       });
 
       // Track success metrics (following consultTransfer pattern)
@@ -1585,9 +1579,9 @@ export default class Task extends EventEmitter implements ITask {
         METRIC_EVENT_NAMES.TASK_CONFERENCE_START_SUCCESS,
         {
           taskId: this.data.interactionId,
-          destination: paramsDataForConferenceV2.data.to,
-          destinationType: paramsDataForConferenceV2.data.destinationType,
-          agentId: paramsDataForConferenceV2.data.agentId,
+          destination: consultationData.to,
+          destinationType: consultationData.destinationType,
+          agentId: consultationData.agentId,
           ...MetricsManager.getCommonTrackingFieldForAQMResponse(response),
         },
         ['operational', 'behavioral', 'business']
@@ -1610,20 +1604,13 @@ export default class Task extends EventEmitter implements ITask {
         reasonCode: err.data?.reasonCode,
       };
 
-      // Track failure metrics (following consultTransfer pattern)
-      // Build conference data for error tracking using extracted data
-      const failedParamsData = buildConsultConferenceParamData(
-        consultationData,
-        this.data.interactionId
-      );
-
       this.metricsManager.trackEvent(
         METRIC_EVENT_NAMES.TASK_CONFERENCE_START_FAILED,
         {
           taskId: this.data.interactionId,
-          destination: failedParamsData.data.to,
-          destinationType: failedParamsData.data.destinationType,
-          agentId: failedParamsData.data.agentId,
+          destination: consultationData.to,
+          destinationType: consultationData.destinationType,
+          agentId: consultationData.agentId,
           error: error.toString(),
           ...taskErrorProps,
           ...MetricsManager.getCommonTrackingFieldForAQMResponseFailed(error.details || {}),