@webex/contact-center 3.10.0-next.3 → 3.10.0-next.31

package/src/services/task/TaskManager.ts

@@ -17,6 +17,8 @@ import {
   getIsConferenceInProgress,
   isParticipantInMainInteraction,
   isPrimary,
+  isSecondaryEpDnAgent,
+  shouldAutoAnswerTask,
 } from './TaskUtils';
 
 /** @internal */
@@ -35,6 +37,7 @@ export default class TaskManager extends EventEmitter {
   private static taskManager;
   private wrapupData: WrapupData;
   private agentId: string;
+  private webRtcEnabled: boolean;
   /**
    * @param contact - Routing Contact layer. Talks to AQMReq layer to convert events to promises
    * @param webCallingService - Webrtc Service Layer
@@ -72,6 +75,10 @@ export default class TaskManager extends EventEmitter {
     return this.agentId;
   }
 
+  public setWebRtcEnabled(webRtcEnabled: boolean) {
+    this.webRtcEnabled = webRtcEnabled;
+  }
+
   private handleIncomingWebCall = (call: ICall) => {
     const currentTask = Object.values(this.taskCollection).find(
       (task) => task.data.interaction.mediaType === 'telephony'
@@ -129,10 +136,13 @@ export default class TaskManager extends EventEmitter {
                 interactionId: payload.data.interactionId,
               });
 
-              // Pre-calculate isConferenceInProgress for the initial task data
-              const simulatedTaskForAgentContact = {
-                data: {...payload.data},
-              } as ITask;
+              // Check if auto-answer should happen for this task
+              const shouldAutoAnswer = shouldAutoAnswerTask(
+                payload.data,
+                this.agentId,
+                this.webCallingService.loginOption,
+                this.webRtcEnabled
+              );
 
               task = new Task(
                 this.contact,
@@ -141,7 +151,8 @@ export default class TaskManager extends EventEmitter {
                   ...payload.data,
                   wrapUpRequired:
                     payload.data.interaction?.participants?.[this.agentId]?.isWrapUp || false,
-                  isConferenceInProgress: getIsConferenceInProgress(simulatedTaskForAgentContact),
+                  isConferenceInProgress: getIsConferenceInProgress(payload.data),
+                  isAutoAnswering: shouldAutoAnswer, // Set flag before emitting
                 },
                 this.wrapupData,
                 this.agentId
@@ -173,13 +184,22 @@ export default class TaskManager extends EventEmitter {
             }
             break;
 
-          case CC_EVENTS.AGENT_CONTACT_RESERVED:
+          case CC_EVENTS.AGENT_CONTACT_RESERVED: {
+            // Check if auto-answer should happen for this task
+            const shouldAutoAnswerReserved = shouldAutoAnswerTask(
+              payload.data,
+              this.agentId,
+              this.webCallingService.loginOption,
+              this.webRtcEnabled
+            );
+
             task = new Task(
               this.contact,
               this.webCallingService,
               {
                 ...payload.data,
                 isConsulted: false,
+                isAutoAnswering: shouldAutoAnswerReserved, // Set flag before emitting
               },
               this.wrapupData,
               this.agentId
@@ -194,6 +214,7 @@ export default class TaskManager extends EventEmitter {
               this.emit(TASK_EVENTS.TASK_INCOMING, task);
             }
             break;
+          }
           case CC_EVENTS.AGENT_OFFER_CONTACT:
             // We don't have to emit any event here since this will be result of promise.
             task = this.updateTaskData(task, payload.data);
@@ -203,17 +224,29 @@ export default class TaskManager extends EventEmitter {
               interactionId: payload.data?.interactionId,
             });
             this.emit(TASK_EVENTS.TASK_OFFER_CONTACT, task);
+
+            // Handle auto-answer for offer contact
+            this.handleAutoAnswer(task);
             break;
           case CC_EVENTS.AGENT_OUTBOUND_FAILED:
-            // We don't have to emit any event here since this will be result of promise.
-            if (task.data) {
-              this.removeTaskFromCollection(task);
+            if (task) {
+              task = this.updateTaskData(task, payload.data);
+              this.metricsManager.trackEvent(
+                METRIC_EVENT_NAMES.TASK_OUTDIAL_FAILED,
+                {
+                  ...MetricsManager.getCommonTrackingFieldForAQMResponse(payload.data),
+                  taskId: payload.data.interactionId,
+                  reason: payload.data.reasonCode || payload.data.reason,
+                },
+                ['behavioral', 'operational']
+              );
+              LoggerProxy.log(`Agent outbound failed for task`, {
+                module: TASK_MANAGER_FILE,
+                method: METHODS.REGISTER_TASK_LISTENERS,
+                interactionId: payload.data.interactionId,
+              });
+              task.emit(TASK_EVENTS.TASK_OUTDIAL_FAILED, payload.data.reason ?? 'UNKNOWN_REASON');
             }
-            LoggerProxy.log(`Agent outbound failed for task`, {
-              module: TASK_MANAGER_FILE,
-              method: METHODS.REGISTER_TASK_LISTENERS,
-              interactionId: payload.data?.interactionId,
-            });
             break;
           case CC_EVENTS.AGENT_CONTACT_ASSIGNED:
             task = this.updateTaskData(task, payload.data);
@@ -252,13 +285,23 @@ export default class TaskManager extends EventEmitter {
             break;
           }
           case CC_EVENTS.CONTACT_ENDED:
-            task = this.updateTaskData(task, {
-              ...payload.data,
-              wrapUpRequired: payload.data.interaction.state !== 'new',
-            });
-            this.handleTaskCleanup(task);
-            task.emit(TASK_EVENTS.TASK_END, task);
+            // Update task data
+            if (task) {
+              task = this.updateTaskData(task, {
+                ...payload.data,
+                wrapUpRequired:
+                  payload.data.interaction.state !== 'new' &&
+                  !isSecondaryEpDnAgent(payload.data.interaction),
+              });
+
+              // Handle cleanup based on whether task should be deleted
+              this.handleTaskCleanup(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
@@ -296,6 +339,9 @@ export default class TaskManager extends EventEmitter {
               isConsulted: true, // This ensures that the task is marked as us being requested for a consult
             });
             task.emit(TASK_EVENTS.TASK_OFFER_CONSULT, task);
+
+            // Handle auto-answer for consult offer
+            this.handleAutoAnswer(task);
             break;
           case CC_EVENTS.AGENT_CONSULTING:
             // Received when agent is in an active consult state
@@ -380,32 +426,22 @@ export default class TaskManager extends EventEmitter {
             } else {
               this.removeTaskFromCollection(task);
             }
-            task?.emit(TASK_EVENTS.TASK_CONFERENCE_ENDED, task);
+            task.emit(TASK_EVENTS.TASK_CONFERENCE_ENDED, task);
             break;
           case CC_EVENTS.PARTICIPANT_JOINED_CONFERENCE: {
-            // Participant joined conference - update task state with participant information and emit event
-            // Pre-calculate isConferenceInProgress with updated data to avoid double update
-            const simulatedTaskForJoin = {
-              ...task,
-              data: {...task.data, ...payload.data},
-            };
             task = this.updateTaskData(task, {
               ...payload.data,
-              isConferenceInProgress: getIsConferenceInProgress(simulatedTaskForJoin),
+              isConferenceInProgress: getIsConferenceInProgress(payload.data),
             });
             task.emit(TASK_EVENTS.TASK_PARTICIPANT_JOINED, task);
             break;
           }
           case CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE: {
             // Conference ended - update task state and emit event
-            // Pre-calculate isConferenceInProgress with updated data to avoid double update
-            const simulatedTaskForLeft = {
-              ...task,
-              data: {...task.data, ...payload.data},
-            };
+
             task = this.updateTaskData(task, {
               ...payload.data,
-              isConferenceInProgress: getIsConferenceInProgress(simulatedTaskForLeft),
+              isConferenceInProgress: getIsConferenceInProgress(payload.data),
             });
             if (checkParticipantNotInInteraction(task, this.agentId)) {
               if (
@@ -441,13 +477,10 @@ 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;
@@ -487,6 +520,54 @@ 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];
@@ -498,7 +579,79 @@ export default class TaskManager extends EventEmitter {
     }
   }
 
+  /**
+   * Handles auto-answer logic for incoming tasks
+   * Automatically accepts tasks when isAutoAnswering flag is set
+   * The flag is set during task creation based on:
+   * 1. WebRTC calls with auto-answer enabled in agent profile
+   * 2. Agent-initiated WebRTC outdial calls
+   * 3. Agent-initiated digital outbound (Email/SMS) without previous transfers
+   *
+   * @param task - The task to auto-answer
+   * @private
+   */
+  private async handleAutoAnswer(task: ITask): Promise<void> {
+    if (!task || !task.data || !task.data.isAutoAnswering) {
+      return;
+    }
+
+    LoggerProxy.info(`Auto-answering task`, {
+      module: TASK_MANAGER_FILE,
+      method: 'handleAutoAnswer',
+      interactionId: task.data.interactionId,
+    });
+
+    try {
+      await task.accept();
+      LoggerProxy.info(`Task auto-answered successfully`, {
+        module: TASK_MANAGER_FILE,
+        method: 'handleAutoAnswer',
+        interactionId: task.data.interactionId,
+      });
+
+      // Track successful auto-answer
+      this.metricsManager.trackEvent(
+        METRIC_EVENT_NAMES.TASK_AUTO_ANSWER_SUCCESS,
+        {
+          taskId: task.data.interactionId,
+          mediaType: task.data.interaction.mediaType,
+          isAutoAnswered: true,
+        },
+        ['behavioral', 'operational']
+      );
+      // Emit task:autoAnswered event for widgets/UI to react
+      task.emit(TASK_EVENTS.TASK_AUTO_ANSWERED, task);
+    } catch (error) {
+      // Reset isAutoAnswering flag on failure
+      task.updateTaskData({...task.data, isAutoAnswering: false});
+      LoggerProxy.error(`Failed to auto-answer task`, {
+        module: TASK_MANAGER_FILE,
+        method: 'handleAutoAnswer',
+        interactionId: task.data.interactionId,
+        error,
+      });
+
+      // Track auto-answer failure
+      this.metricsManager.trackEvent(
+        METRIC_EVENT_NAMES.TASK_AUTO_ANSWER_FAILED,
+        {
+          taskId: task.data.interactionId,
+          mediaType: task.data.interaction.mediaType,
+          error: error?.message || 'Unknown error',
+          isAutoAnswered: false,
+        },
+        ['behavioral', 'operational']
+      );
+    }
+  }
+
+  /**
+   * 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'
@@ -506,9 +659,16 @@ export default class TaskManager extends EventEmitter {
       task.unregisterWebCallListeners();
       this.webCallingService.cleanUpCall();
     }
-    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.
+
+    const isOutdial = task.data.interaction.outboundType === 'OUTDIAL';
+    const isNew = task.data.interaction.state === 'new';
+    const needsWrapUp = task.data.agentsPendingWrapUp?.length > 0;
+
+    // For OUTDIAL: only remove if NOT terminated (user-declined, no wrap-up follows)
+    // If terminated, keep task for wrap-up flow (CONTACT_ENDED → AGENT_WRAPUP)
+    // For non-OUTDIAL: remove if state is 'new'
+    // Always remove if secondary EpDn agent
+    if ((isNew && !(isOutdial && needsWrapUp)) || isSecondaryEpDnAgent(task.data.interaction)) {
       this.removeTaskFromCollection(task);
     }
   }

package/src/services/task/TaskUtils.ts

@@ -1,5 +1,7 @@
 /* eslint-disable import/prefer-default-export */
-import {ITask} from './types';
+import {Interaction, ITask, TaskData, MEDIA_CHANNEL} from './types';
+import {OUTDIAL_DIRECTION, OUTDIAL_MEDIA_TYPE, OUTBOUND_TYPE} from '../../constants';
+import {LoginOption} from '../../types';
 
 /**
  * Determines if the given agent is the primary agent (owner) of the task
@@ -53,13 +55,13 @@ export const checkParticipantNotInInteraction = (task: ITask, agentId: string):
 
 /**
  * Determines if a conference is currently in progress based on the number of active agent participants
- * @param task - The task to check for conference status
+ * @param TaskData - The payLoad data to check for conference status
  * @returns true if there are 2 or more active agent participants in the main call, false otherwise
  */
-export const getIsConferenceInProgress = (task: ITask): boolean => {
-  const mediaMainCall = task?.data?.interaction?.media?.[task?.data?.interactionId];
+export const getIsConferenceInProgress = (data: TaskData): boolean => {
+  const mediaMainCall = data.interaction.media?.[data?.interactionId];
   const participantsInMainCall = new Set(mediaMainCall?.participants);
-  const participants = task?.data?.interaction?.participants;
+  const participants = data.interaction.participants;
 
   const agentParticipants = new Set();
   if (participantsInMainCall.size > 0) {
@@ -79,3 +81,141 @@ export const getIsConferenceInProgress = (task: ITask): boolean => {
 
   return agentParticipants.size >= 2;
 };
+
+/**
+ * Checks if the current agent is a secondary agent in a consultation scenario.
+ * Secondary agents are those who were consulted (not the original call owner).
+ * @param task - The task object containing interaction details
+ * @returns true if this is a secondary agent (consulted party), false otherwise
+ */
+export const isSecondaryAgent = (interaction: Interaction): boolean => {
+  if (!interaction.callProcessingDetails) {
+    return false;
+  }
+
+  return (
+    interaction.callProcessingDetails.relationshipType === 'consult' &&
+    !!interaction.callProcessingDetails.parentInteractionId &&
+    interaction.callProcessingDetails.parentInteractionId !== interaction.interactionId
+  );
+};
+
+/**
+ * Checks if the current agent is a secondary EP-DN (Entry Point Dial Number) agent.
+ * This is specifically for telephony consultations to external numbers/entry points.
+ * @param task - The task object containing interaction details
+ * @returns true if this is a secondary EP-DN agent in telephony consultation, false otherwise
+ */
+export const isSecondaryEpDnAgent = (interaction: Interaction): boolean => {
+  if (!interaction) {
+    return false;
+  }
+
+  return interaction.mediaType === 'telephony' && isSecondaryAgent(interaction);
+};
+
+/**
+ * Checks if auto-answer is enabled for the agent participant
+ * @param interaction - The interaction object
+ * @param agentId - Current agent ID
+ * @returns true if auto-answer is enabled, false otherwise
+ */
+export const isAutoAnswerEnabled = (interaction: Interaction, agentId: string): boolean => {
+  return interaction.participants?.[agentId]?.autoAnswerEnabled === true;
+};
+
+/**
+ * Checks if the interaction is a WebRTC call eligible for auto-answer
+ * @param interaction - The interaction object
+ * @param loginOption - The agent's login option (BROWSER, AGENT_DN, etc.)
+ * @param webRtcEnabled - Whether WebRTC is enabled for the agent
+ * @returns true if this is a WebRTC call, false otherwise
+ */
+export const isWebRTCCall = (
+  interaction: Interaction,
+  loginOption: string,
+  webRtcEnabled: boolean
+): boolean => {
+  return (
+    webRtcEnabled &&
+    loginOption === LoginOption.BROWSER &&
+    interaction.mediaType === OUTDIAL_MEDIA_TYPE
+  );
+};
+
+/**
+ * Checks if the interaction is a digital outbound (Email/SMS)
+ * @param interaction - The interaction object
+ * @returns true if this is a digital outbound, false otherwise
+ */
+export const isDigitalOutbound = (interaction: Interaction): boolean => {
+  return (
+    interaction.contactDirection?.type === OUTDIAL_DIRECTION &&
+    interaction.outboundType === OUTBOUND_TYPE &&
+    (interaction.mediaChannel === MEDIA_CHANNEL.EMAIL ||
+      interaction.mediaChannel === MEDIA_CHANNEL.SMS)
+  );
+};
+
+/**
+ * Checks if the outdial was initiated by the current agent
+ * @param interaction - The interaction object
+ * @param agentId - Current agent ID
+ * @returns true if agent initiated the outdial, false otherwise
+ */
+export const hasAgentInitiatedOutdial = (interaction: Interaction, agentId: string): boolean => {
+  return (
+    interaction.contactDirection?.type === OUTDIAL_DIRECTION &&
+    interaction.outboundType === OUTBOUND_TYPE &&
+    interaction.callProcessingDetails?.outdialAgentId === agentId &&
+    interaction.owner === agentId &&
+    !interaction.callProcessingDetails?.BLIND_TRANSFER_IN_PROGRESS
+  );
+};
+
+/**
+ * Determines if a task should be auto-answered based on interaction data
+ * Auto-answer logic handles:
+ * 1. WebRTC calls with auto-answer enabled in agent profile
+ * 2. Agent-initiated WebRTC outdial calls
+ * 3. Agent-initiated digital outbound (Email/SMS) without previous transfers
+ *
+ * @param taskData - The task data
+ * @param agentId - Current agent ID
+ * @param loginOption - Agent's login option
+ * @param webRtcEnabled - Whether WebRTC is enabled for the agent
+ * @returns true if task should be auto-answered, false otherwise
+ */
+export const shouldAutoAnswerTask = (
+  taskData: TaskData,
+  agentId: string,
+  loginOption: string,
+  webRtcEnabled: boolean
+): boolean => {
+  const {interaction} = taskData;
+
+  if (!interaction || !agentId) {
+    return false;
+  }
+
+  // Check if auto-answer is enabled for this agent
+  const autoAnswerEnabled = isAutoAnswerEnabled(interaction, agentId);
+
+  // Check if this is an agent-initiated outdial
+  const agentInitiatedOutdial = hasAgentInitiatedOutdial(interaction, agentId);
+
+  // WebRTC telephony calls
+  if (isWebRTCCall(interaction, loginOption, webRtcEnabled)) {
+    return autoAnswerEnabled || agentInitiatedOutdial;
+  }
+
+  // Digital outbound (Email/SMS)
+  if (isDigitalOutbound(interaction) && agentInitiatedOutdial) {
+    // Don't auto-answer if task has been transferred (has previous vteams)
+    const hasPreviousVteams = interaction.previousVTeams && interaction.previousVTeams.length > 0;
+
+    return !hasPreviousVteams;
+  }
+
+  return false;
+};

package/src/services/task/constants.ts

@@ -34,6 +34,8 @@ export const PRESERVED_TASK_DATA_FIELDS = {
   WRAP_UP_REQUIRED: 'wrapUpRequired',
   /** Indicates if a conference is currently in progress (2+ active agents) */
   IS_CONFERENCE_IN_PROGRESS: 'isConferenceInProgress',
+  /** Indicates if auto-answer is in progress for this task */
+  IS_AUTO_ANSWERING: 'isAutoAnswering',
 };
 
 /**