@webex/contact-center 0.0.0-next.1

package/dist/services/task/index.js

@@ -0,0 +1,1188 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _events = _interopRequireDefault(require("events"));
+var _calling = require("@webex/calling");
+var _Utils = require("../core/Utils");
+var _types = require("../../types");
+var _constants = require("../../constants");
+var _constants2 = require("./constants");
+var _loggerProxy = _interopRequireDefault(require("../../logger-proxy"));
+var _types2 = require("./types");
+var _MetricsManager = _interopRequireDefault(require("../../metrics/MetricsManager"));
+var _constants3 = require("../../metrics/constants");
+var _AutoWrapup = _interopRequireDefault(require("./AutoWrapup"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * Task class represents a contact center task/interaction that can be managed by an agent.
+ * This class provides all the necessary methods to manage tasks in a contact center environment,
+ * handling various call control operations and task lifecycle management.
+ *
+ * - Task Lifecycle Management:
+ *   - {@link accept} - Accept incoming task
+ *   - {@link decline} - Decline incoming task
+ *   - {@link end} - End active task
+ * - Media Controls:
+ *   - {@link toggleMute} - Mute/unmute microphone for voice tasks
+ *   - {@link hold} - Place task on hold
+ *   - {@link resume} - Resume held task
+ * - Recording Controls:
+ *   - {@link pauseRecording} - Pause task recording
+ *   - {@link resumeRecording} - Resume paused recording
+ * - Task Transfer & Consultation:
+ *   - {@link consult} - Initiate consultation with another agent/queue
+ *   - {@link endConsult} - End ongoing consultation
+ *   - {@link transfer} - Transfer task to another agent/queue
+ *   - {@link consultTransfer} - Transfer after consultation
+ * - Task Completion:
+ *   - {@link wrapup} - Complete task wrap-up
+ *
+ * Key events emitted by Task instances (see {@link TASK_EVENTS} for details):
+ *
+ * - Task Lifecycle:
+ *   - task:incoming — New task is being offered
+ *   - task:assigned — Task assigned to agent
+ *   - task:unassigned — Task unassigned from agent
+ *   - task:end — Task has ended
+ *   - task:wrapup — Task entered wrap-up state
+ *   - task:wrappedup — Task wrap-up completed
+ *   - task:rejected — Task was rejected/unanswered
+ *   - task:hydrate — Task data populated
+ *
+ * - Media & Controls:
+ *   - task:media — Voice call media track received
+ *   - task:hold — Task placed on hold
+ *   - task:unhold — Task resumed from hold
+ *
+ * - Consultation & Transfer:
+ *   - task:consultCreated — Consultation initiated
+ *   - task:consulting — Consultation in progress
+ *   - task:consultAccepted — Consultation accepted
+ *   - task:consultEnd — Consultation ended
+ *   - task:consultQueueCancelled — Queue consultation cancelled
+ *   - task:consultQueueFailed — Queue consultation failed
+ *   - task:offerConsult — Consultation offered
+ *   - task:offerContact — New contact offered
+ *
+ * - Recording:
+ *   - task:recordingPaused — Recording paused
+ *   - task:recordingPauseFailed — Recording pause failed
+ *   - task:recordingResumed — Recording resumed
+ *   - task:recordingResumeFailed — Recording resume failed
+ *
+ * @implements {ITask}
+ * @example
+ * ```typescript
+ * // 1. Initialize task
+ * const task = new Task(contact, webCallingService, taskData);
+ *
+ * // 2. Set up event listeners
+ * task.on('task:media', (track) => {
+ *   // Handle voice call media
+ *   const audioElement = document.getElementById('remote-audio');
+ *   audioElement.srcObject = new MediaStream([track]);
+ * });
+ *
+ * task.on('task:hold', () => {
+ *   console.log('Task is on hold');
+ *   // Update UI to show hold state
+ * });
+ *
+ * task.on('task:end', () => {
+ *   console.log('Task ended');
+ *   if (task.data.wrapUpRequired) {
+ *     // Show wrap-up form
+ *   }
+ * });
+ *
+ * // 3. Example task operations
+ * await task.accept(); // Accept incoming task
+ * await task.hold();   // Place on hold
+ * await task.resume(); // Resume from hold
+ * await task.end();    // End task
+ *
+ * // 4. Handle wrap-up if required
+ * await task.wrapup({
+ *   auxCodeId: 'RESOLVED',
+ *   wrapUpReason: 'Customer issue resolved'
+ * });
+ * ```
+ */
+
+class Task extends _events.default {
+  /**
+   * Creates a new Task instance which provides the following features:
+   * @param contact - The routing contact service instance
+   * @param webCallingService - The web calling service instance
+   * @param data - Initial task data
+   * @param wrapupData - Wrap-up configuration data
+   */
+  constructor(contact, webCallingService, data, wrapupData) {
+    super();
+    this.contact = contact;
+    this.data = data;
+    this.webCallingService = webCallingService;
+    this.webCallMap = {};
+    this.wrapupData = wrapupData;
+    this.metricsManager = _MetricsManager.default.getInstance();
+    this.registerWebCallListeners();
+    this.setupAutoWrapupTimer();
+  }
+
+  /**
+   * Sets up the automatic wrap-up timer if wrap-up is required
+   * @private
+   */
+  setupAutoWrapupTimer() {
+    if (this.data.wrapUpRequired &&
+    // only when wrapup required
+    !this.autoWrapup &&
+    // if autoWrapup is not already set
+    this.wrapupData &&
+    // wrapupData is not defined
+    this.wrapupData.wrapUpProps // wrapUpProps is defined
+    ) {
+      const wrapUpProps = this.wrapupData.wrapUpProps;
+      if (!wrapUpProps || wrapUpProps.autoWrapup === false) {
+        _loggerProxy.default.info(`Auto wrap-up is not required for this task`, {
+          module: _constants.TASK_FILE,
+          method: _constants2.METHODS.SETUP_AUTO_WRAPUP_TIMER,
+          interactionId: this.data.interactionId
+        });
+        return;
+      }
+      const defaultWrapupReason = wrapUpProps.wrapUpReasonList?.find(r => r.isDefault) ?? wrapUpProps.wrapUpReasonList?.[0];
+      if (!defaultWrapupReason) {
+        _loggerProxy.default.error('No wrap-up reason configured', {
+          module: _constants.TASK_FILE,
+          method: _constants2.METHODS.SETUP_AUTO_WRAPUP_TIMER
+        });
+        return;
+      }
+      const intervalMs = wrapUpProps.autoWrapupInterval;
+      if (!intervalMs || intervalMs <= 0) {
+        _loggerProxy.default.error(`Invalid auto wrap-up interval: ${intervalMs}`, {
+          module: _constants.TASK_FILE,
+          method: _constants2.METHODS.SETUP_AUTO_WRAPUP_TIMER
+        });
+      }
+      this.autoWrapup = new _AutoWrapup.default(intervalMs, wrapUpProps.allowCancelAutoWrapup);
+      this.autoWrapup.start(async () => {
+        _loggerProxy.default.info(`Auto wrap-up timer triggered`, {
+          module: _constants.TASK_FILE,
+          method: _constants2.METHODS.SETUP_AUTO_WRAPUP_TIMER,
+          interactionId: this.data.interactionId
+        });
+        await this.wrapup({
+          wrapUpReason: defaultWrapupReason.name,
+          auxCodeId: defaultWrapupReason.id
+        });
+      });
+    }
+  }
+
+  /**
+   * Cancels the automatic wrap-up timer if it's running
+   * @public - Public so it can be called externally when needed
+   * Note: This is supported only in single session mode. Not supported in multi-session mode.
+   */
+  cancelAutoWrapupTimer() {
+    this.autoWrapup?.clear();
+    this.autoWrapup = undefined;
+    _loggerProxy.default.info(`Auto wrap-up timer cancelled`, {
+      module: _constants.TASK_FILE,
+      method: _constants2.METHODS.CANCEL_AUTO_WRAPUP_TIMER,
+      interactionId: this.data?.interactionId
+    });
+  }
+
+  /**
+   * @ignore
+   * @private
+   */
+  handleRemoteMedia = track => {
+    this.emit(_types2.TASK_EVENTS.TASK_MEDIA, track);
+  };
+
+  /**
+   * @ignore
+   * @private
+   */
+  registerWebCallListeners() {
+    this.webCallingService.on(_calling.CALL_EVENT_KEYS.REMOTE_MEDIA, this.handleRemoteMedia);
+  }
+
+  /**
+   * @ignore
+   */
+  unregisterWebCallListeners() {
+    this.webCallingService.off(_calling.CALL_EVENT_KEYS.REMOTE_MEDIA, this.handleRemoteMedia);
+  }
+
+  /**
+   * Updates the task data with new information
+   * @param updatedData - New task data to merge with existing data
+   * @param shouldOverwrite - If true, completely replace data instead of merging
+   * @returns The updated task instance
+   * @example
+   * ```typescript
+   * task.updateTaskData(newData);
+   * task.updateTaskData(newData, true); // completely replace data
+   * ```
+   */
+  updateTaskData = (updatedData, shouldOverwrite = false) => {
+    this.data = shouldOverwrite ? updatedData : this.reconcileData(this.data, updatedData);
+    this.setupAutoWrapupTimer();
+    return this;
+  };
+
+  /**
+   * Recursively merges old data with new data
+   * @private
+   */
+  reconcileData(oldData, 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]);
+      } else {
+        oldData[key] = newData[key];
+      }
+    });
+    return oldData;
+  }
+
+  /**
+   * Agent accepts the incoming task.
+   * After accepting, the task will emit task:assigned event and for voice calls,
+   * a task:media event with the audio stream.
+   *
+   * @returns Promise<TaskResponse>
+   * @throws Error if accepting task fails or media requirements not met
+   * @example
+   * ```typescript
+   * // Set up event handlers before accepting
+   * task.on(TASK_EVENTS.TASK_ASSIGNED, () => {
+   *   console.log('Task assigned, ID:', task.data.interactionId);
+   *   // Update UI to show active task
+   * });
+   *
+   * // For voice calls, handle media
+   * task.on(TASK_EVENTS.TASK_MEDIA, (track) => {
+   *   const audioElement = document.getElementById('remote-audio');
+   *   audioElement.srcObject = new MediaStream([track]);
+   * });
+   *
+   * // Accept the task
+   * try {
+   *   await task.accept();
+   *   console.log('Successfully accepted task');
+   * } catch (error) {
+   *   console.error('Failed to accept task:', error);
+   *   // Handle error (e.g., show error message to agent)
+   * }
+   * ```
+   */
+  async accept() {
+    try {
+      _loggerProxy.default.info(`Accepting task`, {
+        module: _constants.TASK_FILE,
+        method: _constants2.METHODS.ACCEPT,
+        interactionId: this.data.interactionId
+      });
+      this.metricsManager.timeEvent([_constants3.METRIC_EVENT_NAMES.TASK_ACCEPT_SUCCESS, _constants3.METRIC_EVENT_NAMES.TASK_ACCEPT_FAILED]);
+      if (this.data.interaction.mediaType !== _types2.MEDIA_CHANNEL.TELEPHONY) {
+        const response = await this.contact.accept({
+          interactionId: this.data.interactionId
+        });
+        _loggerProxy.default.log(`Task accepted successfully`, {
+          module: _constants.TASK_FILE,
+          method: _constants2.METHODS.ACCEPT,
+          trackingId: response.trackingId,
+          interactionId: this.data.interactionId
+        });
+        this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES.TASK_ACCEPT_SUCCESS, {
+          taskId: this.data.interactionId,
+          ..._MetricsManager.default.getCommonTrackingFieldForAQMResponse(this.data)
+        }, ['operational', 'behavioral', 'business']);
+        return response;
+      }
+      if (this.webCallingService.loginOption === _types.LoginOption.BROWSER) {
+        const constraints = {
+          audio: true
+        };
+        const localStream = await navigator.mediaDevices.getUserMedia(constraints);
+        const audioTrack = localStream.getAudioTracks()[0];
+        this.localAudioStream = new _calling.LocalMicrophoneStream(new MediaStream([audioTrack]));
+        this.webCallingService.answerCall(this.localAudioStream, this.data.interactionId);
+        this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES.TASK_ACCEPT_SUCCESS, {
+          taskId: this.data.interactionId,
+          ..._MetricsManager.default.getCommonTrackingFieldForAQMResponse(this.data)
+        }, ['operational', 'behavioral', 'business']);
+        _loggerProxy.default.log(`Task accepted successfully with webrtc calling`, {
+          module: _constants.TASK_FILE,
+          method: _constants2.METHODS.ACCEPT,
+          interactionId: this.data.interactionId
+        });
+      }
+      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);
+      this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES.TASK_ACCEPT_FAILED, {
+        taskId: this.data.interactionId,
+        error: error.toString(),
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponseFailed(error.details)
+      }, ['operational', 'behavioral', 'business']);
+      throw detailedError;
+    }
+  }
+
+  /**
+   * Agent can mute/unmute their microphone during a WebRTC task.
+   * This method toggles between muted and unmuted states for the local audio stream.
+   *
+   * @returns Promise<void> - Resolves when mute/unmute operation completes
+   * @throws Error if toggling mute state fails or audio stream is not available
+   * @example
+   * ```typescript
+   * // Toggle mute state
+   * task.toggleMute()
+   *   .then(() => console.log('Mute state toggled successfully'))
+   *   .catch(error => console.error('Failed to toggle mute:', error));
+   * ```
+   */
+  async toggleMute() {
+    try {
+      _loggerProxy.default.info(`Toggling mute state`, {
+        module: _constants.TASK_FILE,
+        method: _constants2.METHODS.TOGGLE_MUTE,
+        interactionId: this.data.interactionId
+      });
+      this.webCallingService.muteUnmuteCall(this.localAudioStream);
+      _loggerProxy.default.log(`Mute state toggled successfully isCallMuted: ${this.webCallingService.isCallMuted()}`, {
+        module: _constants.TASK_FILE,
+        method: _constants2.METHODS.TOGGLE_MUTE,
+        interactionId: this.data.interactionId
+      });
+      return Promise.resolve();
+    } catch (error) {
+      const {
+        error: detailedError
+      } = (0, _Utils.getErrorDetails)(error, _constants2.METHODS.TOGGLE_MUTE, _constants.TASK_FILE);
+      throw detailedError;
+    }
+  }
+
+  /**
+   * Declines the incoming task. This will reject the task and notify the routing system.
+   * For voice calls, this is equivalent to declining the incoming call.
+   *
+   * @returns Promise<TaskResponse>
+   * @throws Error if the decline operation fails
+   * @example
+   * ```typescript
+   * // Decline an incoming task
+   * task.decline()
+   *   .then(() => console.log('Task declined successfully'))
+   *   .catch(error => console.error('Failed to decline task:', error));
+   * ```
+   */
+  async decline() {
+    try {
+      _loggerProxy.default.info(`Declining task`, {
+        module: _constants.TASK_FILE,
+        method: _constants2.METHODS.DECLINE,
+        interactionId: this.data.interactionId
+      });
+      this.metricsManager.timeEvent([_constants3.METRIC_EVENT_NAMES.TASK_DECLINE_SUCCESS, _constants3.METRIC_EVENT_NAMES.TASK_DECLINE_FAILED]);
+      this.webCallingService.declineCall(this.data.interactionId);
+      this.unregisterWebCallListeners();
+      this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES.TASK_DECLINE_SUCCESS, {
+        taskId: this.data.interactionId
+      }, ['operational', 'behavioral']);
+      _loggerProxy.default.log(`Task declined successfully`, {
+        module: _constants.TASK_FILE,
+        method: _constants2.METHODS.DECLINE,
+        interactionId: this.data.interactionId
+      });
+      return Promise.resolve();
+    } catch (error) {
+      const {
+        error: detailedError
+      } = (0, _Utils.getErrorDetails)(error, _constants2.METHODS.DECLINE, _constants.TASK_FILE);
+      this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES.TASK_DECLINE_FAILED, {
+        taskId: this.data.interactionId,
+        error: error.toString(),
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponseFailed(error.details || {})
+      }, ['operational', 'behavioral']);
+      throw detailedError;
+    }
+  }
+
+  /**
+   * Puts the current task/interaction on hold.
+   * Emits task:hold event when successful. For voice tasks, this mutes the audio.
+   *
+   * @returns Promise<TaskResponse>
+   * @throws Error if hold operation fails
+   * @example
+   * ```typescript
+   * // Set up hold event handler
+   * task.on(TASK_EVENTS.TASK_HOLD, () => {
+   *   console.log('Task is now on hold');
+   *   // Update UI to show hold state (e.g., enable resume button, show hold indicator)
+   *   document.getElementById('resume-btn').disabled = false;
+   *   document.getElementById('hold-indicator').style.display = 'block';
+   * });
+   *
+   * // Place task on hold
+   * try {
+   *   await task.hold();
+   *   console.log('Successfully placed task on hold');
+   * } catch (error) {
+   *   console.error('Failed to place task on hold:', error);
+   *   // Handle error (e.g., show error message, reset UI state)
+   * }
+   * ```
+   */
+  async hold() {
+    try {
+      _loggerProxy.default.info(`Holding task`, {
+        module: _constants.TASK_FILE,
+        method: _constants2.METHODS.HOLD,
+        interactionId: this.data.interactionId
+      });
+      this.metricsManager.timeEvent([_constants3.METRIC_EVENT_NAMES.TASK_HOLD_SUCCESS, _constants3.METRIC_EVENT_NAMES.TASK_HOLD_FAILED]);
+      const response = await this.contact.hold({
+        interactionId: this.data.interactionId,
+        data: {
+          mediaResourceId: this.data.mediaResourceId
+        }
+      });
+      this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES.TASK_HOLD_SUCCESS, {
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponse(response),
+        taskId: this.data.interactionId,
+        mediaResourceId: this.data.mediaResourceId
+      }, ['operational', 'behavioral']);
+      _loggerProxy.default.log(`Task placed on hold successfully`, {
+        module: _constants.TASK_FILE,
+        method: _constants2.METHODS.HOLD,
+        trackingId: response.trackingId,
+        interactionId: this.data.interactionId
+      });
+      return response;
+    } catch (error) {
+      const {
+        error: detailedError
+      } = (0, _Utils.getErrorDetails)(error, _constants2.METHODS.HOLD, _constants.TASK_FILE);
+      this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES.TASK_HOLD_FAILED, {
+        taskId: this.data.interactionId,
+        mediaResourceId: this.data.mediaResourceId,
+        error: error.toString(),
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponseFailed(error.details || {})
+      }, ['operational', 'behavioral']);
+      throw detailedError;
+    }
+  }
+
+  /**
+   * Resumes the task/interaction that was previously put on hold.
+   * Emits task:resume event when successful. For voice tasks, this restores the audio.
+   *
+   * @returns Promise<TaskResponse>
+   * @throws Error if resume operation fails
+   * @example
+   * ```typescript
+   * // Set up resume event handler
+   * task.on(TASK_EVENTS.TASK_RESUME, () => {
+   *   console.log('Task resumed from hold');
+   *   // Update UI to show active state
+   *   document.getElementById('hold-btn').disabled = false;
+   *   document.getElementById('hold-indicator').style.display = 'none';
+   * });
+   *
+   * // Resume task from hold
+   * try {
+   *   await task.resume();
+   *   console.log('Successfully resumed task from hold');
+   * } catch (error) {
+   *   console.error('Failed to resume task:', error);
+   *   // Handle error (e.g., show error message)
+   * }
+   * ```
+   */
+  async resume() {
+    try {
+      _loggerProxy.default.info(`Resuming task`, {
+        module: _constants.TASK_FILE,
+        method: _constants2.METHODS.RESUME,
+        interactionId: this.data.interactionId
+      });
+      const {
+        mainInteractionId
+      } = this.data.interaction;
+      const {
+        mediaResourceId
+      } = this.data.interaction.media[mainInteractionId];
+      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
+        }
+      });
+      this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES.TASK_RESUME_SUCCESS, {
+        taskId: this.data.interactionId,
+        mainInteractionId,
+        mediaResourceId,
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponse(response)
+      }, ['operational', 'behavioral']);
+      _loggerProxy.default.log(`Task resumed successfully`, {
+        module: _constants.TASK_FILE,
+        method: _constants2.METHODS.RESUME,
+        trackingId: response.trackingId,
+        interactionId: this.data.interactionId
+      });
+      return response;
+    } catch (error) {
+      const {
+        error: detailedError
+      } = (0, _Utils.getErrorDetails)(error, _constants2.METHODS.RESUME, _constants.TASK_FILE);
+      const mainInteractionId = this.data.interaction?.mainInteractionId;
+      this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES.TASK_RESUME_FAILED, {
+        taskId: this.data.interactionId,
+        mainInteractionId,
+        mediaResourceId: mainInteractionId ? this.data.interaction.media[mainInteractionId].mediaResourceId : '',
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponseFailed(error.details || {})
+      }, ['operational', 'behavioral']);
+      throw detailedError;
+    }
+  }
+
+  /**
+   * Ends the task/interaction with the customer.
+   * Emits task:end event when successful. If task requires wrap-up,
+   * this will be indicated in the task:end event data.
+   *
+   * @returns Promise<TaskResponse>
+   * @throws Error if ending task fails
+   * @example
+   * ```typescript
+   * // Set up task end event handler
+   * task.on(TASK_EVENTS.TASK_END, (data) => {
+   *   console.log('Task ended:', task.data.interactionId);
+   *
+   *   if (data.wrapUpRequired) {
+   *     // Show wrap-up form
+   *     showWrapupForm();
+   *   } else {
+   *     // Clean up and prepare for next task
+   *     cleanupTask();
+   *   }
+   * });
+   *
+   * // End the task
+   * try {
+   *   await task.end();
+   *   console.log('Task end request successful');
+   * } catch (error) {
+   *   console.error('Failed to end task:', error);
+   *   // Handle error (e.g., show error message, retry option)
+   * }
+   *
+   * function showWrapupForm() {
+   *   // Show wrap-up UI with required codes
+   *   document.getElementById('wrapup-form').style.display = 'block';
+   * }
+   *
+   * function cleanupTask() {
+   *   // Reset UI state
+   *   document.getElementById('active-task').style.display = 'none';
+   *   document.getElementById('controls').style.display = 'none';
+   * }
+   * ```
+   */
+  async end() {
+    try {
+      _loggerProxy.default.info(`Ending task`, {
+        module: _constants.TASK_FILE,
+        method: _constants2.METHODS.END,
+        interactionId: this.data.interactionId
+      });
+      this.metricsManager.timeEvent([_constants3.METRIC_EVENT_NAMES.TASK_END_SUCCESS, _constants3.METRIC_EVENT_NAMES.TASK_END_FAILED]);
+      const response = await this.contact.end({
+        interactionId: this.data.interactionId
+      });
+      this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES.TASK_END_SUCCESS, {
+        taskId: this.data.interactionId,
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponse(response)
+      }, ['operational', 'behavioral', 'business']);
+      _loggerProxy.default.log(`Task ended successfully`, {
+        module: _constants.TASK_FILE,
+        method: _constants2.METHODS.END,
+        trackingId: response.trackingId,
+        interactionId: this.data.interactionId
+      });
+      return response;
+    } catch (error) {
+      const {
+        error: detailedError
+      } = (0, _Utils.getErrorDetails)(error, _constants2.METHODS.END, _constants.TASK_FILE);
+      this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES.TASK_END_FAILED, {
+        taskId: this.data.interactionId,
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponseFailed(error.details || {})
+      }, ['operational', 'behavioral', 'business']);
+      throw detailedError;
+    }
+  }
+
+  /**
+   * Wraps up the task/interaction with the customer.
+   * This is called after task:end event if wrapUpRequired is true.
+   * Emits task:wrappedup event when successful.
+   *
+   * @param wrapupPayload - WrapupPayLoad containing:
+   *   - auxCodeId: Required ID for the wrap-up code
+   *   - wrapUpReason: Required description of wrap-up reason
+   * @returns Promise<TaskResponse>
+   * @throws Error if task data is unavailable, auxCodeId is missing, or wrapUpReason is missing
+   * @example
+   * ```typescript
+   * // Set up wrap-up events
+   * task.on(TASK_EVENTS.TASK_WRAPUP, () => {
+   *   console.log('Task ready for wrap-up');
+   *   // Show wrap-up form
+   *   document.getElementById('wrapup-form').style.display = 'block';
+   * });
+   *
+   * task.on(TASK_EVENTS.TASK_WRAPPEDUP, () => {
+   *   console.log('Task wrap-up completed');
+   *   // Clean up UI
+   *   document.getElementById('wrapup-form').style.display = 'none';
+   * });
+   *
+   * // Submit wrap-up
+   * try {
+   *   const wrapupPayload = {
+   *     auxCodeId: selectedCode, // e.g., 'ISSUE_RESOLVED'
+   *     wrapUpReason: 'Customer issue resolved successfully'
+   *   };
+   *   await task.wrapup(wrapupPayload);
+   *   console.log('Successfully submitted wrap-up');
+   * } catch (error) {
+   *   console.error('Failed to submit wrap-up:', error);
+   *   // Handle validation errors
+   *   if (error.message.includes('required')) {
+   *     // Show validation error to agent
+   *   }
+   * }
+   * ```
+   */
+  async wrapup(wrapupPayload) {
+    try {
+      this.cancelAutoWrapupTimer();
+      _loggerProxy.default.info(`Wrapping up task`, {
+        module: _constants.TASK_FILE,
+        method: _constants2.METHODS.WRAPUP,
+        interactionId: this.data.interactionId
+      });
+      this.metricsManager.timeEvent([_constants3.METRIC_EVENT_NAMES.TASK_WRAPUP_SUCCESS, _constants3.METRIC_EVENT_NAMES.TASK_WRAPUP_FAILED]);
+      if (!this.data) {
+        throw new Error('No task data available');
+      }
+      if (!wrapupPayload.auxCodeId || wrapupPayload.auxCodeId.length === 0) {
+        throw new Error('AuxCodeId is required');
+      }
+      if (!wrapupPayload.wrapUpReason || wrapupPayload.wrapUpReason.length === 0) {
+        throw new Error('WrapUpReason is required');
+      }
+      const response = await this.contact.wrapup({
+        interactionId: this.data.interactionId,
+        data: wrapupPayload
+      });
+      this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES.TASK_WRAPUP_SUCCESS, {
+        taskId: this.data.interactionId,
+        wrapUpCode: wrapupPayload.auxCodeId,
+        wrapUpReason: wrapupPayload.wrapUpReason,
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponse(response)
+      }, ['operational', 'behavioral', 'business']);
+      _loggerProxy.default.log(`Task wrapped up successfully`, {
+        module: _constants.TASK_FILE,
+        method: _constants2.METHODS.WRAPUP,
+        trackingId: response.trackingId,
+        interactionId: this.data.interactionId
+      });
+      return response;
+    } catch (error) {
+      const {
+        error: detailedError
+      } = (0, _Utils.getErrorDetails)(error, _constants2.METHODS.WRAPUP, _constants.TASK_FILE);
+      this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES.TASK_WRAPUP_FAILED, {
+        taskId: this.data.interactionId,
+        wrapUpCode: wrapupPayload.auxCodeId,
+        wrapUpReason: wrapupPayload.wrapUpReason,
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponseFailed(error.details || {})
+      }, ['operational', 'behavioral', 'business']);
+      throw detailedError;
+    }
+  }
+
+  /**
+   * Pauses the recording for the current voice task.
+   * Emits task:recordingPaused event when successful.
+   *
+   * @returns Promise<TaskResponse>
+   * @throws Error if pause recording fails
+   * @example
+   * ```typescript
+   * // Set up recording events
+   * task.on(TASK_EVENTS.TASK_RECORDING_PAUSED, () => {
+   *   console.log('Recording paused');
+   *   // Update UI to show recording paused state
+   *   document.getElementById('recording-status').textContent = 'Recording Paused';
+   *   document.getElementById('pause-recording-btn').style.display = 'none';
+   *   document.getElementById('resume-recording-btn').style.display = 'block';
+   * });
+   *
+   * task.on(TASK_EVENTS.TASK_RECORDING_PAUSE_FAILED, (error) => {
+   *   console.error('Failed to pause recording:', error);
+   *   // Show error to agent
+   * });
+   *
+   * // Pause recording
+   * try {
+   *   await task.pauseRecording();
+   *   console.log('Pause recording request sent');
+   * } catch (error) {
+   *   console.error('Error sending pause recording request:', error);
+   *   // Handle error
+   * }
+   * ```
+   */
+  async pauseRecording() {
+    try {
+      _loggerProxy.default.info(`Pausing recording`, {
+        module: _constants.TASK_FILE,
+        method: _constants2.METHODS.PAUSE_RECORDING,
+        interactionId: this.data.interactionId
+      });
+      this.metricsManager.timeEvent([_constants3.METRIC_EVENT_NAMES.TASK_PAUSE_RECORDING_SUCCESS, _constants3.METRIC_EVENT_NAMES.TASK_PAUSE_RECORDING_FAILED]);
+      const result = await this.contact.pauseRecording({
+        interactionId: this.data.interactionId
+      });
+      this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES.TASK_PAUSE_RECORDING_SUCCESS, {
+        taskId: this.data.interactionId,
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponse(result)
+      }, ['operational', 'behavioral', 'business']);
+      _loggerProxy.default.log(`Recording paused successfully`, {
+        module: _constants.TASK_FILE,
+        method: _constants2.METHODS.PAUSE_RECORDING,
+        trackingId: result.trackingId,
+        interactionId: this.data.interactionId
+      });
+      return result;
+    } catch (error) {
+      const {
+        error: detailedError
+      } = (0, _Utils.getErrorDetails)(error, _constants2.METHODS.PAUSE_RECORDING, _constants.TASK_FILE);
+      this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES.TASK_PAUSE_RECORDING_FAILED, {
+        taskId: this.data.interactionId,
+        error: error.toString(),
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponseFailed(error.details || {})
+      }, ['operational', 'behavioral', 'business']);
+      throw detailedError;
+    }
+  }
+
+  /**
+   * Resumes the recording for the voice task that was previously paused.
+   * Emits task:recordingResumed event when successful.
+   *
+   * @param resumeRecordingPayload - Configuration for resuming recording:
+   *   - autoResumed: Indicates if resume was automatic (defaults to false)
+   * @returns Promise<TaskResponse>
+   * @throws Error if resume recording fails
+   * @example
+   * ```typescript
+   * // Set up recording resume events
+   * task.on(TASK_EVENTS.TASK_RECORDING_RESUMED, () => {
+   *   console.log('Recording resumed');
+   *   // Update UI to show active recording state
+   *   document.getElementById('recording-status').textContent = 'Recording Active';
+   *   document.getElementById('pause-recording-btn').style.display = 'block';
+   *   document.getElementById('resume-recording-btn').style.display = 'none';
+   * });
+   *
+   * task.on(TASK_EVENTS.TASK_RECORDING_RESUME_FAILED, (error) => {
+   *   console.error('Failed to resume recording:', error);
+   *   // Show error to agent
+   * });
+   *
+   * // Resume recording
+   * try {
+   *   const resumePayload = {
+   *     autoResumed: false // Set to true if triggered by system
+   *   };
+   *   await task.resumeRecording(resumePayload);
+   *   console.log('Resume recording request sent');
+   * } catch (error) {
+   *   console.error('Error sending resume recording request:', error);
+   *   // Handle error
+   * }
+   * ```
+   */
+  async resumeRecording(resumeRecordingPayload) {
+    try {
+      _loggerProxy.default.info(`Resuming recording`, {
+        module: _constants.TASK_FILE,
+        method: _constants2.METHODS.RESUME_RECORDING,
+        interactionId: this.data.interactionId
+      });
+      this.metricsManager.timeEvent([_constants3.METRIC_EVENT_NAMES.TASK_RESUME_RECORDING_SUCCESS, _constants3.METRIC_EVENT_NAMES.TASK_RESUME_RECORDING_FAILED]);
+      resumeRecordingPayload ??= {
+        autoResumed: false
+      };
+      const result = await this.contact.resumeRecording({
+        interactionId: this.data.interactionId,
+        data: resumeRecordingPayload
+      });
+      this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES.TASK_RESUME_RECORDING_SUCCESS, {
+        taskId: this.data.interactionId,
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponse(result)
+      }, ['operational', 'behavioral', 'business']);
+      _loggerProxy.default.log(`Recording resumed successfully`, {
+        module: _constants.TASK_FILE,
+        method: _constants2.METHODS.RESUME_RECORDING,
+        trackingId: result.trackingId,
+        interactionId: this.data.interactionId
+      });
+      return result;
+    } catch (error) {
+      const {
+        error: detailedError
+      } = (0, _Utils.getErrorDetails)(error, _constants2.METHODS.RESUME_RECORDING, _constants.TASK_FILE);
+      this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES.TASK_RESUME_RECORDING_FAILED, {
+        taskId: this.data.interactionId,
+        error: error.toString(),
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponseFailed(error.details || {})
+      }, ['operational', 'behavioral', 'business']);
+      throw detailedError;
+    }
+  }
+
+  /**
+   * Consults another agent or queue on an ongoing task for further assistance.
+   * During consultation, the original customer is typically placed on hold while
+   * the agent seeks guidance from another agent or queue.
+   *
+   * @param consultPayload - Configuration for the consultation containing:
+   *   - to: ID of the agent or queue to consult with
+   *   - destinationType: Type of destination (AGENT, QUEUE, etc.)
+   *   - holdParticipants: Whether to hold other participants (defaults to true)
+   * @returns Promise<TaskResponse> - Resolves with consultation result
+   * @throws Error if consultation fails or invalid parameters provided
+   * @example
+   * ```typescript
+   * // Consult with another agent
+   * const consultPayload = {
+   *   to: 'agentId123',
+   *   destinationType: DESTINATION_TYPE.AGENT,
+   *   holdParticipants: true
+   * };
+   * task.consult(consultPayload)
+   *   .then(response => console.log('Consultation started successfully'))
+   *   .catch(error => console.error('Failed to start consultation:', error));
+   *
+   * // Consult with a queue
+   * const queueConsultPayload = {
+   *   to: 'salesQueue123',
+   *   destinationType: DESTINATION_TYPE.QUEUE
+   * };
+   * task.consult(queueConsultPayload)
+   *   .then(response => console.log('Queue consultation started'))
+   *   .catch(error => console.error('Failed to start queue consultation:', error));
+   * ```
+   */
+  async consult(consultPayload) {
+    try {
+      _loggerProxy.default.info(`Starting consult`, {
+        module: _constants.TASK_FILE,
+        method: _constants2.METHODS.CONSULT,
+        interactionId: this.data.interactionId
+      });
+      this.metricsManager.timeEvent([_constants3.METRIC_EVENT_NAMES.TASK_CONSULT_START_SUCCESS, _constants3.METRIC_EVENT_NAMES.TASK_CONSULT_START_FAILED]);
+      const result = await this.contact.consult({
+        interactionId: this.data.interactionId,
+        data: consultPayload
+      });
+      this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES.TASK_CONSULT_START_SUCCESS, {
+        taskId: this.data.interactionId,
+        destination: consultPayload.to,
+        destinationType: consultPayload.destinationType,
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponse(result)
+      }, ['operational', 'behavioral', 'business']);
+      _loggerProxy.default.log(`Consult started successfully to ${consultPayload.to}`, {
+        module: _constants.TASK_FILE,
+        method: _constants2.METHODS.CONSULT,
+        trackingId: result.trackingId,
+        interactionId: this.data.interactionId
+      });
+      return result;
+    } catch (error) {
+      const {
+        error: detailedError
+      } = (0, _Utils.getErrorDetails)(error, _constants2.METHODS.CONSULT, _constants.TASK_FILE);
+      this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES.TASK_CONSULT_START_FAILED, {
+        taskId: this.data.interactionId,
+        destination: consultPayload.to,
+        destinationType: consultPayload.destinationType,
+        error: error.toString(),
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponseFailed(error.details || {})
+      }, ['operational', 'behavioral', 'business']);
+      throw detailedError;
+    }
+  }
+
+  /**
+   * Ends an ongoing consultation session for the task.
+   * This terminates the consultation while maintaining the original customer connection.
+   *
+   * @param consultEndPayload - Configuration for ending the consultation containing:
+   *   - isConsult: Must be true to indicate this is a consultation end
+   *   - taskId: ID of the task being consulted on
+   *   - queueId: (Optional) Queue ID if this was a queue consultation
+   *   - isSecondaryEpDnAgent: (Optional) Indicates if this involves a secondary entry point
+   * @returns Promise<TaskResponse> - Resolves when consultation is ended
+   * @throws Error if ending consultation fails or invalid parameters provided
+   * @example
+   * ```typescript
+   * // End a direct agent consultation
+   * const consultEndPayload = {
+   *   isConsult: true,
+   *   taskId: 'task123'
+   * };
+   * task.endConsult(consultEndPayload)
+   *   .then(response => console.log('Consultation ended successfully'))
+   *   .catch(error => console.error('Failed to end consultation:', error));
+   *
+   * // End a queue consultation
+   * const queueConsultEndPayload = {
+   *   isConsult: true,
+   *   taskId: 'task123',
+   *   queueId: 'queue123'
+   * };
+   * task.endConsult(queueConsultEndPayload)
+   *   .then(response => console.log('Queue consultation ended'))
+   *   .catch(error => console.error('Failed to end queue consultation:', error));
+   * ```
+   */
+  async endConsult(consultEndPayload) {
+    try {
+      _loggerProxy.default.info(`Ending consult`, {
+        module: _constants.TASK_FILE,
+        method: _constants2.METHODS.END_CONSULT,
+        interactionId: this.data.interactionId
+      });
+      this.metricsManager.timeEvent([_constants3.METRIC_EVENT_NAMES.TASK_CONSULT_END_SUCCESS, _constants3.METRIC_EVENT_NAMES.TASK_CONSULT_END_FAILED]);
+      const result = await this.contact.consultEnd({
+        interactionId: this.data.interactionId,
+        data: consultEndPayload
+      });
+      this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES.TASK_CONSULT_END_SUCCESS, {
+        taskId: this.data.interactionId,
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponse(result)
+      }, ['operational', 'behavioral', 'business']);
+      _loggerProxy.default.log(`Consult ended successfully`, {
+        module: _constants.TASK_FILE,
+        method: _constants2.METHODS.END_CONSULT,
+        trackingId: result.trackingId,
+        interactionId: this.data.interactionId
+      });
+      return result;
+    } catch (error) {
+      const {
+        error: detailedError
+      } = (0, _Utils.getErrorDetails)(error, _constants2.METHODS.END_CONSULT, _constants.TASK_FILE);
+      this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES.TASK_CONSULT_END_FAILED, {
+        taskId: this.data.interactionId,
+        error: error.toString(),
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponseFailed(error.details || {})
+      }, ['operational', 'behavioral', 'business']);
+      throw detailedError;
+    }
+  }
+
+  /**
+   * Transfer the task to an agent directly or to a queue.
+   * This is a blind transfer that immediately redirects the task to the specified destination.
+   *
+   * @param transferPayload - Transfer configuration containing:
+   *   - to: ID of the agent or queue to transfer to
+   *   - destinationType: Type of destination (AGENT, QUEUE, etc.)
+   * @returns Promise<TaskResponse> - Resolves when transfer is completed
+   * @throws Error if transfer fails or invalid parameters provided
+   * @example
+   * ```typescript
+   * // Transfer to a queue
+   * const queueTransferPayload = {
+   *   to: 'salesQueue123',
+   *   destinationType: DESTINATION_TYPE.QUEUE
+   * };
+   * task.transfer(queueTransferPayload)
+   *   .then(response => console.log('Task transferred to queue successfully'))
+   *   .catch(error => console.error('Failed to transfer to queue:', error));
+   *
+   * // Transfer to an agent
+   * const agentTransferPayload = {
+   *   to: 'agentId123',
+   *   destinationType: DESTINATION_TYPE.AGENT
+   * };
+   * task.transfer(agentTransferPayload)
+   *   .then(response => console.log('Task transferred to agent successfully'))
+   *   .catch(error => console.error('Failed to transfer to agent:', error));
+   * ```
+   */
+  async transfer(transferPayload) {
+    try {
+      _loggerProxy.default.info(`Transferring task to ${transferPayload.to}`, {
+        module: _constants.TASK_FILE,
+        method: _constants2.METHODS.TRANSFER,
+        interactionId: this.data.interactionId
+      });
+      this.metricsManager.timeEvent([_constants3.METRIC_EVENT_NAMES.TASK_TRANSFER_SUCCESS, _constants3.METRIC_EVENT_NAMES.TASK_TRANSFER_FAILED]);
+      let result;
+      if (transferPayload.destinationType === _types2.DESTINATION_TYPE.QUEUE) {
+        result = await this.contact.vteamTransfer({
+          interactionId: this.data.interactionId,
+          data: transferPayload
+        });
+      } else {
+        result = await this.contact.blindTransfer({
+          interactionId: this.data.interactionId,
+          data: transferPayload
+        });
+      }
+      this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES.TASK_TRANSFER_SUCCESS, {
+        taskId: this.data.interactionId,
+        destination: transferPayload.to,
+        destinationType: transferPayload.destinationType,
+        isConsultTransfer: false,
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponse(result)
+      }, ['operational', 'behavioral', 'business']);
+      _loggerProxy.default.log(`Task transferred successfully to ${transferPayload.to}`, {
+        module: _constants.TASK_FILE,
+        method: _constants2.METHODS.TRANSFER,
+        trackingId: result.trackingId,
+        interactionId: this.data.interactionId
+      });
+      return result;
+    } catch (error) {
+      const {
+        error: detailedError
+      } = (0, _Utils.getErrorDetails)(error, _constants2.METHODS.TRANSFER, _constants.TASK_FILE);
+      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(),
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponseFailed(error.details || {})
+      }, ['operational', 'behavioral', 'business']);
+      throw detailedError;
+    }
+  }
+
+  /**
+   * Transfer the task to the party that was consulted.
+   * This completes a consultative transfer where the agent first consulted with the target
+   * before transferring the task. For queue consultations, the transfer is automatically
+   * directed to the agent who accepted the consultation.
+   *
+   * @param consultTransferPayload - Configuration for the consultation transfer containing:
+   *   - to: ID of the agent or queue to transfer to
+   *   - destinationType: Type of destination (AGENT, QUEUE, etc. from CONSULT_TRANSFER_DESTINATION_TYPE)
+   * @returns Promise<TaskResponse> - Resolves when consultation transfer is completed
+   * @throws Error if transfer fails, no agent has accepted a queue consultation, or other validation errors
+   * @example
+   * ```typescript
+   * // Complete consultation transfer to an agent
+   * const agentConsultTransfer = {
+   *   to: 'agentId123',
+   *   destinationType: CONSULT_TRANSFER_DESTINATION_TYPE.AGENT
+   * };
+   * task.consultTransfer(agentConsultTransfer)
+   *   .then(response => console.log('Consultation transfer to agent completed'))
+   *   .catch(error => console.error('Failed to complete agent consultation transfer:', error));
+   *
+   * // Complete consultation transfer to a queue agent
+   * const queueConsultTransfer = {
+   *   to: 'queue123',
+   *   destinationType: CONSULT_TRANSFER_DESTINATION_TYPE.QUEUE
+   * };
+   * task.consultTransfer(queueConsultTransfer)
+   *   .then(response => console.log('Consultation transfer to queue agent completed'))
+   *   .catch(error => console.error('Failed to complete queue consultation transfer:', error));
+   * ```
+   */
+  async consultTransfer(consultTransferPayload) {
+    try {
+      _loggerProxy.default.info(`Initiating consult transfer to ${consultTransferPayload.to}`, {
+        module: _constants.TASK_FILE,
+        method: _constants2.METHODS.CONSULT_TRANSFER,
+        interactionId: this.data.interactionId
+      });
+
+      // 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
+        };
+      }
+      const result = await this.contact.consultTransfer({
+        interactionId: this.data.interactionId,
+        data: consultTransferPayload
+      });
+      this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES.TASK_TRANSFER_SUCCESS, {
+        taskId: this.data.interactionId,
+        destination: consultTransferPayload.to,
+        destinationType: consultTransferPayload.destinationType,
+        isConsultTransfer: true,
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponse(result)
+      }, ['operational', 'behavioral', 'business']);
+      _loggerProxy.default.log(`Consult transfer completed successfully to ${consultTransferPayload.to}`, {
+        module: _constants.TASK_FILE,
+        method: _constants2.METHODS.CONSULT_TRANSFER,
+        trackingId: result.trackingId,
+        interactionId: this.data.interactionId
+      });
+      return result;
+    } catch (error) {
+      const {
+        error: detailedError
+      } = (0, _Utils.getErrorDetails)(error, _constants2.METHODS.CONSULT_TRANSFER, _constants.TASK_FILE);
+      this.metricsManager.trackEvent(_constants3.METRIC_EVENT_NAMES.TASK_TRANSFER_FAILED, {
+        taskId: this.data.interactionId,
+        destination: consultTransferPayload.to,
+        destinationType: consultTransferPayload.destinationType,
+        isConsultTransfer: true,
+        error: error.toString(),
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponseFailed(error.details || {})
+      }, ['operational', 'behavioral', 'business']);
+      throw detailedError;
+    }
+  }
+}
+exports.default = Task;
+//# sourceMappingURL=index.js.map