@webex/contact-center 3.9.0 → 3.10.0-next.2

package/dist/services/task/index.js

@@ -120,7 +120,7 @@ class Task extends _events.default {
    * @param data - Initial task data
    * @param wrapupData - Wrap-up configuration data
    */
-  constructor(contact, webCallingService, data, wrapupData) {
+  constructor(contact, webCallingService, data, wrapupData, agentId) {
     super();
     this.contact = contact;
     this.data = data;
@@ -130,6 +130,7 @@ class Task extends _events.default {
     this.metricsManager = _MetricsManager.default.getInstance();
     this.registerWebCallListeners();
     this.setupAutoWrapupTimer();
+    this.agentId = agentId;
   }
 
   /**
@@ -244,11 +245,17 @@ class Task extends _events.default {
    * @private
    */
   reconcileData(oldData, newData) {
+    // Remove keys from oldData that are not in newData
+    Object.keys(oldData).forEach(key => {
+      if (!(key in newData) && !_constants2.KEYS_TO_NOT_DELETE.includes(key)) {
+        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];
       }
@@ -331,15 +338,21 @@ class Task extends _events.default {
       }
       return Promise.resolve(); // TODO: reject for extension as part of refactor
     } catch (error) {
-      const {
-        error: detailedError
-      } = (0, _Utils.getErrorDetails)(error, _constants2.METHODS.ACCEPT, _constants.TASK_FILE);
+      const err = (0, _Utils.generateTaskErrorObject)(error, _constants2.METHODS.ACCEPT, _constants.TASK_FILE);
+      const taskErrorProps = {
+        trackingId: err.data?.trackingId,
+        errorMessage: err.data?.message,
+        errorType: err.data?.errorType,
+        errorData: err.data?.errorData,
+        reasonCode: err.data?.reasonCode
+      };
       this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES.TASK_ACCEPT_FAILED, {
         taskId: this.data.interactionId,
         error: error.toString(),
+        ...taskErrorProps,
         ..._MetricsManager.default.getCommonTrackingFieldForAQMResponseFailed(error.details)
       }, ['operational', 'behavioral', 'business']);
-      throw detailedError;
+      throw err;
     }
   }
 
@@ -372,10 +385,8 @@ class Task extends _events.default {
       });
       return Promise.resolve();
     } catch (error) {
-      const {
-        error: detailedError
-      } = (0, _Utils.getErrorDetails)(error, _constants2.METHODS.TOGGLE_MUTE, _constants.TASK_FILE);
-      throw detailedError;
+      const err = (0, _Utils.generateTaskErrorObject)(error, _constants2.METHODS.TOGGLE_MUTE, _constants.TASK_FILE);
+      throw err;
     }
   }
 
@@ -413,15 +424,21 @@ class Task extends _events.default {
       });
       return Promise.resolve();
     } catch (error) {
-      const {
-        error: detailedError
-      } = (0, _Utils.getErrorDetails)(error, _constants2.METHODS.DECLINE, _constants.TASK_FILE);
+      const err = (0, _Utils.generateTaskErrorObject)(error, _constants2.METHODS.DECLINE, _constants.TASK_FILE);
+      const taskErrorProps = {
+        trackingId: err.data?.trackingId,
+        errorMessage: err.data?.message,
+        errorType: err.data?.errorType,
+        errorData: err.data?.errorData,
+        reasonCode: err.data?.reasonCode
+      };
       this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES.TASK_DECLINE_FAILED, {
         taskId: this.data.interactionId,
         error: error.toString(),
+        ...taskErrorProps,
         ..._MetricsManager.default.getCommonTrackingFieldForAQMResponseFailed(error.details || {})
       }, ['operational', 'behavioral']);
-      throw detailedError;
+      throw err;
     }
   }
 
