@webex/contact-center 3.10.0-next.9 → 3.10.0-wxc-disconnect.1

package/src/services/task/TaskManager.ts

@@ -12,13 +12,6 @@ import LoggerProxy from '../../logger-proxy';
 import Task from '.';
 import MetricsManager from '../../metrics/MetricsManager';
 import {METRIC_EVENT_NAMES} from '../../metrics/constants';
-import {
-  checkParticipantNotInInteraction,
-  getIsConferenceInProgress,
-  isParticipantInMainInteraction,
-  isPrimary,
-  isSecondaryEpDnAgent,
-} from './TaskUtils';
 
 /** @internal */
 export default class TaskManager extends EventEmitter {
@@ -129,15 +122,14 @@ export default class TaskManager extends EventEmitter {
                 method: METHODS.REGISTER_TASK_LISTENERS,
                 interactionId: payload.data.interactionId,
               });
-
               task = new Task(
                 this.contact,
                 this.webCallingService,
                 {
                   ...payload.data,
                   wrapUpRequired:
-                    payload.data.interaction?.participants?.[this.agentId]?.isWrapUp || false,
-                  isConferenceInProgress: getIsConferenceInProgress(payload.data),
+                    payload.data.interaction?.participants?.[payload.data.agentId]?.isWrapUp ||
+                    false,
                 },
                 this.wrapupData,
                 this.agentId
@@ -168,7 +160,6 @@ export default class TaskManager extends EventEmitter {
               }
             }
             break;
