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

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

@@ -13,41 +13,305 @@ var _MetricsManager = _interopRequireDefault(require("../../../metrics/MetricsMa
 var _constants2 = require("../../../metrics/constants");
 var _stateMachine = require("../state-machine");
 var _TaskUtils = require("../TaskUtils");
+var _wxAppTelephonyUtils = require("../../wxAppTelephonyUtils");
+var _wxAppVoiceMethods = require("./wxAppVoiceMethods");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 class Voice extends _Task.default {
+  static WXAPP_MUTE_SYNC_RETRY_DELAY_MS = 50;
+  static WXAPP_MUTE_SYNC_MAX_RETRIES = 3;
+  enableWxBetterTogether = false;
+  wxAppMuted = false;
+  wxAppAnswerPending = false;
+  wxAppAcceptInFlight = false;
   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
+      isRecordingEnabled: callOptions?.isRecordingEnabled ?? true,
+      enableWxBetterTogether: callOptions?.enableWxBetterTogether ?? false
     };
     super(contact, data, {
-      ...resolvedOptions
+      ...resolvedOptions,
+      consultTransferConfig: callOptions?.consultTransferConfig
     }, wrapupData, agentId);
+    this.enableWxBetterTogether = resolvedOptions.enableWxBetterTogether;
+    this.answerCallOnWebexService = callOptions?.answerCallOnWebexService;
+  }
+  getWxAppVoiceDependencies() {
+    return {
+      enableWxBetterTogether: this.enableWxBetterTogether,
+      answerCallOnWebexService: this.answerCallOnWebexService,
+      agentId: this.agentId,
+      getTaskData: () => this.data,
+      getTaskState: () => this.stateMachineService?.getSnapshot?.()?.value,
+      getWxAppMuted: () => this.wxAppMuted,
+      setWxAppMuted: muted => {
+        this.wxAppMuted = muted;
+      }
+    };
+  }
+
+  /** @deprecated Use {@link Voice.getWxAppVoiceDependencies} */
+  getWxAppVoiceDeps() {
+    return this.getWxAppVoiceDependencies();
+  }
+  isWebexAppCallingOffer() {
+    return (0, _wxAppVoiceMethods.isWebexAppCallingOffer)(this.getWxAppVoiceDeps());
+  }
+  isWebexAppInboundCallingOffer() {
+    return (0, _wxAppVoiceMethods.isWebexAppInboundCallingOffer)(this.getWxAppVoiceDeps());
+  }
+  setWxAppAnswerPending(pending) {
+    this.wxAppAnswerPending = pending;
+    this.uiControlConfig = {
+      ...this.uiControlConfig,
+      wxAppAnswerPending: pending
+    };
+    this.updateUiControls(true);
+  }
+  setWxAppAcceptInFlight(inFlight) {
+    this.wxAppAcceptInFlight = inFlight;
+    this.uiControlConfig = {
+      ...this.uiControlConfig,
+      wxAppAcceptInFlight: inFlight
+    };
+    this.updateUiControls(true);
+  }
+  setEnableWxBetterTogether(enabled) {
+    this.enableWxBetterTogether = enabled;
+    this.uiControlConfig = {
+      ...this.uiControlConfig,
+      enableWxBetterTogether: enabled
+    };
+    this.updateUiControls(true);
+  }
+  applyWxAppMuteStateFromSync(incomingCallId, muted) {
+    if (!this.enableWxBetterTogether) {
+      return;
+    }
+    const activeCallId = this.getWebexCallingCallId();
+    if (!activeCallId || !incomingCallId.endsWith(activeCallId) || this.wxAppMuted === muted) {
+      return;
+    }
+    this.wxAppMuted = muted;
+    this.emit(_types.TASK_EVENTS.TASK_WXAPP_MUTE_STATE_UPDATED, {
+      muted
+    });
+  }
+  getWxAppMuted() {
+    return this.wxAppMuted;
+  }
+  static delay(ms) {
+    return new Promise(resolve => {
+      setTimeout(resolve, ms);
+    });
+  }
+  canRetryWxAppMuteSync() {
+    if (!this.enableWxBetterTogether) {
+      return false;
+    }
+    return Boolean((0, _wxAppVoiceMethods.getCallingDeviceDetails)(this.getWxAppVoiceDeps())?.deviceCallId) && !this.getWebexCallingCallId();
+  }
+  shouldSkipWxAppMuteSync() {
+    if (this.data?.interaction?.isTerminated) {
+      return true;
+    }
+    return this.isWebexAppCallingOffer() && !this.uiControlConfig?.wxAppAnswerPending;
+  }
+  applyWxAppMuteFromBackfill(callId, muted) {
+    if (!this.enableWxBetterTogether || this.wxAppMuted === muted) {
+      return;
+    }
+    const activeCallId = this.getWebexCallingCallId();
+    if (activeCallId && !callId.endsWith(activeCallId) && !activeCallId.endsWith(callId)) {
+      return;
+    }
+    this.wxAppMuted = muted;
+    this.emit(_types.TASK_EVENTS.TASK_WXAPP_MUTE_STATE_UPDATED, {
+      muted
+    });
+  }
+  async syncWxAppMuteFromCallDetails(retryAttempt = 0) {
+    if (!this.enableWxBetterTogether || !this.answerCallOnWebexService) {
+      return undefined;
+    }
+    if (retryAttempt === 0 && this.shouldSkipWxAppMuteSync()) {
+      return undefined;
+    }
+    if (retryAttempt === 0 && this.wxAppMuteSyncInFlight) {
+      return this.wxAppMuteSyncInFlight;
+    }
+    const syncPromise = this.performWxAppMuteSync(retryAttempt);
+    if (retryAttempt === 0) {
+      this.wxAppMuteSyncInFlight = syncPromise;
+      syncPromise.finally(() => {
+        if (this.wxAppMuteSyncInFlight === syncPromise) {
+          this.wxAppMuteSyncInFlight = undefined;
+        }
+      }).catch(() => undefined);
+      return syncPromise;
+    }
+    return syncPromise;
+  }
+  async performWxAppMuteSync(retryAttempt) {
+    if (this.shouldSkipWxAppMuteSync()) {
+      return undefined;
+    }
+    let callId = this.getWebexCallingCallId();
+    if (!callId) {
+      if (retryAttempt < Voice.WXAPP_MUTE_SYNC_MAX_RETRIES && this.canRetryWxAppMuteSync()) {
+        await Voice.delay(Voice.WXAPP_MUTE_SYNC_RETRY_DELAY_MS);
+        return this.performWxAppMuteSync(retryAttempt + 1);
+      }
+      callId = (0, _wxAppVoiceMethods.getCallingDeviceDetails)(this.getWxAppVoiceDeps())?.deviceCallId ?? null;
+      if (!callId) {
+        return undefined;
+      }
+    }
+    try {
+      const lineOwnerId = (0, _wxAppVoiceMethods.resolveWxAppLineOwnerId)(this.getWxAppVoiceDeps());
+      const details = await this.answerCallOnWebexService.getCallDetails({
+        callId,
+        lineOwnerId
+      });
+      if (details.muted !== undefined) {
+        this.applyWxAppMuteStateFromSync(callId, details.muted);
+        if (this.wxAppMuted !== details.muted) {
+          this.applyWxAppMuteFromBackfill(callId, details.muted);
+        }
+        return details.muted;
+      }
+      return this.wxAppMuted;
+    } catch (error) {
+      if (!(0, _wxAppTelephonyUtils.isWxAppCallNotFoundError)(error)) {
+        _loggerProxy.default.error(`Failed to sync wxApp mute from call details: ${error}`, {
+          module: _constants.CC_FILE,
+          method: _constants.METHODS.GET_CALL_DETAILS_ON_WEBEX,
+          interactionId: this.data?.interactionId
+        });
+      }
+      return undefined;
+    }
+  }
+  onTaskAssigned() {
+    this.setWxAppAnswerPending(false);
+    queueMicrotask(() => {
+      this.syncWxAppMuteFromCallDetails().catch(() => undefined);
+    });
+  }
+  onTaskHydrated() {
+    const state = this.stateMachineService?.getSnapshot?.()?.value;
+    const answerStillPending = state === _stateMachine.TaskState.OFFERED && (this.uiControlConfig?.wxAppAcceptInFlight || this.uiControlConfig?.wxAppAnswerPending);
+    if (!answerStillPending) {
+      this.setWxAppAnswerPending(false);
+    }
+    this.syncWxAppMuteFromCallDetails().catch(() => undefined);
+  }
+  getCallingDeviceDetails() {
+    return (0, _wxAppVoiceMethods.getCallingDeviceDetails)(this.getWxAppVoiceDeps());
+  }
+  getWebexCallingCallId() {
+    return (0, _wxAppVoiceMethods.getWebexCallingCallId)(this.getWxAppVoiceDeps());
+  }
+  createWxAppLifecycle() {
+    return {
+      setWxAppAcceptInFlight: inFlight => this.setWxAppAcceptInFlight(inFlight),
+      setWxAppAnswerPending: pending => this.setWxAppAnswerPending(pending),
+      resetWxAppMuted: () => {
+        this.wxAppMuted = false;
+      },
+      syncWxAppMuteFromCallDetails: () => this.syncWxAppMuteFromCallDetails(),
+      mapWxAppVoiceError: (error, method) => (0, _wxAppVoiceMethods.mapWxAppVoiceError)(error, method, _constants.CC_FILE)
+    };
   }
   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
+   * Accepts the task. Routes to wxApp telephony answer when `enableWxBetterTogether` and wxApp offer.
    */
   async accept() {
-    super.unsupportedMethodError(_constants.METHODS.ACCEPT);
+    if (this.enableWxBetterTogether && this.isWebexAppCallingOffer()) {
+      await (0, _wxAppVoiceMethods.runWxAppAccept)(this.getWxAppVoiceDependencies(), this.createWxAppLifecycle());
+      return Promise.resolve();
+    }
+    return 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
+   * Declines the task. Routes wxApp inbound to telephony reject; wxApp outdial offer to cancelTask.
    */
   async decline() {
-    super.unsupportedMethodError(_constants.METHODS.REJECT);
+    if (this.enableWxBetterTogether && this.isWebexAppInboundCallingOffer()) {
+      await (0, _wxAppVoiceMethods.runWxAppReject)(this.getWxAppVoiceDependencies(), this.createWxAppLifecycle());
+      return Promise.resolve();
+    }
+    const isOutdial = this.data?.interaction?.outboundType === 'OUTDIAL';
+    if (!this.enableWxBetterTogether || !isOutdial || !this.isWebexAppCallingOffer()) {
+      return super.unsupportedMethodError(_constants.METHODS.REJECT);
+    }
+    const interactionId = this.data.interactionId;
+    _loggerProxy.default.log(`Declining wxApp outdial task for taskId:${interactionId}`, {
+      module: _constants.CC_FILE,
+      method: _constants.METHODS.REJECT,
+      interactionId
+    });
+    try {
+      this.metricsManager.timeEvent([_constants2.METRIC_EVENT_NAMES.TASK_DECLINE_SUCCESS, _constants2.METRIC_EVENT_NAMES.TASK_DECLINE_FAILED]);
+      this.setWxAppAnswerPending(false);
+      const response = await this.contact.cancelTask({
+        interactionId
+      });
+      this.metricsManager.trackEvent(_constants2.METRIC_EVENT_NAMES.TASK_DECLINE_SUCCESS, {
+        taskId: interactionId,
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponse(response)
+      }, ['operational', 'behavioral']);
+      return response;
+    } catch (error) {
+      this.metricsManager.trackEvent(_constants2.METRIC_EVENT_NAMES.TASK_DECLINE_FAILED, {
+        taskId: interactionId,
+        error: error.toString(),
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponseFailed(error.details || {})
+      }, ['operational', 'behavioral']);
+      const {
+        error: detailedError
+      } = (0, _Utils.getErrorDetails)(error, _constants.METHODS.REJECT, _constants.CC_FILE);
+      throw detailedError;
+    }
+  }
+
+  /**
+   * Toggles mute for wxApp engaged telephony when `enableWxBetterTogether` is active.
+   */
+  async toggleMute(options) {
+    if (this.enableWxBetterTogether && this.getWebexCallingCallId()) {
+      if (this.wxAppMuteToggleInFlight) {
+        await this.wxAppMuteToggleInFlight.catch(() => undefined);
+      }
+      const togglePromise = (0, _wxAppVoiceMethods.runWxAppToggleMute)(this.getWxAppVoiceDependencies(), this.createWxAppLifecycle(), options);
+      this.wxAppMuteToggleInFlight = togglePromise;
+      togglePromise.finally(() => {
+        if (this.wxAppMuteToggleInFlight === togglePromise) {
+          this.wxAppMuteToggleInFlight = undefined;
+        }
+      }).catch(() => undefined);
+      await togglePromise;
+      return;
+    }
+    super.unsupportedMethodError(_constants.METHODS.TOGGLE_MUTE);
+  }
+
+  /**
+   * Sends in-call DTMF for wxApp engaged telephony when `enableWxBetterTogether` is active.
+   */
+  async transmitDtmf(options) {
+    if (this.enableWxBetterTogether && this.getWebexCallingCallId()) {
+      await (0, _wxAppVoiceMethods.runWxAppTransmitDtmf)(this.getWxAppVoiceDependencies(), this.createWxAppLifecycle(), options);
+      return;
+    }
+    super.unsupportedMethodError(_constants.METHODS.TRANSMIT_DTMF);
   }
 
   /**
@@ -667,6 +931,74 @@ class Voice extends _Task.default {
     }
   }
 
+  /**
+   * Removes another participant from an active conference.
+   * Completion is correlated with ParticipantLeftConference by the AQM request layer.
+   * @param payload - Participant identifier to remove
+   * @returns Promise<TaskResponse>
+   */
+  async dropConferenceParticipant(payload) {
+    // The TypeScript contract requires payload, but the published SDK is also callable from
+    // untyped JavaScript. Keep an explicit runtime boundary check before direct property access.
+    if (!payload) {
+      throw new Error('participantId must be a non-empty string');
+    }
+    const {
+      participantId
+    } = payload;
+    if (typeof participantId !== 'string' || participantId.trim().length === 0) {
+      throw new Error('participantId must be a non-empty string');
+    }
+    const requestInteractionId = this.data.interaction?.mainInteractionId || this.data.interactionId;
+    // taskId identifies the SDK task instance, which can remain child-interaction keyed after
+    // consult/EP-DN flows. requestInteractionId identifies the main interaction sent to AQM.
+
+    _loggerProxy.default.info('Dropping conference participant', {
+      module: _constants.CC_FILE,
+      method: _constants.METHODS.DROP_CONFERENCE_PARTICIPANT,
+      interactionId: requestInteractionId
+    });
+    try {
+      this.metricsManager.timeEvent([_constants2.METRIC_EVENT_NAMES.TASK_CONFERENCE_PARTICIPANT_DROP_SUCCESS, _constants2.METRIC_EVENT_NAMES.TASK_CONFERENCE_PARTICIPANT_DROP_FAILED]);
+      const response = await this.contact.dropConferenceParticipant({
+        interactionId: requestInteractionId,
+        participantId
+      });
+      this.metricsManager.trackEvent(_constants2.METRIC_EVENT_NAMES.TASK_CONFERENCE_PARTICIPANT_DROP_SUCCESS, {
+        taskId: this.data.interactionId,
+        requestInteractionId,
+        ..._MetricsManager.default.getCommonTrackingFieldForAQMResponse(response),
+        agentId: this.agentId
+      }, ['operational', 'behavioral', 'business']);
+      _loggerProxy.default.log('Successfully dropped conference participant', {
+        module: _constants.CC_FILE,
+        method: _constants.METHODS.DROP_CONFERENCE_PARTICIPANT,
+        trackingId: response?.trackingId,
+        interactionId: requestInteractionId
+      });
+      return response;
+    } catch (error) {
+      const failureTrackingFields = _MetricsManager.default.getCommonTrackingFieldForAQMResponseFailed(error?.details || {});
+      this.metricsManager.trackEvent(_constants2.METRIC_EVENT_NAMES.TASK_CONFERENCE_PARTICIPANT_DROP_FAILED, {
+        taskId: this.data.interactionId,
+        requestInteractionId,
+        agentId: this.agentId,
+        trackingId: failureTrackingFields.trackingId,
+        notifTrackingId: failureTrackingFields.notifTrackingId,
+        orgId: failureTrackingFields.orgId,
+        failureType: failureTrackingFields.failureType,
+        reasonCode: failureTrackingFields.reasonCode
+      }, ['operational', 'behavioral', 'business']);
+      _loggerProxy.default.error('Failed to drop conference participant', {
+        module: _constants.CC_FILE,
+        method: _constants.METHODS.DROP_CONFERENCE_PARTICIPANT,
+        trackingId: failureTrackingFields.trackingId,
+        interactionId: requestInteractionId
+      });
+      throw error;
+    }
+  }
+
   /**
    * Exit from a conference call.
    * Per conference-spec.md:
@@ -1031,8 +1363,12 @@ class Voice extends _Task.default {
       emitTaskOutdialFailed: ({
         event
       }) => {
-        if (event && 'taskData' in event && event.taskData) {
-          this.updateTaskData(event.taskData);
+        const taskData = event?.taskData;
+        if (taskData) {
+          this.updateTaskData(taskData);
+        }
+        if (taskData?.suppressOutdialFailedPopup) {
+          return;
         }
         const reason = event?.reason || 'Outdial failed';
         this.emit(_types.TASK_EVENTS.TASK_OUTDIAL_FAILED, reason);