@webex/contact-center 3.11.0 → 3.12.0-llmrefactor.2

package/dist/services/task/voice/Voice.js

@@ -0,0 +1,1044 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _constants = require("../../../constants");
+var _Utils = require("../../core/Utils");
+var _types = require("../types");
+var _Task = _interopRequireDefault(require("../Task"));
+var _loggerProxy = _interopRequireDefault(require("../../../logger-proxy"));
+var _MetricsManager = _interopRequireDefault(require("../../../metrics/MetricsManager"));
+var _constants2 = require("../../../metrics/constants");
+var _stateMachine = require("../state-machine");
+var _TaskUtils = require("../TaskUtils");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class Voice extends _Task.default {
+  constructor(contact, data, callOptions, wrapupData, agentId) {
+    const resolvedOptions = {
+      isEndTaskEnabled: callOptions?.isEndTaskEnabled ?? true,
+      isEndConsultEnabled: callOptions?.isEndConsultEnabled ?? true,
+      voiceVariant: callOptions?.voiceVariant ?? _types.VOICE_VARIANT.PSTN,
+      isRecordingEnabled: callOptions?.isRecordingEnabled ?? true
+    };
+    super(contact, data, {
+      ...resolvedOptions
+    }, wrapupData, agentId);
+  }
+  getStateMachineSnapshot() {
+    return this.stateMachineService?.getSnapshot?.();
+  }
+
+  /**
+   * This method is used to accept the task.
+   * It is expected to be overridden by child classes.
+   * @returns Promise<TaskResponse>
+   * @throws Error
+   */
+  async accept() {
+    super.unsupportedMethodError(_constants.METHODS.ACCEPT);
+  }
+
+  /**
+   * This method is used to decline the task.
+   * It is expected to be overridden by child classes.
+   * @returns Promise<TaskResponse>
+   * @throws Error
+   */
+  async decline() {
+    super.unsupportedMethodError(_constants.METHODS.REJECT);
+  }
+
+  /**
+   * This is used to hold the task.
+   * @returns Promise<TaskResponse>
+   * @throws Error
+   * @example
+   * ```typescript
+   * task.hold().then(()=>{}).catch(()=>{})
+   * ```
+   * */
+  async hold() {
+    return this.holdResume();
+  }
+
+  /**
+   * This is used to resume the task.
+   * @returns Promise<TaskResponse>
+   * @throws Error
+   * @example
+   * ```typescript
+   * task.resume().then(()=>{}).catch(()=>{})
+   * ```
+   * */
+  async resume() {
+    return this.holdResume();
+  }
+
+  /**
+   * This is used to hold or resume the task.
+   * @param isHeld: boolean - true to hold the task, false to resume it
+   * @returns Promise<TaskResponse>
+   * @throws Error
+   * @example
+   * ```typescript
+   * task.holdResume(isHeld: true).then(()=>{}).catch(()=>{})
+   * ```
+   * */
+  async holdResume() {
+    /* 
+    Determine if the task is being held or resumed based on the media resource state
+    If the media resource is not found, default to resuming the task
+    */
+    const snapshot = this.getStateMachineSnapshot();
+    const snapshotState = snapshot?.value;
+    const mainInteractionId = this.data.interaction?.mainInteractionId || this.data.interactionId;
+    const mainMediaResource = this.data.interaction?.media?.[mainInteractionId]?.mediaResourceId || this.data.mediaResourceId;
+    const mediaHoldState = this.data.interaction?.media?.[mainInteractionId]?.isHold ?? this.data.interaction.media?.[mainMediaResource]?.isHold;
+    let shouldHold = !(mediaHoldState ?? false);
+    if (snapshotState === _stateMachine.TaskState.HELD || snapshotState === _stateMachine.TaskState.RESUME_INITIATING) {
+      shouldHold = false;
+    } else if (snapshotState === _stateMachine.TaskState.CONNECTED && mediaHoldState !== true) {
+      // CONNECTED with isHold:true can happen after consult RONA/decline when event ordering
+      // leaves the machine in CONNECTED while main media is still on hold — resume on first click.
+      shouldHold = true;
+    }
+
+    // Validate operation is allowed in current state
+    const state = snapshot;
+    if (state) {
+      const currentState = state.value;
+      if (shouldHold) {
+        if (!state.matches(_stateMachine.TaskState.CONNECTED)) {
+          const error = new Error(`Cannot hold call in current state: ${currentState}`);
+          _loggerProxy.default.error('Hold operation not allowed', {
+            module: _constants.CC_FILE,
+            method: _constants.METHODS.HOLD_RESUME,
+            interactionId: this.data.interactionId
+          });
+          throw error;
+        }
+      } else if (!state.matches(_stateMachine.TaskState.HELD) && !(state.matches(_stateMachine.TaskState.CONFERENCING) && mediaHoldState === true) && !(state.matches(_stateMachine.TaskState.CONNECTED) && mediaHoldState === true)) {
+        const error = new Error(`Cannot resume call in current state: ${currentState}`);
+        _loggerProxy.default.error('Resume operation not allowed', {
+          module: _constants.CC_FILE,
+          method: _constants.METHODS.HOLD_RESUME,
+          interactionId: this.data.interactionId
+        });
+        throw error;
+      }
+    }
+
+    // Send initiating event to transition to intermediate state
+    if (this.stateMachineService) {
+      const initiatingEvent = shouldHold ? _stateMachine.TaskEvent.HOLD_INITIATED : _stateMachine.TaskEvent.UNHOLD_INITIATED;
+      this.stateMachineService.send({
+        type: initiatingEvent,
+        mediaResourceId: mainMediaResource
+      });
+    }
+    _loggerProxy.default.info(`${shouldHold ? 'Holding' : 'Resuming'} task`, {
+      module: _constants.CC_FILE,
+      method: _constants.METHODS.HOLD_RESUME,
+      interactionId: this.data.interactionId
+    });
+    const [successEvt, failedEvt] = shouldHold ? [_constants2.METRIC_EVENT_NAMES.TASK_HOLD_SUCCESS, _constants2.METRIC_EVENT_NAMES.TASK_HOLD_FAILED] : [_constants2.METRIC_EVENT_NAMES.TASK_RESUME_SUCCESS, _constants2.METRIC_EVENT_NAMES.TASK_RESUME_FAILED];
+    this.metricsManager.timeEvent([successEvt, failedEvt]);
+    try {
+      let response;
+      if (shouldHold) {
+        response = await this.contact.hold({
+          interactionId: this.data.interactionId,
+          data: {
+            mediaResourceId: mainMediaResource
+          }
+        });
+
+        // Send success event to complete the transition
+        if (this.stateMachineService) {
+          this.stateMachineService.send({
+            type: _stateMachine.TaskEvent.HOLD_SUCCESS,
+            mediaResourceId: mainMediaResource
+          });
+        }
+        this.metricsManager.trackEvent(successEvt, {
+          taskId: this.data.interactionId,
+          mediaResourceId: mainMediaResource,
+          ..._MetricsManager.default.getCommonTrackingFieldForAQMResponse(response)
+        }, ['operational', 'behavioral']);
+        _loggerProxy.default.log(`Task placed on hold successfully`, {
+          module: _constants.CC_FILE,
+          method: _constants.METHODS.HOLD_RESUME,
+          trackingId: response.trackingId,
+          interactionId: this.data.interactionId
+        });
+      } else {
+        response = await this.contact.unHold({
+          interactionId: this.data.interactionId,
+          data: {
+            mediaResourceId: mainMediaResource
+          }
+        });
+
+        // Send success event to complete the transition
+        if (this.stateMachineService) {
+          this.stateMachineService.send({
+            type: _stateMachine.TaskEvent.UNHOLD_SUCCESS,
+            mediaResourceId: mainMediaResource
+          });
+        }
+        this.metricsManager.trackEvent(successEvt, {
+          taskId: this.data.interactionId,
+          mainInteractionId,
+          mediaResourceId: mainMediaResource,
+          ..._MetricsManager.default.getCommonTrackingFieldForAQMResponse(response)
+        }, ['operational', 'behavioral']);
+        _loggerProxy.default.log(`Task resumed successfully`, {
+          module: _constants.CC_FILE,
+          method: _constants.METHODS.HOLD_RESUME,
+          trackingId: response.trackingId,
+          interactionId: this.data.interactionId
+        });
+      }
+      return response;
+    } catch (error) {
+      const failureEvent = shouldHold ? _stateMachine.TaskEvent.HOLD_FAILED : _stateMachine.TaskEvent.UNHOLD_FAILED;
+      this.stateMachineService.send({
+        type: failureEvent,
+        reason: error.toString(),
+        mediaResourceId: this.data.mediaResourceId
+      });
+      const {
+        error: detailedError
+      } = (0, _Utils.getErrorDetails)(error, 'holdResume', _constants.CC_FILE);
+      this.metricsManager.trackEvent(failedEvt, shouldHold ? {
+        taskId: this.data.interactionId,
+        mediaResourceId: this.data.mediaResourceId,
+        error: error.toString(),
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponseFailed(error.details || {})
+      } : {
+        taskId: this.data.interactionId,
+        error: error.toString(),
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponseFailed(error.details || {})
+      }, ['operational', 'behavioral']);
+      throw detailedError;
+    }
+  }
+
+  /**
+   * This is used to pause the call recording
+   * @returns Promise<TaskResponse>
+   * @throws Error
+   * @example
+   * ```typescript
+   * task.pauseRecording().then(()=>{}).catch(()=>{});
+   * ```
+   */
+  async pauseRecording() {
+    // Validate recording is active
+    const state = this.getStateMachineSnapshot();
+    if (state) {
+      const {
+        recordingControlsAvailable,
+        recordingInProgress
+      } = state.context;
+      const recordingActive = Boolean(recordingControlsAvailable && recordingInProgress);
+      if (!recordingActive) {
+        const error = new Error('Recording is not active or already paused');
+        _loggerProxy.default.error('Pause recording operation not allowed', {
+          module: _constants.CC_FILE,
+          method: 'pauseRecording',
+          interactionId: this.data.interactionId
+        });
+        throw error;
+      }
+    }
+    try {
+      _loggerProxy.default.info(`Pausing recording`, {
+        module: _constants.CC_FILE,
+        method: 'pauseRecording',
+        interactionId: this.data.interactionId
+      });
+      this.metricsManager.timeEvent([_constants2.METRIC_EVENT_NAMES.TASK_PAUSE_RECORDING_SUCCESS, _constants2.METRIC_EVENT_NAMES.TASK_PAUSE_RECORDING_FAILED]);
+      const result = await this.contact.pauseRecording({
+        interactionId: this.data.interactionId
+      });
+      this.metricsManager.trackEvent(_constants2.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.CC_FILE,
+        method: 'pauseRecording',
+        trackingId: result.trackingId,
+        interactionId: this.data.interactionId
+      });
+      return result;
+    } catch (error) {
+      const {
+        error: detailedError
+      } = (0, _Utils.getErrorDetails)(error, 'pauseRecording', _constants.CC_FILE);
+      this.metricsManager.trackEvent(_constants2.METRIC_EVENT_NAMES.TASK_PAUSE_RECORDING_FAILED, {
+        taskId: this.data.interactionId,
+        error: error.toString(),
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponseFailed(error.details || {})
+      }, ['operational', 'behavioral', 'business']);
+      throw detailedError;
+    }
+  }
+
+  /**
+   * This is used to pause the call recording
+   * @param resumeRecordingPayload
+   * @returns Promise<TaskResponse>
+   * @throws Error
+   * @example
+   * ```typescript
+   * task.resumeRecording(resumeRecordingPayload).then(()=>{}).catch(()=>{});
+   * ```
+   */
+  async resumeRecording(resumeRecordingPayload) {
+    // Validate recording is paused
+    const state = this.getStateMachineSnapshot();
+    if (state) {
+      const {
+        recordingControlsAvailable,
+        recordingInProgress
+      } = state.context;
+      const recordingPaused = Boolean(recordingControlsAvailable && !recordingInProgress);
+      if (!recordingPaused) {
+        const error = new Error('Recording is not paused');
+        _loggerProxy.default.error('Resume recording operation not allowed', {
+          module: _constants.CC_FILE,
+          method: 'resumeRecording',
+          interactionId: this.data.interactionId
+        });
+        throw error;
+      }
+    }
+    try {
+      _loggerProxy.default.info(`Resuming recording`, {
+        module: _constants.CC_FILE,
+        method: 'resumeRecording',
+        interactionId: this.data.interactionId
+      });
+      this.metricsManager.timeEvent([_constants2.METRIC_EVENT_NAMES.TASK_RESUME_RECORDING_SUCCESS, _constants2.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(_constants2.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.CC_FILE,
+        method: 'resumeRecording',
+        trackingId: result.trackingId,
+        interactionId: this.data.interactionId
+      });
+      return result;
+    } catch (error) {
+      const {
+        error: detailedError
+      } = (0, _Utils.getErrorDetails)(error, 'resumeRecording', _constants.CC_FILE);
+      this.metricsManager.trackEvent(_constants2.METRIC_EVENT_NAMES.TASK_RESUME_RECORDING_FAILED, {
+        taskId: this.data.interactionId,
+        error: error.toString(),
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponseFailed(error.details || {})
+      }, ['operational', 'behavioral', 'business']);
+      throw detailedError;
+    }
+  }
+
+  /**
+   * This is used to consult the task
+   * @param consultPayload
+   * @returns Promise<TaskResponse>
+   * @throws Error
+   * @example
+   * ```typescript
+   * const consultPayload = {
+   *   destination: 'myBuddyAgentId',
+   *   destinationType: DESTINATION_TYPE.AGENT,
+   * }
+   * task.consult(consultPayload).then(()=>{}).catch(()=>{});
+   * ```
+   * */
+  async consult(consultPayload) {
+    // Validate consult is allowed
+    const state = this.getStateMachineSnapshot();
+    const canConsult = state && (state.matches(_stateMachine.TaskState.CONNECTED) || state.matches(_stateMachine.TaskState.HELD) || state.matches(_stateMachine.TaskState.CONFERENCING));
+    if (!canConsult) {
+      const currentState = state?.value;
+      const error = new Error(`Cannot initiate consult in ${currentState} state`);
+      _loggerProxy.default.error('Consult operation not allowed', {
+        module: _constants.CC_FILE,
+        method: 'consult',
+        interactionId: this.data.interactionId
+      });
+      throw error;
+    }
+
+    // Send initiating event to transition to CONSULT_INITIATING state
+    if (this.stateMachineService) {
+      this.stateMachineService.send({
+        type: _stateMachine.TaskEvent.CONSULT,
+        destination: consultPayload.to,
+        destinationType: consultPayload.destinationType
+      });
+    }
+    const requestInteractionId = this.data.interaction?.mainInteractionId || this.data.interactionId;
+    try {
+      _loggerProxy.default.info(`Starting consult`, {
+        module: _constants.CC_FILE,
+        method: 'consult',
+        interactionId: requestInteractionId
+      });
+      this.metricsManager.timeEvent([_constants2.METRIC_EVENT_NAMES.TASK_CONSULT_START_SUCCESS, _constants2.METRIC_EVENT_NAMES.TASK_CONSULT_START_FAILED]);
+      const result = await this.contact.consult({
+        interactionId: requestInteractionId,
+        data: consultPayload
+      });
+
+      // Send success event to transition to CONSULTING state
+      if (this.stateMachineService) {
+        this.stateMachineService.send({
+          type: _stateMachine.TaskEvent.CONSULT_SUCCESS,
+          taskData: result.data
+        });
+      }
+      this.metricsManager.trackEvent(_constants2.METRIC_EVENT_NAMES.TASK_CONSULT_START_SUCCESS, {
+        taskId: this.data.interactionId,
+        requestInteractionId,
+        destination: consultPayload.to,
+        destinationType: consultPayload.destinationType,
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponse(result)
+      }, ['operational', 'behavioral', 'business']);
+      _loggerProxy.default.log(`Consult successfully initiated to ${consultPayload.to}`, {
+        module: _constants.CC_FILE,
+        method: 'consult',
+        trackingId: result.trackingId,
+        interactionId: requestInteractionId
+      });
+      return result;
+    } catch (error) {
+      this.stateMachineService.send({
+        type: _stateMachine.TaskEvent.CONSULT_FAILED,
+        reason: error.toString()
+      });
+      const {
+        error: detailedError
+      } = (0, _Utils.getErrorDetails)(error, 'consult', _constants.CC_FILE);
+      this.metricsManager.trackEvent(_constants2.METRIC_EVENT_NAMES.TASK_CONSULT_START_FAILED, {
+        taskId: this.data.interactionId,
+        requestInteractionId,
+        destination: consultPayload.to,
+        destinationType: consultPayload.destinationType,
+        error: error.toString(),
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponseFailed(error.details || {})
+      }, ['operational', 'behavioral', 'business']);
+      throw detailedError;
+    }
+  }
+
+  /**
+   * This is used to end the consult session on the task.
+   * @param consultEndPayload - Payload indicating consult end flags and identifiers
+   * @returns Promise<TaskResponse>
+   * @throws Error
+   * @example
+   * ```typescript
+   * task.endConsult({
+   *   isConsult: true,
+   *   queueId: 'myQueueId',
+   *   taskId: 'taskId',
+   * });
+   * ```
+   */
+  async endConsult(consultEndPayload) {
+    const requestInteractionId = this.data.interaction?.mainInteractionId || this.data.interactionId;
+    try {
+      _loggerProxy.default.info(`Ending consult`, {
+        module: _constants.CC_FILE,
+        method: 'endConsult',
+        interactionId: requestInteractionId
+      });
+      this.metricsManager.timeEvent([_constants2.METRIC_EVENT_NAMES.TASK_CONSULT_END_SUCCESS, _constants2.METRIC_EVENT_NAMES.TASK_CONSULT_END_FAILED]);
+      const result = await this.contact.consultEnd({
+        interactionId: requestInteractionId,
+        data: consultEndPayload
+      });
+      this.metricsManager.trackEvent(_constants2.METRIC_EVENT_NAMES.TASK_CONSULT_END_SUCCESS, {
+        taskId: this.data.interactionId,
+        requestInteractionId,
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponse(result)
+      }, ['operational', 'behavioral', 'business']);
+      _loggerProxy.default.log(`Consult ended successfully`, {
+        module: _constants.CC_FILE,
+        method: 'endConsult',
+        trackingId: result.trackingId,
+        interactionId: this.data.interactionId
+      });
+      return result;
+    } catch (error) {
+      const {
+        error: detailedError
+      } = (0, _Utils.getErrorDetails)(error, 'endConsult', _constants.CC_FILE);
+      this.metricsManager.trackEvent(_constants2.METRIC_EVENT_NAMES.TASK_CONSULT_END_FAILED, {
+        taskId: this.data.interactionId,
+        requestInteractionId,
+        error: error.toString(),
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponseFailed(error.details || {})
+      }, ['operational', 'behavioral', 'business']);
+      throw detailedError;
+    }
+  }
+
+  /**
+   * This is used to transfer the task.
+   * @param payload - Transfer payload
+   * @returns Promise<TaskResponse>
+   * @throws Error
+   * @example
+   * ```typescript
+   * task.transfer({
+   *   to: 'destinationId',
+   *   destinationType: DESTINATION_TYPE.AGENT,
+   *   consult: true, // Optional, if true will perform a consult transfer else blind transfer
+   * });
+   * ```
+   */
+  async transfer(payload) {
+    try {
+      _loggerProxy.default.info(`Transferring task to ${payload.to}`, {
+        module: _constants.CC_FILE,
+        method: _constants.METHODS.TRANSFER_CALL,
+        interactionId: this.data.interactionId
+      });
+      this.metricsManager.timeEvent([_constants2.METRIC_EVENT_NAMES.TASK_TRANSFER_SUCCESS, _constants2.METRIC_EVENT_NAMES.TASK_TRANSFER_FAILED]);
+
+      // consult transfer path
+      if (this.data.interaction.state === 'consulting') {
+        const normalizedDestinationType = payload.destinationType === 'Agent' || payload.destinationType === 'Queue' ? payload.destinationType.toLowerCase() : payload.destinationType;
+        let consultPayload = {
+          to: payload.to,
+          destinationType: normalizedDestinationType
+        };
+        if (normalizedDestinationType === _types.CONSULT_TRANSFER_DESTINATION_TYPE.QUEUE) {
+          const consultContext = this.getStateMachineSnapshot()?.context;
+          const destAgent = consultContext?.consultDestinationAgentId || this.data.destAgentId;
+          if (!destAgent) {
+            throw new Error('No agent has accepted this queue consult yet');
+          }
+          consultPayload = {
+            to: destAgent,
+            destinationType: _types.CONSULT_TRANSFER_DESTINATION_TYPE.AGENT
+          };
+        }
+        const result = await this.contact.consultTransfer({
+          interactionId: this.data.interactionId,
+          data: consultPayload
+        });
+        this.metricsManager.trackEvent(_constants2.METRIC_EVENT_NAMES.TASK_TRANSFER_SUCCESS, {
+          taskId: this.data.interactionId,
+          destination: consultPayload.to,
+          destinationType: consultPayload.destinationType,
+          isConsultTransfer: true,
+          ..._MetricsManager.default.getCommonTrackingFieldForAQMResponse(result)
+        }, ['operational', 'behavioral', 'business']);
+        _loggerProxy.default.log(`Consult transfer completed successfully to ${consultPayload.to}`, {
+          module: _constants.CC_FILE,
+          method: _constants.METHODS.TRANSFER_CALL,
+          trackingId: result.trackingId,
+          interactionId: this.data.interactionId
+        });
+        return result;
+      }
+
+      // standard blind transfer
+      return await super.transfer({
+        to: payload.to,
+        destinationType: payload.destinationType
+      });
+    } catch (err) {
+      const {
+        error: detailedError
+      } = (0, _Utils.getErrorDetails)(err, _constants.METHODS.TRANSFER_CALL, _constants.CC_FILE);
+      this.metricsManager.trackEvent(_constants2.METRIC_EVENT_NAMES.TASK_TRANSFER_FAILED, {
+        taskId: this.data.interactionId,
+        destination: payload.to,
+        destinationType: payload.destinationType,
+        isConsultTransfer: this.data.interaction.state === 'consulting',
+        error: err.toString(),
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponseFailed(err.details || {})
+      }, ['operational', 'behavioral', 'business']);
+      throw detailedError;
+    }
+  }
+
+  /**
+   * Start a consult conference, merging main and consult calls.
+   */
+  async consultConference() {
+    const derivedDestAgentId = this.data.interaction && this.data.agentId ? (0, _Utils.calculateDestAgentId)(this.data.interaction, this.data.agentId) : '';
+    const derivedDestType = this.data.interaction && this.data.agentId ? (0, _Utils.calculateDestType)(this.data.interaction, this.data.agentId) : '';
+
+    // derivedDestType is most reliable as it inspects live interaction participants
+    const resolvedDestinationType = derivedDestType || this.getStateMachineSnapshot()?.context?.consultDestinationType || this.data.destinationType || 'agent';
+    const consultationData = {
+      agentId: this.data.agentId,
+      destinationType: resolvedDestinationType,
+      // derivedDestAgentId is most reliable as it resolves epId for EP_DN
+      // and agent ID for regular agents from live interaction data
+      destAgentId: derivedDestAgentId || this.getStateMachineSnapshot()?.context?.consultDestinationAgentId || this.data.destAgentId
+    };
+
+    // Send state machine event to transition to CONF_INITIATING
+    if (this.stateMachineService) {
+      this.stateMachineService.send({
+        type: _stateMachine.TaskEvent.MERGE_TO_CONFERENCE
+      });
+    }
+    try {
+      if (!consultationData.destAgentId) {
+        throw new Error('Unable to determine consult destination for conference');
+      }
+      _loggerProxy.default.info(`Initiating consult conference to ${consultationData.destAgentId}`, {
+        module: _constants.CC_FILE,
+        method: _constants.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
+      });
+
+      // Send success event to transition to CONFERENCING
+      if (this.stateMachineService) {
+        this.stateMachineService.send({
+          type: _stateMachine.TaskEvent.CONFERENCE_START
+        });
+      }
+      this.metricsManager.trackEvent(_constants2.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.CC_FILE,
+        method: _constants.METHODS.CONSULT_CONFERENCE,
+        interactionId: this.data.interactionId
+      });
+      return response;
+    } catch (error) {
+      // Send failure event to revert state
+      if (this.stateMachineService) {
+        this.stateMachineService.send({
+          type: _stateMachine.TaskEvent.CONFERENCE_FAILED,
+          reason: error.toString()
+        });
+      }
+      const {
+        error: detailedError
+      } = (0, _Utils.getErrorDetails)(error, _constants.METHODS.CONSULT_CONFERENCE, _constants.CC_FILE);
+      const failedParamsData = (0, _Utils.buildConsultConferenceParamData)(consultationData, this.data.interactionId);
+      this.metricsManager.trackEvent(_constants2.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(),
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponseFailed(error.details || {})
+      }, ['operational', 'behavioral', 'business']);
+      _loggerProxy.default.error(`Failed to start consult conference`, {
+        module: _constants.CC_FILE,
+        method: _constants.METHODS.CONSULT_CONFERENCE,
+        interactionId: this.data.interactionId
+      });
+      throw detailedError;
+    }
+  }
+
+  /**
+   * Exit from a conference call.
+   * Per conference-spec.md:
+   * - Primary agent exits to wrapup
+   * - Non-primary agent exits to available/connected
+   * - Other participants continue the call
+   *
+   * @returns Promise<TaskResponse>
+   * @throws Error if not in conference or exit fails
+   * @example
+   * ```typescript
+   * task.exitConference().then(() => {}).catch(() => {});
+   * ```
+   */
+  async exitConference() {
+    // Validate we're in conference state OR conference is in progress per task data
+    // This handles cases where:
+    // 1. State machine is in CONFERENCING state
+    // 2. State machine is in CONNECTED but conference is active (e.g., ownership transferred)
+    const state = this.getStateMachineSnapshot();
+    const isConferencingState = state?.matches(_stateMachine.TaskState.CONFERENCING);
+    const isConferenceInProgressFromData = this.data ? (0, _TaskUtils.getIsConferenceInProgress)(this.data) : false;
+    if (!state || !isConferencingState && !isConferenceInProgressFromData) {
+      const currentState = state?.value;
+      const error = new Error(`Cannot exit conference in ${currentState} state`);
+      _loggerProxy.default.error('Exit conference operation not allowed', {
+        module: _constants.CC_FILE,
+        method: 'exitConference',
+        interactionId: this.data.interactionId
+      });
+      throw error;
+    }
+
+    // Send state machine event
+    if (this.stateMachineService) {
+      this.stateMachineService.send({
+        type: _stateMachine.TaskEvent.EXIT_CONFERENCE,
+        agentId: this.data.agentId
+      });
+    }
+    const requestInteractionId = this.data.interaction?.mainInteractionId || this.data.interactionId;
+    try {
+      _loggerProxy.default.info(`Exiting conference`, {
+        module: _constants.CC_FILE,
+        method: 'exitConference',
+        interactionId: requestInteractionId
+      });
+      this.metricsManager.timeEvent([_constants2.METRIC_EVENT_NAMES.TASK_CONFERENCE_EXIT_SUCCESS, _constants2.METRIC_EVENT_NAMES.TASK_CONFERENCE_EXIT_FAILED]);
+      const response = await this.contact.exitConference({
+        interactionId: requestInteractionId
+      });
+
+      // Send success event to transition state
+      if (this.stateMachineService) {
+        this.stateMachineService.send({
+          type: _stateMachine.TaskEvent.EXIT_CONFERENCE_SUCCESS,
+          taskData: response.data
+        });
+      }
+      this.metricsManager.trackEvent(_constants2.METRIC_EVENT_NAMES.TASK_CONFERENCE_EXIT_SUCCESS, {
+        taskId: this.data.interactionId,
+        requestInteractionId,
+        agentId: this.data.agentId,
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponse(response)
+      }, ['operational', 'behavioral', 'business']);
+      _loggerProxy.default.log(`Successfully exited conference`, {
+        module: _constants.CC_FILE,
+        method: 'exitConference',
+        trackingId: response.trackingId,
+        interactionId: requestInteractionId
+      });
+      return response;
+    } catch (error) {
+      // Send failure event
+      if (this.stateMachineService) {
+        this.stateMachineService.send({
+          type: _stateMachine.TaskEvent.EXIT_CONFERENCE_FAILED,
+          reason: error.toString()
+        });
+      }
+      const {
+        error: detailedError
+      } = (0, _Utils.getErrorDetails)(error, 'exitConference', _constants.CC_FILE);
+      this.metricsManager.trackEvent(_constants2.METRIC_EVENT_NAMES.TASK_CONFERENCE_EXIT_FAILED, {
+        taskId: this.data.interactionId,
+        requestInteractionId,
+        agentId: this.data.agentId,
+        error: error.toString(),
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponseFailed(error.details || {})
+      }, ['operational', 'behavioral', 'business']);
+      _loggerProxy.default.error(`Failed to exit conference`, {
+        module: _constants.CC_FILE,
+        method: 'exitConference',
+        interactionId: requestInteractionId
+      });
+      throw detailedError;
+    }
+  }
+
+  /**
+   * Transfer the conference to another participant.
+   * Per conference-spec.md: Only primary agent can transfer conference.
+   * After transfer, the transferring agent exits to wrapup.
+   *
+   * @returns Promise<TaskResponse>
+   * @throws Error if not in conference or transfer fails
+   * @example
+   * ```typescript
+   * task.transferConference().then(() => {}).catch(() => {});
+   * ```
+   */
+  async transferConference() {
+    // Validate we're in conference or consulting state
+    // CONSULTING is allowed because agent can transfer conference while consulting
+    // (transfers ownership to the consulted agent)
+    const state = this.getStateMachineSnapshot();
+    const isValidState = state && (state.matches(_stateMachine.TaskState.CONFERENCING) || state.matches(_stateMachine.TaskState.CONSULTING));
+    if (!isValidState) {
+      const currentState = state?.value;
+      const error = new Error(`Cannot transfer conference in ${currentState} state`);
+      _loggerProxy.default.error('Transfer conference operation not allowed', {
+        module: _constants.CC_FILE,
+        method: 'transferConference',
+        interactionId: this.data.interactionId
+      });
+      throw error;
+    }
+
+    // Send state machine event
+    if (this.stateMachineService) {
+      this.stateMachineService.send({
+        type: _stateMachine.TaskEvent.TRANSFER_CONFERENCE,
+        agentId: this.data.agentId
+      });
+    }
+    const requestInteractionId = this.data.interaction?.mainInteractionId || this.data.interactionId;
+    try {
+      _loggerProxy.default.info(`Transferring conference`, {
+        module: _constants.CC_FILE,
+        method: 'transferConference',
+        interactionId: requestInteractionId
+      });
+      this.metricsManager.timeEvent([_constants2.METRIC_EVENT_NAMES.TASK_CONFERENCE_TRANSFER_SUCCESS, _constants2.METRIC_EVENT_NAMES.TASK_CONFERENCE_TRANSFER_FAILED]);
+      const response = await this.contact.conferenceTransfer({
+        interactionId: requestInteractionId
+      });
+
+      // Send success event to transition state
+      if (this.stateMachineService) {
+        this.stateMachineService.send({
+          type: _stateMachine.TaskEvent.TRANSFER_CONFERENCE_SUCCESS,
+          taskData: response.data
+        });
+      }
+      this.metricsManager.trackEvent(_constants2.METRIC_EVENT_NAMES.TASK_CONFERENCE_TRANSFER_SUCCESS, {
+        taskId: this.data.interactionId,
+        requestInteractionId,
+        agentId: this.data.agentId,
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponse(response)
+      }, ['operational', 'behavioral', 'business']);
+      _loggerProxy.default.log(`Successfully transferred conference`, {
+        module: _constants.CC_FILE,
+        method: 'transferConference',
+        trackingId: response.trackingId,
+        interactionId: requestInteractionId
+      });
+      return response;
+    } catch (error) {
+      // Send failure event
+      if (this.stateMachineService) {
+        this.stateMachineService.send({
+          type: _stateMachine.TaskEvent.TRANSFER_CONFERENCE_FAILED,
+          reason: error.toString()
+        });
+      }
+      const {
+        error: detailedError
+      } = (0, _Utils.getErrorDetails)(error, 'transferConference', _constants.CC_FILE);
+      this.metricsManager.trackEvent(_constants2.METRIC_EVENT_NAMES.TASK_CONFERENCE_TRANSFER_FAILED, {
+        taskId: this.data.interactionId,
+        requestInteractionId,
+        agentId: this.data.agentId,
+        error: error.toString(),
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponseFailed(error.details || {})
+      }, ['operational', 'behavioral', 'business']);
+      _loggerProxy.default.error(`Failed to transfer conference`, {
+        module: _constants.CC_FILE,
+        method: 'transferConference',
+        interactionId: requestInteractionId
+      });
+      throw detailedError;
+    }
+  }
+
+  /**
+   * Toggle between consult call and main call during consulting.
+   * If on consult leg (consultCallHeld = false), switches to main call by holding consult.
+   * If on main call (consultCallHeld = true), switches to consult by resuming consult.
+   *
+   * @returns Promise<TaskResponse>
+   * @throws Error if not in CONSULTING state or no consult media resource
+   * @example
+   * ```typescript
+   * await task.switchCall();
+   * ```
+   */
+  async switchCall() {
+    // Validate we're in CONSULTING state
+    const state = this.getStateMachineSnapshot();
+    if (!state?.matches(_stateMachine.TaskState.CONSULTING)) {
+      const currentState = state?.value;
+      const error = new Error(`Cannot switch call in ${currentState} state`);
+      _loggerProxy.default.error('Switch call operation not allowed', {
+        module: _constants.CC_FILE,
+        method: 'switchCall',
+        interactionId: this.data.interactionId
+      });
+      throw error;
+    }
+
+    // Validate we have a consult media resource
+    const consultMediaResourceId = (0, _TaskUtils.getConsultMediaResourceId)(this.data.interaction, this.data.consultMediaResourceId, this.data.agentId);
+    if (!consultMediaResourceId) {
+      const error = new Error('No consult media resource available');
+      _loggerProxy.default.error('Switch call failed - no consult media resource', {
+        module: _constants.CC_FILE,
+        method: 'switchCall',
+        interactionId: this.data.interactionId
+      });
+      throw error;
+    }
+    const context = state.context;
+    const isOnConsultLeg = !context.consultCallHeld;
+
+    // Determine direction and send appropriate state machine event
+    const targetEvent = isOnConsultLeg ? _stateMachine.TaskEvent.SWITCH_TO_MAIN_CALL : _stateMachine.TaskEvent.SWITCH_TO_CONSULT;
+    const revertEvent = isOnConsultLeg ? _stateMachine.TaskEvent.SWITCH_TO_CONSULT : _stateMachine.TaskEvent.SWITCH_TO_MAIN_CALL;
+    if (this.stateMachineService) {
+      this.stateMachineService.send({
+        type: targetEvent
+      });
+    }
+    this.metricsManager.timeEvent([_constants2.METRIC_EVENT_NAMES.TASK_SWITCH_CALL_SUCCESS, _constants2.METRIC_EVENT_NAMES.TASK_SWITCH_CALL_FAILED]);
+    try {
+      if (isOnConsultLeg) {
+        const response = await this.contact.unHold({
+          interactionId: this.data.interactionId,
+          data: {
+            mediaResourceId: this.data.mediaResourceId
+          }
+        });
+        this.metricsManager.trackEvent(_constants2.METRIC_EVENT_NAMES.TASK_SWITCH_CALL_SUCCESS, {
+          taskId: this.data.interactionId,
+          direction: 'toMainCall',
+          mediaResourceId: consultMediaResourceId,
+          ..._MetricsManager.default.getCommonTrackingFieldForAQMResponse(response)
+        }, ['operational', 'behavioral']);
+        _loggerProxy.default.log(`Switched to main call successfully`, {
+          module: _constants.CC_FILE,
+          method: 'switchCall',
+          trackingId: response.trackingId,
+          interactionId: this.data.interactionId
+        });
+        return response;
+      }
+      const response = await this.contact.hold({
+        interactionId: this.data.interactionId,
+        data: {
+          mediaResourceId: this.data.mediaResourceId
+        }
+      });
+      this.metricsManager.trackEvent(_constants2.METRIC_EVENT_NAMES.TASK_SWITCH_CALL_SUCCESS, {
+        taskId: this.data.interactionId,
+        direction: 'toConsultCall',
+        mediaResourceId: consultMediaResourceId,
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponse(response)
+      }, ['operational', 'behavioral']);
+      _loggerProxy.default.log(`Switched to consult call successfully`, {
+        module: _constants.CC_FILE,
+        method: 'switchCall',
+        trackingId: response.trackingId,
+        interactionId: this.data.interactionId
+      });
+      return response;
+    } catch (error) {
+      if (this.stateMachineService) {
+        this.stateMachineService.send({
+          type: revertEvent
+        });
+      }
+      this.metricsManager.trackEvent(_constants2.METRIC_EVENT_NAMES.TASK_SWITCH_CALL_FAILED, {
+        taskId: this.data.interactionId,
+        direction: isOnConsultLeg ? 'toMainCall' : 'toConsultCall',
+        mediaResourceId: consultMediaResourceId,
+        error: error.toString(),
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponseFailed(error.details || {})
+      }, ['operational', 'behavioral']);
+      const {
+        error: detailedError
+      } = (0, _Utils.getErrorDetails)(error, 'switchCall', _constants.CC_FILE);
+      _loggerProxy.default.error(`Failed to switch call`, {
+        module: _constants.CC_FILE,
+        method: 'switchCall',
+        interactionId: this.data.interactionId
+      });
+      throw detailedError;
+    }
+  }
+  getChannelSpecificActionOverrides() {
+    const baseOverrides = super.getChannelSpecificActionOverrides();
+    return {
+      ...baseOverrides,
+      emitTaskHold: this.createEmitSelfAction(_types.TASK_EVENTS.TASK_HOLD, {
+        updateTaskData: true
+      }),
+      emitTaskResume: this.createEmitSelfAction(_types.TASK_EVENTS.TASK_RESUME, {
+        updateTaskData: true
+      }),
+      emitTaskRecordingStarted: this.createEmitSelfAction(_types.TASK_EVENTS.TASK_RECORDING_STARTED, {
+        updateTaskData: true
+      }),
+      emitTaskRecordingPaused: this.createEmitSelfAction(_types.TASK_EVENTS.TASK_RECORDING_PAUSED, {
+        updateTaskData: true
+      }),
+      emitTaskRecordingPauseFailed: this.createEmitSelfAction(_types.TASK_EVENTS.TASK_RECORDING_PAUSE_FAILED, {
+        updateTaskData: true
+      }),
+      emitTaskRecordingResumed: this.createEmitSelfAction(_types.TASK_EVENTS.TASK_RECORDING_RESUMED, {
+        updateTaskData: true
+      }),
+      emitTaskRecordingResumeFailed: this.createEmitSelfAction(_types.TASK_EVENTS.TASK_RECORDING_RESUME_FAILED, {
+        updateTaskData: true
+      }),
+      // Conference event emitters
+      emitTaskParticipantJoined: this.createEmitSelfAction(_types.TASK_EVENTS.TASK_PARTICIPANT_JOINED, {
+        updateTaskData: true
+      }),
+      emitTaskParticipantLeft: this.createEmitSelfAction(_types.TASK_EVENTS.TASK_PARTICIPANT_LEFT, {
+        updateTaskData: true
+      }),
+      emitTaskConferenceStarted: this.createEmitSelfAction(_types.TASK_EVENTS.TASK_CONFERENCE_STARTED, {
+        updateTaskData: true
+      }),
+      emitTaskConferenceEnded: this.createEmitSelfAction(_types.TASK_EVENTS.TASK_CONFERENCE_ENDED, {
+        updateTaskData: true
+      }),
+      emitTaskConferenceFailed: this.createEmitSelfAction(_types.TASK_EVENTS.TASK_CONFERENCE_FAILED, {
+        updateTaskData: true
+      }),
+      emitTaskExitConference: this.createEmitSelfAction(_types.TASK_EVENTS.TASK_EXIT_CONFERENCE, {
+        updateTaskData: false
+      }),
+      emitTaskTransferConference: this.createEmitSelfAction(_types.TASK_EVENTS.TASK_TRANSFER_CONFERENCE, {
+        updateTaskData: false
+      }),
+      emitTaskSwitchCall: this.createEmitSelfAction(_types.TASK_EVENTS.TASK_SWITCH_CALL, {
+        updateTaskData: false
+      }),
+      emitTaskTransferConferenceFailed: this.createEmitSelfAction(_types.TASK_EVENTS.TASK_CONFERENCE_TRANSFER_FAILED, {
+        updateTaskData: true
+      }),
+      emitTaskOutdialFailed: ({
+        event
+      }) => {
+        if (event && 'taskData' in event && event.taskData) {
+          this.updateTaskData(event.taskData);
+        }
+        const reason = event?.reason || 'Outdial failed';
+        this.emit(_types.TASK_EVENTS.TASK_OUTDIAL_FAILED, reason);
+      }
+    };
+  }
+}
+exports.default = Voice;
+//# sourceMappingURL=Voice.js.map