@@ -429,6 +446,7 @@ class Task extends _events.default {
    * Puts the current task/interaction on hold.
    * Emits task:hold event when successful. For voice tasks, this mutes the audio.
    *
+   * @param mediaResourceId - Optional media resource ID to use for the hold operation. If not provided, uses the task's current mediaResourceId
    * @returns Promise<TaskResponse>
    * @throws Error if hold operation fails
    * @example
@@ -449,9 +467,17 @@ class Task extends _events.default {
    *   console.error('Failed to place task on hold:', error);
    *   // Handle error (e.g., show error message, reset UI state)
    * }
+   *
+   * // Place task on hold with custom mediaResourceId
+   * try {
+   *   await task.hold('custom-media-resource-id');
+   *   console.log('Successfully placed task on hold with custom mediaResourceId');
+   * } catch (error) {
+   *   console.error('Failed to place task on hold:', error);
+   * }
    * ```
    */
-  async hold() {
+  async hold(mediaResourceId) {
     try {
       _loggerProxy.default.info(`Holding task`, {
         module: _constants.TASK_FILE,
@@ -459,16 +485,17 @@ class Task extends _events.default {
         interactionId: this.data.interactionId
       });
       this.metricsManager.timeEvent([_constants3.METRIC_EVENT_NAMES.TASK_HOLD_SUCCESS, _constants3.METRIC_EVENT_NAMES.TASK_HOLD_FAILED]);
+      const effectiveMediaResourceId = mediaResourceId ?? this.data.mediaResourceId;
       const response = await this.contact.hold({
         interactionId: this.data.interactionId,
         data: {
-          mediaResourceId: this.data.mediaResourceId
+          mediaResourceId: effectiveMediaResourceId
         }
       });
       this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES.TASK_HOLD_SUCCESS, {
         ..._MetricsManager.default.getCommonTrackingFieldForAQMResponse(response),
         taskId: this.data.interactionId,
-        mediaResourceId: this.data.mediaResourceId
+        mediaResourceId: effectiveMediaResourceId
       }, ['operational', 'behavioral']);
       _loggerProxy.default.log(`Task placed on hold successfully`, {
         module: _constants.TASK_FILE,
@@ -478,16 +505,23 @@ class Task extends _events.default {
       });
       return response;
     } catch (error) {
-      const {
-        error: detailedError
-      } = (0, _Utils.getErrorDetails)(error, _constants2.METHODS.HOLD, _constants.TASK_FILE);
+      const err = (0, _Utils.generateTaskErrorObject)(error, _constants2.METHODS.HOLD, _constants.TASK_FILE);
+      const taskErrorProps = {
+        trackingId: err.data?.trackingId,
+        errorMessage: err.data?.message,
+        errorType: err.data?.errorType,
+        errorData: err.data?.errorData,
+        reasonCode: err.data?.reasonCode
+      };
+      const effectiveMediaResourceId = mediaResourceId ?? this.data.mediaResourceId;
       this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES.TASK_HOLD_FAILED, {
         taskId: this.data.interactionId,
-        mediaResourceId: this.data.mediaResourceId,
+        mediaResourceId: effectiveMediaResourceId,
         error: error.toString(),
+        ...taskErrorProps,
         ..._MetricsManager.default.getCommonTrackingFieldForAQMResponseFailed(error.details || {})
       }, ['operational', 'behavioral']);
-      throw detailedError;
+      throw err;
     }
   }
 
@@ -495,6 +529,7 @@ class Task extends _events.default {
    * Resumes the task/interaction that was previously put on hold.
    * Emits task:resume event when successful. For voice tasks, this restores the audio.
    *
+   * @param mediaResourceId - Optional media resource ID to use for the resume operation. If not provided, uses the task's current mediaResourceId from interaction media
    * @returns Promise<TaskResponse>
    * @throws Error if resume operation fails
    * @example
@@ -515,9 +550,17 @@ class Task extends _events.default {
    *   console.error('Failed to resume task:', error);
    *   // Handle error (e.g., show error message)
    * }
+   *
+   * // Resume task from hold with custom mediaResourceId
+   * try {
+   *   await task.resume('custom-media-resource-id');
+   *   console.log('Successfully resumed task from hold with custom mediaResourceId');
+   * } catch (error) {
+   *   console.error('Failed to resume task:', error);
+   * }
    * ```
    */
-  async resume() {
+  async resume(mediaResourceId) {
     try {
       _loggerProxy.default.info(`Resuming task`, {
         module: _constants.TASK_FILE,
@@ -527,20 +570,19 @@ class Task extends _events.default {
       const {
         mainInteractionId
       } = this.data.interaction;
-      const {
-        mediaResourceId
-      } = this.data.interaction.media[mainInteractionId];
+      const defaultMediaResourceId = this.data.interaction.media[mainInteractionId]?.mediaResourceId;
+      const effectiveMediaResourceId = mediaResourceId ?? defaultMediaResourceId;
       this.metricsManager.timeEvent([_constants3.METRIC_EVENT_NAMES.TASK_RESUME_SUCCESS, _constants3.METRIC_EVENT_NAMES.TASK_RESUME_FAILED]);
       const response = await this.contact.unHold({
         interactionId: this.data.interactionId,
         data: {
-          mediaResourceId
+          mediaResourceId: effectiveMediaResourceId
         }
       });
       this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES.TASK_RESUME_SUCCESS, {
         taskId: this.data.interactionId,
         mainInteractionId,
-        mediaResourceId,
+        mediaResourceId: effectiveMediaResourceId,
         ..._MetricsManager.default.getCommonTrackingFieldForAQMResponse(response)
       }, ['operational', 'behavioral']);
       _loggerProxy.default.log(`Task resumed successfully`, {
@@ -551,17 +593,25 @@ class Task extends _events.default {
       });
       return response;
     } catch (error) {
-      const {
-        error: detailedError
-      } = (0, _Utils.getErrorDetails)(error, _constants2.METHODS.RESUME, _constants.TASK_FILE);
+      const err = (0, _Utils.generateTaskErrorObject)(error, _constants2.METHODS.RESUME, _constants.TASK_FILE);
       const mainInteractionId = this.data.interaction?.mainInteractionId;
+      const defaultMediaResourceId = mainInteractionId ? this.data.interaction.media[mainInteractionId]?.mediaResourceId : '';
+      const effectiveMediaResourceId = mediaResourceId ?? defaultMediaResourceId;
+      const taskErrorProps = {
+        trackingId: err.data?.trackingId,
+        errorMessage: err.data?.message,
+        errorType: err.data?.errorType,
+        errorData: err.data?.errorData,
+        reasonCode: err.data?.reasonCode
+      };
       this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES.TASK_RESUME_FAILED, {
         taskId: this.data.interactionId,
         mainInteractionId,
-        mediaResourceId: mainInteractionId ? this.data.interaction.media[mainInteractionId].mediaResourceId : '',
+        mediaResourceId: effectiveMediaResourceId,
+        ...taskErrorProps,
         ..._MetricsManager.default.getCommonTrackingFieldForAQMResponseFailed(error.details || {})
       }, ['operational', 'behavioral']);
-      throw detailedError;
+      throw err;
     }
   }
 
@@ -631,14 +681,20 @@ class Task extends _events.default {
       });
       return response;
     } catch (error) {
-      const {
-        error: detailedError
-      } = (0, _Utils.getErrorDetails)(error, _constants2.METHODS.END, _constants.TASK_FILE);
+      const err = (0, _Utils.generateTaskErrorObject)(error, _constants2.METHODS.END, _constants.TASK_FILE);
+      const taskErrorProps = {
+        trackingId: err.data?.trackingId,
+        errorMessage: err.data?.message,
+        errorType: err.data?.errorType,
+        errorData: err.data?.errorData,
+        reasonCode: err.data?.reasonCode
+      };
       this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES.TASK_END_FAILED, {
         taskId: this.data.interactionId,
+        ...taskErrorProps,
         ..._MetricsManager.default.getCommonTrackingFieldForAQMResponseFailed(error.details || {})
       }, ['operational', 'behavioral', 'business']);
-      throw detailedError;
+      throw err;
     }
   }
 
