@webex/contact-center 3.10.0-next.18 → 3.10.0-next.19

package/src/services/task/TaskManager.ts

@@ -18,6 +18,7 @@ import {
   isParticipantInMainInteraction,
   isPrimary,
   isSecondaryEpDnAgent,
+  shouldAutoAnswerTask,
 } from './TaskUtils';
 
 /** @internal */
@@ -36,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
@@ -73,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'
@@ -130,6 +136,14 @@ export default class TaskManager extends EventEmitter {
                 interactionId: payload.data.interactionId,
               });
 
+              // 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,
                 this.webCallingService,
@@ -138,6 +152,7 @@ export default class TaskManager extends EventEmitter {
                   wrapUpRequired:
                     payload.data.interaction?.participants?.[this.agentId]?.isWrapUp || false,
                   isConferenceInProgress: getIsConferenceInProgress(payload.data),
+                  isAutoAnswering: shouldAutoAnswer, // Set flag before emitting
                 },
                 this.wrapupData,
                 this.agentId
@@ -169,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
@@ -190,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);
@@ -199,24 +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:
-            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');
+            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');
+            }
             break;
           case CC_EVENTS.AGENT_CONTACT_ASSIGNED:
             task = this.updateTaskData(task, payload.data);
@@ -256,18 +286,19 @@ export default class TaskManager extends EventEmitter {
           }
           case CC_EVENTS.CONTACT_ENDED:
             // Update task data
-            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);
+            if (task) {
+              task = this.updateTaskData(task, {
+                ...payload.data,
+                wrapUpRequired:
+                  payload.data.interaction.state !== 'new' &&
+                  !isSecondaryEpDnAgent(payload.data.interaction),
+              });
 
-            task?.emit(TASK_EVENTS.TASK_END, task);
+              // 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);
@@ -308,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
@@ -545,6 +579,70 @@ 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']
+      );
+    } 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
@@ -562,13 +660,13 @@ export default class TaskManager extends EventEmitter {
 
     const isOutdial = task.data.interaction.outboundType === 'OUTDIAL';
     const isNew = task.data.interaction.state === 'new';
-    const isTerminated = task.data.interaction.isTerminated;
+    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 && isTerminated)) || isSecondaryEpDnAgent(task.data.interaction)) {
+    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 {Interaction, ITask, TaskData} 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
@@ -111,3 +113,109 @@ export const isSecondaryEpDnAgent = (interaction: Interaction): boolean => {
 
   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',
 };
 
 /**

package/src/services/task/types.ts

@@ -672,6 +672,8 @@ export type Interaction = {
     BLIND_TRANSFER_IN_PROGRESS?: boolean;
     /** Desktop view configuration for Flow Control */
     fcDesktopView?: string;
+    /** Agent ID who initiated the outdial call */
+    outdialAgentId?: string;
   };
   /** Main interaction identifier for related interactions */
   mainInteractionId?: string;