-
           case CC_EVENTS.AGENT_CONTACT_RESERVED:
             task = new Task(
               this.contact,
@@ -248,22 +239,13 @@ export default class TaskManager extends EventEmitter {
             break;
           }
           case CC_EVENTS.CONTACT_ENDED:
-            // Update task data
             task = this.updateTaskData(task, {
               ...payload.data,
-              wrapUpRequired:
-                payload.data.interaction.state !== 'new' &&
-                !isSecondaryEpDnAgent(payload.data.interaction),
+              wrapUpRequired: payload.data.interaction.state !== 'new',
             });
-
-            // Handle cleanup based on whether task should be deleted
             this.handleTaskCleanup(task);
+            task.emit(TASK_EVENTS.TASK_END, task);
 
-            task?.emit(TASK_EVENTS.TASK_END, task);
-
-            break;
-          case CC_EVENTS.CONTACT_MERGED:
-            task = this.handleContactMerged(task, payload.data);
             break;
           case CC_EVENTS.AGENT_CONTACT_HELD:
             // As soon as the main interaction is held, we need to emit TASK_HOLD
@@ -376,45 +358,18 @@ export default class TaskManager extends EventEmitter {
           case CC_EVENTS.AGENT_CONSULT_CONFERENCE_ENDED:
             // Conference ended - update task state and emit event
             task = this.updateTaskData(task, payload.data);
-            if (
-              !task ||
-              isPrimary(task, this.agentId) ||
-              isParticipantInMainInteraction(task, this.agentId)
-            ) {
-              LoggerProxy.log('Primary or main interaction participant leaving conference');
-            } else {
-              this.removeTaskFromCollection(task);
-            }
             task.emit(TASK_EVENTS.TASK_CONFERENCE_ENDED, task);
             break;
-          case CC_EVENTS.PARTICIPANT_JOINED_CONFERENCE: {
-            task = this.updateTaskData(task, {
-              ...payload.data,
-              isConferenceInProgress: getIsConferenceInProgress(payload.data),
-            });
+          case CC_EVENTS.PARTICIPANT_JOINED_CONFERENCE:
+            // Participant joined conference - update task state with participant information and emit event
+            task = this.updateTaskData(task, payload.data);
             task.emit(TASK_EVENTS.TASK_PARTICIPANT_JOINED, task);
             break;
-          }
-          case CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE: {
+          case CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE:
             // Conference ended - update task state and emit event
-
-            task = this.updateTaskData(task, {
-              ...payload.data,
-              isConferenceInProgress: getIsConferenceInProgress(payload.data),
-            });
-            if (checkParticipantNotInInteraction(task, this.agentId)) {
-              if (
-                isParticipantInMainInteraction(task, this.agentId) ||
-                isPrimary(task, this.agentId)
-              ) {
-                LoggerProxy.log('Primary or main interaction participant leaving conference');
-              } else {
-                this.removeTaskFromCollection(task);
-              }
-            }
+            task = this.updateTaskData(task, payload.data);
             task.emit(TASK_EVENTS.TASK_PARTICIPANT_LEFT, task);
             break;
-          }
           case CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE_FAILED:
             // Conference exit failed - update task state and emit failure event
             task = this.updateTaskData(task, payload.data);
@@ -436,10 +391,13 @@ export default class TaskManager extends EventEmitter {
             task = this.updateTaskData(task, payload.data);
             task.emit(TASK_EVENTS.TASK_CONFERENCE_TRANSFER_FAILED, task);
             break;
+          case CC_EVENTS.CONSULTED_PARTICIPANT_MOVING:
+            // Participant is being moved/transferred - update task state with movement info
+            task = this.updateTaskData(task, payload.data);
+            break;
           case CC_EVENTS.PARTICIPANT_POST_CALL_ACTIVITY:
             // Post-call activity for participant - update task state with activity details
             task = this.updateTaskData(task, payload.data);
-            task.emit(TASK_EVENTS.TASK_POST_CALL_ACTIVITY, task);
             break;
           default:
             break;
@@ -479,54 +437,6 @@ export default class TaskManager extends EventEmitter {
     }
   }
 
-  /**
-   * Handles CONTACT_MERGED event logic
-   * @param task - The task to process
-   * @param taskData - The task data from the event payload
-   * @returns Updated or newly created task
-   * @private
-   */
-  private handleContactMerged(task: ITask, taskData: TaskData): ITask {
-    if (taskData.childInteractionId) {
-      // remove the child task from collection
-      this.removeTaskFromCollection(this.taskCollection[taskData.childInteractionId]);
-    }
-
-    if (this.taskCollection[taskData.interactionId]) {
-      LoggerProxy.log(`Got CONTACT_MERGED: Task already exists in collection`, {
-        module: TASK_MANAGER_FILE,
-        method: METHODS.REGISTER_TASK_LISTENERS,
-        interactionId: taskData.interactionId,
-      });
-      // update the task data
-      task = this.updateTaskData(task, taskData);
-    } else {
-      // Case2 : Task is not present in taskCollection
-      LoggerProxy.log(`Got CONTACT_MERGED : Creating new task in taskManager`, {
-        module: TASK_MANAGER_FILE,
-        method: METHODS.REGISTER_TASK_LISTENERS,
-        interactionId: taskData.interactionId,
-      });
-
-      task = new Task(
-        this.contact,
-        this.webCallingService,
-        {
-          ...taskData,
-          wrapUpRequired: taskData.interaction?.participants?.[this.agentId]?.isWrapUp || false,
-          isConferenceInProgress: getIsConferenceInProgress(taskData),
-        },
-        this.wrapupData,
-        this.agentId
-      );
-      this.taskCollection[taskData.interactionId] = task;
-    }
-
-    this.emit(TASK_EVENTS.TASK_MERGED, task);
-
-    return task;
-  }
-
   private removeTaskFromCollection(task: ITask) {
     if (task?.data?.interactionId) {
       delete this.taskCollection[task.data.interactionId];
@@ -538,13 +448,7 @@ export default class TaskManager extends EventEmitter {
     }
   }
 
-  /**
-   * Handles cleanup of task resources including Desktop/WebRTC call cleanup and task removal
-   * @param task - The task to clean up
-   * @private
-   */
   private handleTaskCleanup(task: ITask) {
-    // Clean up Desktop/WebRTC calling resources for browser-based telephony tasks
     if (
       this.webCallingService.loginOption === LoginOption.BROWSER &&
       task.data.interaction.mediaType === 'telephony'
@@ -552,9 +456,8 @@ export default class TaskManager extends EventEmitter {
       task.unregisterWebCallListeners();
       this.webCallingService.cleanUpCall();
     }
-
-    if (task.data.interaction.state === 'new' || isSecondaryEpDnAgent(task.data.interaction)) {
-      // Only remove tasks in 'new' state or isSecondaryEpDnAgent immediately. For other states,
+    if (task.data.interaction.state === 'new') {
+      // Only remove tasks in 'new' state immediately. For other states,
       // retain tasks until they complete wrap-up, unless the task disconnected before being answered.
       this.removeTaskFromCollection(task);
     }

package/src/services/task/constants.ts

@@ -23,25 +23,6 @@ export const CONFERENCE_TRANSFER = '/conference/transfer';
 export const TASK_MANAGER_FILE = 'taskManager';
 export const TASK_FILE = 'task';
 
-/**
- * Task data field names that should be preserved during reconciliation
- * These fields are retained even if not present in new data during updates
- */
-export const PRESERVED_TASK_DATA_FIELDS = {
-  /** Indicates if the task is in consultation state */
-  IS_CONSULTED: 'isConsulted',
-  /** Indicates if wrap-up is required for this task */
-  WRAP_UP_REQUIRED: 'wrapUpRequired',
-  /** Indicates if a conference is currently in progress (2+ active agents) */
-  IS_CONFERENCE_IN_PROGRESS: 'isConferenceInProgress',
-};
-
-/**
- * Array of task data field names that should not be deleted during reconciliation
- * Used by reconcileData method to preserve important task state fields
- */
-export const KEYS_TO_NOT_DELETE: string[] = Object.values(PRESERVED_TASK_DATA_FIELDS);
-
 // METHOD NAMES
 export const METHODS = {
   // Task class methods

package/src/services/task/index.ts

@@ -1,11 +1,16 @@
 import EventEmitter from 'events';
 import {CALL_EVENT_KEYS, LocalMicrophoneStream} from '@webex/calling';
 import {CallId} from '@webex/calling/dist/types/common/types';
-import {generateTaskErrorObject, calculateDestAgentId, calculateDestType} from '../core/Utils';
+import {
+  generateTaskErrorObject,
+  deriveConsultTransferDestinationType,
+  getDestinationAgentId,
+  buildConsultConferenceParamData,
+} from '../core/Utils';
 import {Failure} from '../core/GlobalTypes';
 import {LoginOption} from '../../types';
 import {TASK_FILE} from '../../constants';
-import {METHODS, KEYS_TO_NOT_DELETE} from './constants';
+import {METHODS} from './constants';
 import routingContact from './contact';
 import LoggerProxy from '../../logger-proxy';
 import {
@@ -276,24 +281,9 @@ export default class Task extends EventEmitter implements ITask {
    * @private
    */
   private reconcileData(oldData: TaskData, newData: TaskData): TaskData {
-    // Remove keys from oldData that are not in newData
-    Object.keys(oldData).forEach((key) => {
-      if (!(key in newData) && !KEYS_TO_NOT_DELETE.includes(key as string)) {
-        delete oldData[key];
-      }
-    });
-
-    // Merge or update keys from newData
     Object.keys(newData).forEach((key) => {
-      if (
-        newData[key] &&
-        typeof newData[key] === 'object' &&
-        !Array.isArray(newData[key]) &&
-        oldData[key] &&
-        typeof oldData[key] === 'object' &&
-        !Array.isArray(oldData[key])
-      ) {
-        this.reconcileData(oldData[key], newData[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];
       }
@@ -521,7 +511,6 @@ export default class Task extends EventEmitter implements ITask {
    * Puts the current task/interaction on hold.
    * Emits task:hold event when successful. For voice tasks, this mutes the audio.
    *
-   * @param mediaResourceId - Optional media resource ID to use for the hold operation. If not provided, uses the task's current mediaResourceId
    * @returns Promise<TaskResponse>
    * @throws Error if hold operation fails
    * @example
@@ -542,17 +531,9 @@ export default class Task extends EventEmitter implements ITask {
    *   console.error('Failed to place task on hold:', error);
    *   // Handle error (e.g., show error message, reset UI state)
    * }
-   *
-   * // Place task on hold with custom mediaResourceId
-   * try {
-   *   await task.hold('custom-media-resource-id');
-   *   console.log('Successfully placed task on hold with custom mediaResourceId');
-   * } catch (error) {
-   *   console.error('Failed to place task on hold:', error);
-   * }
    * ```
    */
-  public async hold(mediaResourceId?: string): Promise<TaskResponse> {
+  public async hold(): Promise<TaskResponse> {
     try {
       LoggerProxy.info(`Holding task`, {
         module: TASK_FILE,
@@ -565,11 +546,9 @@ export default class Task extends EventEmitter implements ITask {
         METRIC_EVENT_NAMES.TASK_HOLD_FAILED,
       ]);
 
-      const effectiveMediaResourceId = mediaResourceId ?? this.data.mediaResourceId;
-
       const response = await this.contact.hold({
         interactionId: this.data.interactionId,
-        data: {mediaResourceId: effectiveMediaResourceId},
+        data: {mediaResourceId: this.data.mediaResourceId},
       });
 
       this.metricsManager.trackEvent(
@@ -577,7 +556,7 @@ export default class Task extends EventEmitter implements ITask {
         {
           ...MetricsManager.getCommonTrackingFieldForAQMResponse(response),
           taskId: this.data.interactionId,
-          mediaResourceId: effectiveMediaResourceId,
+          mediaResourceId: this.data.mediaResourceId,
         },
         ['operational', 'behavioral']
       );
@@ -599,13 +578,11 @@ export default class Task extends EventEmitter implements ITask {
         errorData: err.data?.errorData,
         reasonCode: err.data?.reasonCode,
       };
-      const effectiveMediaResourceId = mediaResourceId ?? this.data.mediaResourceId;
-
       this.metricsManager.trackEvent(
         METRIC_EVENT_NAMES.TASK_HOLD_FAILED,
         {
           taskId: this.data.interactionId,
-          mediaResourceId: effectiveMediaResourceId,
+          mediaResourceId: this.data.mediaResourceId,
           error: error.toString(),
           ...taskErrorProps,
           ...MetricsManager.getCommonTrackingFieldForAQMResponseFailed(error.details || {}),
@@ -620,7 +597,6 @@ export default class Task extends EventEmitter implements ITask {
    * Resumes the task/interaction that was previously put on hold.
    * Emits task:resume event when successful. For voice tasks, this restores the audio.
    *
-   * @param mediaResourceId - Optional media resource ID to use for the resume operation. If not provided, uses the task's current mediaResourceId from interaction media
    * @returns Promise<TaskResponse>
    * @throws Error if resume operation fails
    * @example
@@ -641,17 +617,9 @@ export default class Task extends EventEmitter implements ITask {
    *   console.error('Failed to resume task:', error);
    *   // Handle error (e.g., show error message)
    * }
-   *
-   * // Resume task from hold with custom mediaResourceId
-   * try {
-   *   await task.resume('custom-media-resource-id');
-   *   console.log('Successfully resumed task from hold with custom mediaResourceId');
-   * } catch (error) {
-   *   console.error('Failed to resume task:', error);
-   * }
    * ```
    */
-  public async resume(mediaResourceId?: string): Promise<TaskResponse> {
+  public async resume(): Promise<TaskResponse> {
     try {
       LoggerProxy.info(`Resuming task`, {
         module: TASK_FILE,
@@ -659,9 +627,7 @@ export default class Task extends EventEmitter implements ITask {
         interactionId: this.data.interactionId,
       });
       const {mainInteractionId} = this.data.interaction;
-      const defaultMediaResourceId =
-        this.data.interaction.media[mainInteractionId]?.mediaResourceId;
-      const effectiveMediaResourceId = mediaResourceId ?? defaultMediaResourceId;
+      const {mediaResourceId} = this.data.interaction.media[mainInteractionId];
 
       this.metricsManager.timeEvent([
         METRIC_EVENT_NAMES.TASK_RESUME_SUCCESS,
@@ -670,7 +636,7 @@ export default class Task extends EventEmitter implements ITask {
 
       const response = await this.contact.unHold({
         interactionId: this.data.interactionId,
-        data: {mediaResourceId: effectiveMediaResourceId},
+        data: {mediaResourceId},
       });
 
       this.metricsManager.trackEvent(
@@ -678,7 +644,7 @@ export default class Task extends EventEmitter implements ITask {
         {
           taskId: this.data.interactionId,
           mainInteractionId,
-          mediaResourceId: effectiveMediaResourceId,
+          mediaResourceId,
           ...MetricsManager.getCommonTrackingFieldForAQMResponse(response),
         },
         ['operational', 'behavioral']
@@ -695,11 +661,6 @@ export default class Task extends EventEmitter implements ITask {
     } catch (error) {
       const err = generateTaskErrorObject(error, METHODS.RESUME, TASK_FILE);
       const mainInteractionId = this.data.interaction?.mainInteractionId;
-      const defaultMediaResourceId = mainInteractionId
-        ? this.data.interaction.media[mainInteractionId]?.mediaResourceId
-        : '';
-      const effectiveMediaResourceId = mediaResourceId ?? defaultMediaResourceId;
-
       const taskErrorProps = {
         trackingId: err.data?.trackingId,
         errorMessage: err.data?.message,
@@ -712,7 +673,9 @@ export default class Task extends EventEmitter implements ITask {
         {
           taskId: this.data.interactionId,
           mainInteractionId,
-          mediaResourceId: effectiveMediaResourceId,
+          mediaResourceId: mainInteractionId
+            ? this.data.interaction.media[mainInteractionId].mediaResourceId
+            : '',
           ...taskErrorProps,
           ...MetricsManager.getCommonTrackingFieldForAQMResponseFailed(error.details || {}),
         },
@@ -1442,31 +1405,35 @@ export default class Task extends EventEmitter implements ITask {
   public async consultTransfer(
     consultTransferPayload?: ConsultTransferPayLoad
   ): Promise<TaskResponse> {
-    // Get the destination agent ID using custom logic from participants data
-    const destAgentId = calculateDestAgentId(this.data.interaction, this.agentId);
-
-    // Resolve the target id (queue consult transfers go to the accepted agent)
-    if (!destAgentId) {
-      throw new Error('No agent has accepted this queue consult yet');
-    }
+    try {
+      // Get the destination agent ID using custom logic from participants data
+      const destAgentId = getDestinationAgentId(
+        this.data.interaction?.participants,
+        this.data.agentId
+      );
 
-    LoggerProxy.info(
-      `Initiating consult transfer to ${consultTransferPayload?.to || destAgentId}`,
-      {
-        module: TASK_FILE,
-        method: METHODS.CONSULT_TRANSFER,
-        interactionId: this.data.interactionId,
+      // Resolve the target id (queue consult transfers go to the accepted agent)
+      if (!destAgentId) {
+        throw new Error('No agent has accepted this queue consult yet');
       }
-    );
-
-    // Derive destination type from the participant's type property
-    const destType = calculateDestType(this.data.interaction, this.agentId);
-    // By default we always use the computed destAgentId as the target id
-    const consultTransferRequest: ConsultTransferPayLoad = {
-      to: destAgentId,
-      destinationType: destType,
-    };
-    try {
+
+      LoggerProxy.info(
+        `Initiating consult transfer to ${consultTransferPayload?.to || destAgentId}`,
+        {
+          module: TASK_FILE,
+          method: METHODS.CONSULT_TRANSFER,
+          interactionId: this.data.interactionId,
+        }
+      );
+      // Obtain payload based on desktop logic using TaskData
+      const finalDestinationType = deriveConsultTransferDestinationType(this.data);
+
+      // By default we always use the computed destAgentId as the target id
+      const consultTransferRequest: ConsultTransferPayLoad = {
+        to: destAgentId,
+        destinationType: finalDestinationType,
+      };
+
       const result = await this.contact.consultTransfer({
         interactionId: this.data.interactionId,
         data: consultTransferRequest,
@@ -1504,12 +1471,17 @@ export default class Task extends EventEmitter implements ITask {
         errorData: err.data?.errorData,
         reasonCode: err.data?.reasonCode,
       };
+      const failedDestinationType = deriveConsultTransferDestinationType(this.data);
+      const failedDestAgentId = getDestinationAgentId(
+        this.data.interaction?.participants,
+        this.data.agentId
+      );
       this.metricsManager.trackEvent(
         METRIC_EVENT_NAMES.TASK_TRANSFER_FAILED,
         {
           taskId: this.data.interactionId,
-          destination: destAgentId || '',
-          destinationType: destType,
+          destination: failedDestAgentId || '',
+          destinationType: failedDestinationType,
           isConsultTransfer: true,
           error: error.toString(),
           ...taskErrorProps,
@@ -1542,36 +1514,28 @@ export default class Task extends EventEmitter implements ITask {
    * ```
    */
   public async consultConference(): Promise<TaskResponse> {
-    // Get the destination agent ID dynamically from participants
-    // This handles multi-party conference scenarios, CBT (Capacity Based Team), and EP-DN cases
-    const destAgentId = calculateDestAgentId(this.data.interaction, this.agentId);
-
-    // Validate that we have a destination agent (for queue consult scenarios)
-    if (!destAgentId) {
-      throw new Error('No agent has accepted this queue consult yet');
-    }
-
-    // Get the destination agent ID for fetching destination type
-    // This helps determine the correct participant type for CBT (Capacity Based Team) and EP-DN scenarios
-    const destAgentType = calculateDestType(this.data.interaction, this.agentId);
-
     // Extract consultation conference data from task data (used in both try and catch)
     const consultationData = {
       agentId: this.agentId,
-      to: destAgentId,
-      destinationType: destAgentType || this.data.destinationType || 'agent',
+      destAgentId: this.data.destAgentId,
+      destinationType: this.data.destinationType || 'agent',
     };
 
     try {
-      LoggerProxy.info(`Initiating consult conference to ${destAgentId}`, {
+      LoggerProxy.info(`Initiating consult conference to ${consultationData.destAgentId}`, {
         module: TASK_FILE,
         method: METHODS.CONSULT_CONFERENCE,
         interactionId: this.data.interactionId,
       });
 
+      const paramsDataForConferenceV2 = buildConsultConferenceParamData(
+        consultationData,
+        this.data.interactionId
+      );
+
       const response = await this.contact.consultConference({
-        interactionId: this.data.interactionId,
-        data: consultationData,
+        interactionId: paramsDataForConferenceV2.interactionId,
+        data: paramsDataForConferenceV2.data,
       });
 
       // Track success metrics (following consultTransfer pattern)
@@ -1579,9 +1543,9 @@ export default class Task extends EventEmitter implements ITask {
         METRIC_EVENT_NAMES.TASK_CONFERENCE_START_SUCCESS,
         {
           taskId: this.data.interactionId,
-          destination: consultationData.to,
-          destinationType: consultationData.destinationType,
-          agentId: consultationData.agentId,
+          destination: paramsDataForConferenceV2.data.to,
+          destinationType: paramsDataForConferenceV2.data.destinationType,
+          agentId: paramsDataForConferenceV2.data.agentId,
           ...MetricsManager.getCommonTrackingFieldForAQMResponse(response),
         },
         ['operational', 'behavioral', 'business']
@@ -1604,13 +1568,20 @@ export default class Task extends EventEmitter implements ITask {
         reasonCode: err.data?.reasonCode,
       };
 
+      // Track failure metrics (following consultTransfer pattern)
+      // Build conference data for error tracking using extracted data
+      const failedParamsData = buildConsultConferenceParamData(
+        consultationData,
+        this.data.interactionId
+      );
+
       this.metricsManager.trackEvent(
         METRIC_EVENT_NAMES.TASK_CONFERENCE_START_FAILED,
         {
           taskId: this.data.interactionId,
-          destination: consultationData.to,
-          destinationType: consultationData.destinationType,
-          agentId: consultationData.agentId,
+          destination: failedParamsData.data.to,
+          destinationType: failedParamsData.data.destinationType,
+          agentId: failedParamsData.data.agentId,
           error: error.toString(),
           ...taskErrorProps,
           ...MetricsManager.getCommonTrackingFieldForAQMResponseFailed(error.details || {}),
@@ -1713,6 +1684,9 @@ export default class Task extends EventEmitter implements ITask {
     }
   }
 
+  // TODO: Uncomment this method in future PR for Multi-Party Conference support (>3 participants)
+  // Conference transfer will be supported when implementing enhanced multi-party conference functionality
+  /*
   /**
    * Transfers the current conference to another agent
    *
@@ -1733,7 +1707,7 @@ export default class Task extends EventEmitter implements ITask {
    * }
    * ```
    */
-  public async transferConference(): Promise<TaskResponse> {
+  /* public async transferConference(): Promise<TaskResponse> {
     try {
       LoggerProxy.info(`Transferring conference`, {
         module: TASK_FILE,
@@ -1797,5 +1771,5 @@ export default class Task extends EventEmitter implements ITask {
 
       throw err;
     }
-  }
+  } */
 }