@@ -720,16 +776,22 @@ class Task extends _events.default {
       });
       return response;
     } catch (error) {
-      const {
-        error: detailedError
-      } = (0, _Utils.getErrorDetails)(error, _constants2.METHODS.WRAPUP, _constants.TASK_FILE);
+      const err = (0, _Utils.generateTaskErrorObject)(error, _constants2.METHODS.WRAPUP, _constants.TASK_FILE);
+      const taskErrorProps = {
+        trackingId: err.data?.trackingId,
+        errorMessage: err.data?.message,
+        errorType: err.data?.errorType,
+        errorData: err.data?.errorData,
+        reasonCode: err.data?.reasonCode
+      };
       this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES.TASK_WRAPUP_FAILED, {
         taskId: this.data.interactionId,
         wrapUpCode: wrapupPayload.auxCodeId,
         wrapUpReason: wrapupPayload.wrapUpReason,
+        ...taskErrorProps,
         ..._MetricsManager.default.getCommonTrackingFieldForAQMResponseFailed(error.details || {})
       }, ['operational', 'behavioral', 'business']);
-      throw detailedError;
+      throw err;
     }
   }
 
@@ -788,15 +850,21 @@ class Task extends _events.default {
       });
       return result;
     } catch (error) {
-      const {
-        error: detailedError
-      } = (0, _Utils.getErrorDetails)(error, _constants2.METHODS.PAUSE_RECORDING, _constants.TASK_FILE);
+      const err = (0, _Utils.generateTaskErrorObject)(error, _constants2.METHODS.PAUSE_RECORDING, _constants.TASK_FILE);
+      const taskErrorProps = {
+        trackingId: err.data?.trackingId,
+        errorMessage: err.data?.message,
+        errorType: err.data?.errorType,
+        errorData: err.data?.errorData,
+        reasonCode: err.data?.reasonCode
+      };
       this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES.TASK_PAUSE_RECORDING_FAILED, {
         taskId: this.data.interactionId,
         error: error.toString(),
+        ...taskErrorProps,
         ..._MetricsManager.default.getCommonTrackingFieldForAQMResponseFailed(error.details || {})
       }, ['operational', 'behavioral', 'business']);