@@ -797,6 +799,10 @@ export type TaskData = {
   reservedAgentChannelId?: string;
   /** Indicates if wrap-up is required for this task */
   wrapUpRequired?: boolean;
+  /** Indicates if auto-answer is in progress for this task */
+  isAutoAnswering?: boolean;
+  /** Indicates if wrap-up is required for this task */
+  agentsPendingWrapUp?: string[];
 };
 
 /**

package/test/unit/spec/cc.ts

@@ -141,6 +141,7 @@ describe('webex.cc', () => {
       task: undefined,
       setWrapupData: jest.fn(),
       setAgentId: jest.fn(),
+      setWebRtcEnabled: jest.fn(),
       registerIncomingCallEvent: jest.fn(),
       registerTaskListeners: jest.fn(),
       getTask: jest.fn(),

package/test/unit/spec/metrics/behavioral-events.ts

@@ -152,6 +152,20 @@ describe('metrics/behavioral-events', () => {
         verb: 'fail',
       });
 
+      expect(getEventTaxonomy(METRIC_EVENT_NAMES.TASK_AUTO_ANSWER_SUCCESS)).toEqual({
+        product,
+        agent: 'user',
+        target: 'task_auto_answer',
+        verb: 'complete',
+      });
+
+      expect(getEventTaxonomy(METRIC_EVENT_NAMES.TASK_AUTO_ANSWER_FAILED)).toEqual({
+        product,
+        agent: 'user',
+        target: 'task_auto_answer',
+        verb: 'fail',
+      });
+
       expect(getEventTaxonomy('' as METRIC_EVENT_NAMES)).toEqual(undefined);
     });
   });

package/test/unit/spec/services/task/TaskManager.ts

@@ -736,6 +736,148 @@ describe('TaskManager', () => {
     expect(taskEmitSpy).toHaveBeenCalledWith(TASK_EVENTS.TASK_OUTDIAL_FAILED, 'CUSTOMER_BUSY');
   });
 
+  it('should handle AGENT_OUTBOUND_FAILED gracefully when task is undefined', () => {
+    const payload = {
+      data: {
+        type: CC_EVENTS.AGENT_OUTBOUND_FAILED,
+        interactionId: 'non-existent-task-id',
+        reason: 'CUSTOMER_BUSY',
+      },
+    };
+    // Should not throw error when task doesn't exist
+    expect(() => {
+      webSocketManagerMock.emit('message', JSON.stringify(payload));
+    }).not.toThrow();
+  });
+
+  it('should NOT remove OUTDIAL task on CONTACT_ENDED when agentsPendingWrapUp exists', () => {
+    const task = taskManager.getTask(taskId);
+    task.updateTaskData = jest.fn().mockImplementation((newData) => {
+      task.data = {
+        ...task.data,
+        ...newData,
+        interaction: {
+          ...task.data.interaction,
+          outboundType: 'OUTDIAL',
+          state: 'new',
+          mediaType: 'telephony',
+        },
+        agentsPendingWrapUp: ['agent-123'],
+      };
+      return task;
+    });
+    task.unregisterWebCallListeners = jest.fn();
+    const removeTaskSpy = jest.spyOn(taskManager, 'removeTaskFromCollection');
+
+    const payload = {
+      data: {
+        type: CC_EVENTS.CONTACT_ENDED,
+        interactionId: taskId,
+        interaction: {
+          outboundType: 'OUTDIAL',
+          state: 'new',
+          mediaType: 'telephony',
+        },
+        agentsPendingWrapUp: ['agent-123'],
+      },
+    };
+
+    webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+    expect(removeTaskSpy).not.toHaveBeenCalled();
+    expect(taskManager.getTask(taskId)).toBeDefined();
+  });
+
+  it('should remove OUTDIAL task on CONTACT_ENDED when agentsPendingWrapUp is empty', () => {
+    const task = taskManager.getTask(taskId);
+    task.updateTaskData = jest.fn().mockImplementation((newData) => {
+      task.data = {
+        ...task.data,
+        ...newData,
+        interaction: {
+          ...task.data.interaction,
+          outboundType: 'OUTDIAL',
+          state: 'new',
+          mediaType: 'telephony',
+        },
+        agentsPendingWrapUp: [],
+      };
+      return task;
+    });
+    task.unregisterWebCallListeners = jest.fn();
+    const removeTaskSpy = jest.spyOn(taskManager, 'removeTaskFromCollection');
+
+    const payload = {
+      data: {
+        type: CC_EVENTS.CONTACT_ENDED,
+        interactionId: taskId,
+        interaction: {
+          outboundType: 'OUTDIAL',
+          state: 'new',
+          mediaType: 'telephony',
+        },
+        agentsPendingWrapUp: [],
+      },
+    };
+
+    webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+    expect(removeTaskSpy).toHaveBeenCalled();
+  });
+
+  it('should remove OUTDIAL task on CONTACT_ENDED when agentsPendingWrapUp is undefined', () => {
+    const task = taskManager.getTask(taskId);
+    task.updateTaskData = jest.fn().mockImplementation((newData) => {
+      task.data = {
+        ...task.data,
+        ...newData,
+        interaction: {
+          ...task.data.interaction,
+          outboundType: 'OUTDIAL',
+          state: 'new',
+          mediaType: 'telephony',
+        },
+        // agentsPendingWrapUp is undefined
+      };
+      return task;
+    });
+    task.unregisterWebCallListeners = jest.fn();
+    const removeTaskSpy = jest.spyOn(taskManager, 'removeTaskFromCollection');
+
+    const payload = {
+      data: {
+        type: CC_EVENTS.CONTACT_ENDED,
+        interactionId: taskId,
+        interaction: {
+          outboundType: 'OUTDIAL',
+          state: 'new',
+          mediaType: 'telephony',
+        },
+        // agentsPendingWrapUp not included
+      },
+    };
+
+    webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+    expect(removeTaskSpy).toHaveBeenCalled();
+  });
+
+  it('should handle CONTACT_ENDED gracefully when task is undefined', () => {
+    const payload = {
+      data: {
+        type: CC_EVENTS.CONTACT_ENDED,
+        interactionId: 'non-existent-task-id',
+        interaction: {
+          state: 'new',
+        },
+      },
+    };
+    // Should not throw error when task doesn't exist
+    expect(() => {
+      webSocketManagerMock.emit('message', JSON.stringify(payload));
+    }).not.toThrow();
+  });
+
   it('should remove OUTDIAL task from taskCollection on AGENT_CONTACT_ASSIGN_FAILED when NOT terminated (user-declined)', () => {
     const task = taskManager.getTask(taskId);
     task.updateTaskData = jest.fn().mockImplementation((newData) => {
@@ -2191,5 +2333,6 @@ describe('TaskManager', () => {
       );
     });
   });
+
 });