-      throw detailedError;
+      throw err;
     }
   }
 
@@ -864,15 +932,21 @@ class Task extends _events.default {
       });
       return result;
     } catch (error) {
-      const {
-        error: detailedError
-      } = (0, _Utils.getErrorDetails)(error, _constants2.METHODS.RESUME_RECORDING, _constants.TASK_FILE);
+      const err = (0, _Utils.generateTaskErrorObject)(error, _constants2.METHODS.RESUME_RECORDING, _constants.TASK_FILE);
+      const taskErrorProps = {
+        trackingId: err.data?.trackingId,
+        errorMessage: err.data?.message,
+        errorType: err.data?.errorType,
+        errorData: err.data?.errorData,
+        reasonCode: err.data?.reasonCode
+      };
       this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES.TASK_RESUME_RECORDING_FAILED, {
         taskId: this.data.interactionId,
         error: error.toString(),
+        ...taskErrorProps,
         ..._MetricsManager.default.getCommonTrackingFieldForAQMResponseFailed(error.details || {})
       }, ['operational', 'behavioral', 'business']);
-      throw detailedError;
+      throw err;
     }
   }
 
@@ -935,17 +1009,23 @@ class Task extends _events.default {
       });
       return result;
     } catch (error) {
-      const {
-        error: detailedError
-      } = (0, _Utils.getErrorDetails)(error, _constants2.METHODS.CONSULT, _constants.TASK_FILE);
+      const err = (0, _Utils.generateTaskErrorObject)(error, _constants2.METHODS.CONSULT, _constants.TASK_FILE);
+      const taskErrorProps = {
+        trackingId: err.data?.trackingId,
+        errorMessage: err.data?.message,
+        errorType: err.data?.errorType,
+        errorData: err.data?.errorData,
+        reasonCode: err.data?.reasonCode
+      };
       this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES.TASK_CONSULT_START_FAILED, {
         taskId: this.data.interactionId,
         destination: consultPayload.to,
         destinationType: consultPayload.destinationType,
         error: error.toString(),
+        ...taskErrorProps,
         ..._MetricsManager.default.getCommonTrackingFieldForAQMResponseFailed(error.details || {})
       }, ['operational', 'behavioral', 'business']);
-      throw detailedError;
+      throw err;
     }
   }
 
@@ -1006,15 +1086,21 @@ class Task extends _events.default {
       });
       return result;
     } catch (error) {
-      const {
-        error: detailedError
-      } = (0, _Utils.getErrorDetails)(error, _constants2.METHODS.END_CONSULT, _constants.TASK_FILE);
+      const err = (0, _Utils.generateTaskErrorObject)(error, _constants2.METHODS.END_CONSULT, _constants.TASK_FILE);
+      const taskErrorProps = {
+        trackingId: err.data?.trackingId,
+        errorMessage: err.data?.message,
+        errorType: err.data?.errorType,
+        errorData: err.data?.errorData,
+        reasonCode: err.data?.reasonCode
+      };
       this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES.TASK_CONSULT_END_FAILED, {
         taskId: this.data.interactionId,
         error: error.toString(),
+        ...taskErrorProps,
         ..._MetricsManager.default.getCommonTrackingFieldForAQMResponseFailed(error.details || {})
       }, ['operational', 'behavioral', 'business']);
-      throw detailedError;
+      throw err;
     }
   }
 
@@ -1083,18 +1169,24 @@ class Task extends _events.default {
       });
       return result;
     } catch (error) {
-      const {
-        error: detailedError
-      } = (0, _Utils.getErrorDetails)(error, _constants2.METHODS.TRANSFER, _constants.TASK_FILE);
+      const err = (0, _Utils.generateTaskErrorObject)(error, _constants2.METHODS.TRANSFER, _constants.TASK_FILE);
+      const taskErrorProps = {
+        trackingId: err.data?.trackingId,
+        errorMessage: err.data?.message,
+        errorType: err.data?.errorType,
+        errorData: err.data?.errorData,
+        reasonCode: err.data?.reasonCode
+      };
       this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES.TASK_TRANSFER_FAILED, {
         taskId: this.data.interactionId,
         destination: transferPayload.to,
         destinationType: transferPayload.destinationType,
         isConsultTransfer: false,
         error: error.toString(),
+        ...taskErrorProps,
         ..._MetricsManager.default.getCommonTrackingFieldForAQMResponseFailed(error.details || {})
       }, ['operational', 'behavioral', 'business']);
-      throw detailedError;
+      throw err;
     }
   }
 
@@ -1132,36 +1224,38 @@ class Task extends _events.default {
    */
   async consultTransfer(consultTransferPayload) {
     try {
-      _loggerProxy.default.info(`Initiating consult transfer to ${consultTransferPayload.to}`, {
+      // Get the destination agent ID using custom logic from participants data
+      const destAgentId = (0, _Utils.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');
+      }
+      _loggerProxy.default.info(`Initiating consult transfer to ${consultTransferPayload?.to || destAgentId}`, {
         module: _constants.TASK_FILE,
         method: _constants2.METHODS.CONSULT_TRANSFER,
         interactionId: this.data.interactionId
       });
+      // Obtain payload based on desktop logic using TaskData
+      const finalDestinationType = (0, _Utils.deriveConsultTransferDestinationType)(this.data);
 
-      // For queue destinations, use the destAgentId from task data
-      if (consultTransferPayload.destinationType === _types2.CONSULT_TRANSFER_DESTINATION_TYPE.QUEUE) {
-        if (!this.data.destAgentId) {
-          throw new Error('No agent has accepted this queue consult yet');
-        }
-
-        // Override the destination with the agent who accepted the queue consult
-        consultTransferPayload = {
-          to: this.data.destAgentId,
-          destinationType: _types2.CONSULT_TRANSFER_DESTINATION_TYPE.AGENT
-        };
-      }
+      // By default we always use the computed destAgentId as the target id
+      const consultTransferRequest = {
+        to: destAgentId,
+        destinationType: finalDestinationType
+      };
       const result = await this.contact.consultTransfer({
         interactionId: this.data.interactionId,
-        data: consultTransferPayload
+        data: consultTransferRequest
       });
       this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES.TASK_TRANSFER_SUCCESS, {
         taskId: this.data.interactionId,
-        destination: consultTransferPayload.to,
-        destinationType: consultTransferPayload.destinationType,
+        destination: consultTransferRequest.to,
+        destinationType: consultTransferRequest.destinationType,
         isConsultTransfer: true,
         ..._MetricsManager.default.getCommonTrackingFieldForAQMResponse(result)
       }, ['operational', 'behavioral', 'business']);
-      _loggerProxy.default.log(`Consult transfer completed successfully to ${consultTransferPayload.to}`, {
+      _loggerProxy.default.log(`Consult transfer completed successfully to ${consultTransferPayload?.to || destAgentId}`, {
         module: _constants.TASK_FILE,
         method: _constants2.METHODS.CONSULT_TRANSFER,
         trackingId: result.trackingId,
@@ -1169,18 +1263,255 @@ class Task extends _events.default {
       });
       return result;
     } catch (error) {
-      const {
-        error: detailedError
-      } = (0, _Utils.getErrorDetails)(error, _constants2.METHODS.CONSULT_TRANSFER, _constants.TASK_FILE);
+      const err = (0, _Utils.generateTaskErrorObject)(error, _constants2.METHODS.CONSULT_TRANSFER, _constants.TASK_FILE);
+      const taskErrorProps = {
+        trackingId: err.data?.trackingId,
+        errorMessage: err.data?.message,
+        errorType: err.data?.errorType,
+        errorData: err.data?.errorData,
+        reasonCode: err.data?.reasonCode
+      };
+      const failedDestinationType = (0, _Utils.deriveConsultTransferDestinationType)(this.data);
+      const failedDestAgentId = (0, _Utils.getDestinationAgentId)(this.data.interaction?.participants, this.data.agentId);
       this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES.TASK_TRANSFER_FAILED, {
         taskId: this.data.interactionId,
-        destination: consultTransferPayload.to,
-        destinationType: consultTransferPayload.destinationType,
+        destination: failedDestAgentId || '',
+        destinationType: failedDestinationType,
         isConsultTransfer: true,
         error: error.toString(),
+        ...taskErrorProps,
         ..._MetricsManager.default.getCommonTrackingFieldForAQMResponseFailed(error.details || {})
       }, ['operational', 'behavioral', 'business']);
-      throw detailedError;
+      throw err;
+    }
+  }
+
+  /**
+   * Starts a consultation conference by merging the consultation call with the main call
+   *
+   * Creates a three-way conference between the agent, customer, and consulted party
+   * Extracts required consultation data from the current task data
+   * On success, emits a `task:conferenceStarted` event
+   *
+   * @returns Promise<TaskResponse> - Response from the consultation conference API
+   * @throws Error if the operation fails or if consultation data is invalid
+   *
+   * @example
+   * ```typescript
+   * try {
+   *   await task.consultConference();
+   *   console.log('Conference started successfully');
+   * } catch (error) {
+   *   console.error('Failed to start conference:', error);
+   * }
+   * ```
+   */
+  async consultConference() {
+    // 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'
+    };
+    try {
+      _loggerProxy.default.info(`Initiating consult conference to ${consultationData.destAgentId}`, {
+        module: _constants.TASK_FILE,
+        method: _constants2.METHODS.CONSULT_CONFERENCE,
+        interactionId: this.data.interactionId
+      });
+      const paramsDataForConferenceV2 = (0, _Utils.buildConsultConferenceParamData)(consultationData, this.data.interactionId);
+      const response = await this.contact.consultConference({
+        interactionId: paramsDataForConferenceV2.interactionId,
+        data: paramsDataForConferenceV2.data
+      });
+
+      // Track success metrics (following consultTransfer pattern)
+      this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES.TASK_CONFERENCE_START_SUCCESS, {
+        taskId: this.data.interactionId,
+        destination: paramsDataForConferenceV2.data.to,
+        destinationType: paramsDataForConferenceV2.data.destinationType,
+        agentId: paramsDataForConferenceV2.data.agentId,
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponse(response)
+      }, ['operational', 'behavioral', 'business']);
+      _loggerProxy.default.log(`Consult conference started successfully`, {
+        module: _constants.TASK_FILE,
+        method: _constants2.METHODS.CONSULT_CONFERENCE,
+        interactionId: this.data.interactionId
+      });
+      return response;
+    } catch (error) {
+      const err = (0, _Utils.generateTaskErrorObject)(error, _constants2.METHODS.CONSULT_CONFERENCE, _constants.TASK_FILE);
+      const taskErrorProps = {
+        trackingId: err.data?.trackingId,
+        errorMessage: err.data?.message,
+        errorType: err.data?.errorType,
+        errorData: err.data?.errorData,
+        reasonCode: err.data?.reasonCode
+      };
+
+      // Track failure metrics (following consultTransfer pattern)
+      // Build conference data for error tracking using extracted data
+      const failedParamsData = (0, _Utils.buildConsultConferenceParamData)(consultationData, this.data.interactionId);
+      this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES.TASK_CONFERENCE_START_FAILED, {
+        taskId: this.data.interactionId,
+        destination: failedParamsData.data.to,
+        destinationType: failedParamsData.data.destinationType,
+        agentId: failedParamsData.data.agentId,
+        error: error.toString(),
+        ...taskErrorProps,
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponseFailed(error.details || {})
+      }, ['operational', 'behavioral', 'business']);
+      _loggerProxy.default.error(`Failed to start consult conference`, {
+        module: _constants.TASK_FILE,
+        method: _constants2.METHODS.CONSULT_CONFERENCE,
+        interactionId: this.data.interactionId
+      });
+      throw err;
+    }
+  }
+
+  /**
+   * Exits the current conference by removing the agent from the conference call
+   *
+   * Exits the agent from the conference, leaving the customer and consulted party connected
+   * On success, emits a `task:conferenceEnded` event
+   *
+   * @returns Promise<TaskResponse> - Response from the conference exit API
+   * @throws Error if the operation fails or if no active conference exists
+   *
+   * @example
+   * ```typescript
+   * try {
+   *   await task.exitConference();
+   *   console.log('Successfully exited conference');
+   * } catch (error) {
+   *   console.error('Failed to exit conference:', error);
+   * }
+   * ```
+   */
+  async exitConference() {
+    try {
+      _loggerProxy.default.info(`Exiting consult conference`, {
+        module: _constants.TASK_FILE,
+        method: _constants2.METHODS.EXIT_CONFERENCE,
+        interactionId: this.data.interactionId
+      });
+
+      // Validate that interaction ID exists
+      if (!this.data.interactionId) {
+        throw new Error('Invalid interaction ID');
+      }
+      const response = await this.contact.exitConference({
+        interactionId: this.data.interactionId
+      });
+
+      // Track success metrics (following consultTransfer pattern)
+      this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES.TASK_CONFERENCE_END_SUCCESS, {
+        taskId: this.data.interactionId,
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponse(response)
+      }, ['operational', 'behavioral', 'business']);
+      _loggerProxy.default.log(`Consult conference exited successfully`, {
+        module: _constants.TASK_FILE,
+        method: _constants2.METHODS.EXIT_CONFERENCE,
+        interactionId: this.data.interactionId
+      });
+      return response;
+    } catch (error) {
+      const err = (0, _Utils.generateTaskErrorObject)(error, _constants2.METHODS.EXIT_CONFERENCE, _constants.TASK_FILE);
+      const taskErrorProps = {
+        trackingId: err.data?.trackingId,
+        errorMessage: err.data?.message,
+        errorType: err.data?.errorType,
+        errorData: err.data?.errorData,
+        reasonCode: err.data?.reasonCode
+      };
+
+      // Track failure metrics (following consultTransfer pattern)
+      this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES.TASK_CONFERENCE_END_FAILED, {
+        taskId: this.data.interactionId,
+        error: error.toString(),
+        ...taskErrorProps,
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponseFailed(error.details || {})
+      }, ['operational', 'behavioral', 'business']);
+      _loggerProxy.default.error(`Failed to exit consult conference`, {
+        module: _constants.TASK_FILE,
+        method: _constants2.METHODS.EXIT_CONFERENCE,
+        interactionId: this.data.interactionId
+      });
+      throw err;
+    }
+  }
+
+  /**
+   * Transfers the current conference to another agent
+   *
+   * Moves the entire conference (including all participants) to a new agent,
+   * while the current agent exits and goes to wrapup
+   * On success, the current agent receives `task:conferenceEnded` event
+   *
+   * @returns Promise<TaskResponse> - Response from the conference transfer API
+   * @throws Error if the operation fails or if no active conference exists
+   *
+   * @example
+   * ```typescript
+   * try {
+   *   await task.transferConference();
+   *   console.log('Conference transferred successfully');
+   * } catch (error) {
+   *   console.error('Failed to transfer conference:', error);
+   * }
+   * ```
+   */
+  async transferConference() {
+    try {
+      _loggerProxy.default.info(`Transferring conference`, {
+        module: _constants.TASK_FILE,
+        method: _constants2.METHODS.TRANSFER_CONFERENCE,
+        interactionId: this.data.interactionId
+      });
+
+      // Validate that interaction ID exists
+      if (!this.data.interactionId) {
+        throw new Error('Invalid interaction ID');
+      }
+      const response = await this.contact.conferenceTransfer({
+        interactionId: this.data.interactionId
+      });
+
+      // Track success metrics (following consultTransfer pattern)
+      this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES.TASK_CONFERENCE_TRANSFER_SUCCESS, {
+        taskId: this.data.interactionId,
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponse(response)
+      }, ['operational', 'behavioral', 'business']);
+      _loggerProxy.default.log(`Conference transferred successfully`, {
+        module: _constants.TASK_FILE,
+        method: _constants2.METHODS.TRANSFER_CONFERENCE,
+        interactionId: this.data.interactionId
+      });
+      return response;
+    } catch (error) {
+      const err = (0, _Utils.generateTaskErrorObject)(error, _constants2.METHODS.TRANSFER_CONFERENCE, _constants.TASK_FILE);
+      const taskErrorProps = {
+        trackingId: err.data?.trackingId,
+        errorMessage: err.data?.message,
+        errorType: err.data?.errorType,
+        errorData: err.data?.errorData,
+        reasonCode: err.data?.reasonCode
+      };
+
+      // Track failure metrics (following consultTransfer pattern)
+      this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES.TASK_CONFERENCE_TRANSFER_FAILED, {
+        taskId: this.data.interactionId,
+        error: error.toString(),
+        ...taskErrorProps,
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponseFailed(error.details || {})
+      }, ['operational', 'behavioral', 'business']);
+      _loggerProxy.default.error(`Failed to transfer conference`, {
+        module: _constants.TASK_FILE,
+        method: _constants2.METHODS.TRANSFER_CONFERENCE,
+        interactionId: this.data.interactionId
+      });
+      throw err;
     }
   }
 }