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

package/dist/services/task/TaskManager.js

@@ -14,11 +14,13 @@ var _types3 = require("../../types");
 var _loggerProxy = _interopRequireDefault(require("../../logger-proxy"));
 var _TaskUtils = require("./TaskUtils");
 var _TaskFactory = _interopRequireDefault(require("./TaskFactory"));
+var _WebexCallingUtils = require("./WebexCallingUtils");
 var _WebRTC = _interopRequireDefault(require("./voice/WebRTC"));
 var _stateMachine = require("./state-machine");
 var _taskDataNormalizer = require("./taskDataNormalizer");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const CC_EVENT_SET = new Set(Object.values(_types2.CC_EVENTS));
+const MAIN_INTERACTION_CORRELATED_EVENTS = new Set([_types2.CC_EVENTS.AGENT_CONSULT_ENDED, _types2.CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE]);
 const isCcEvent = value => CC_EVENT_SET.has(value);
 
 /** @internal */
@@ -109,6 +111,9 @@ class TaskManager extends _events.default {
   setWebRtcEnabled(webRtcEnabled) {
     this.webRtcEnabled = webRtcEnabled;
   }
+  setAnswerCallOnWebexService(answerCallOnWebexService) {
+    this.answerCallOnWebexService = answerCallOnWebexService;
+  }
   handleIncomingWebCall = call => {
     const currentTask = Object.values(this.taskCollection).find(task => task.data.interaction.mediaType === 'telephony' && !(0, _TaskUtils.isCampaignPreviewReservation)(task));
     if (currentTask) {
@@ -139,9 +144,10 @@ class TaskManager extends _events.default {
    * @param ccEvent - The CC_EVENT type from WebSocket
    * @param payload - The event payload
    * @param agentId - Optional agent ID for state detection (needed for HYDRATE)
+   * @param task - Optional task instance for state-aware CONTACT_ENDED mapping
    * @returns TaskEventPayload for state machine or null if no mapping
    */
-  static mapEventToTaskStateMachineEvent(ccEvent, payload, agentId) {
+  static mapEventToTaskStateMachineEvent(ccEvent, payload, agentId, task, enableWxBetterTogether) {
     const mediaResourceId = payload.mediaResourceId || payload.interaction?.media?.[payload.interactionId]?.mediaResourceId;
     switch (ccEvent) {
       // CC -> TaskEvent mappings (see TaskStateMachine comment for quick reference)
@@ -284,13 +290,31 @@ class TaskManager extends _events.default {
           taskData: payload
         };
       case _types2.CC_EVENTS.CONTACT_ENDED:
-        return {
-          type: _stateMachine.TaskEvent.CONTACT_ENDED,
-          taskData: {
-            ...payload,
-            wrapUpRequired: (0, _TaskUtils.isCampaignPreviewTask)(payload) ? false : payload.agentsPendingWrapUp?.includes(agentId || '') || false
+        {
+          const wrapUpRequired = (0, _TaskUtils.isCampaignPreviewTask)(payload) ? false : payload.agentsPendingWrapUp?.includes(agentId || '') || false;
+
+          // Post-accept wxApp outdial agent-end delivers ContactEnded instead of
+          // AgentOutboundFailed. Normalize to OUTBOUND_FAILED so state machine
+          // enters WRAPPING_UP and emits TASK_OUTDIAL_FAILED (AGENT_ENDS).
+          // Pre-accept cancelTask decline stays CONTACT_ENDED → TERMINATED (no wrapup).
+          if (TaskManager.isAgentTerminatedOutdialWrapup(payload, wrapUpRequired, task, agentId, enableWxBetterTogether)) {
+            return {
+              type: _stateMachine.TaskEvent.OUTBOUND_FAILED,
+              reason: 'AGENT_ENDS',
+              taskData: {
+                ...payload,
+                wrapUpRequired: true
+              }
+            };
           }
-        };
+          return {
+            type: _stateMachine.TaskEvent.CONTACT_ENDED,
+            taskData: {
+              ...payload,
+              wrapUpRequired
+            }
+          };
+        }
       case _types2.CC_EVENTS.AGENT_INVITE_FAILED:
         return {
           type: _stateMachine.TaskEvent.INVITE_FAILED,
@@ -308,11 +332,18 @@ class TaskManager extends _events.default {
           reason: payload.reason
         };
       case _types2.CC_EVENTS.AGENT_OUTBOUND_FAILED:
-        return {
-          type: _stateMachine.TaskEvent.OUTBOUND_FAILED,
-          taskData: payload,
-          reason: payload.reason
-        };
+        {
+          const isAgentTerminatedOutdial = payload.interaction?.outboundType === 'OUTDIAL' && (payload.terminatingParty === 'Agent' || payload.reason === 'AGENT_ENDS');
+          const suppressOutdialFailedPopup = isAgentTerminatedOutdial && !TaskManager.isWxAppManagedOutdialTask(agentId, payload, task, enableWxBetterTogether);
+          return {
+            type: _stateMachine.TaskEvent.OUTBOUND_FAILED,
+            taskData: suppressOutdialFailedPopup ? {
+              ...payload,
+              suppressOutdialFailedPopup: true
+            } : payload,
+            reason: payload.reason
+          };
+        }
       case _types2.CC_EVENTS.CAMPAIGN_PREVIEW_ACCEPT_FAILED:
         return {
           type: _stateMachine.TaskEvent.CAMPAIGN_PREVIEW_ACCEPT_FAILED,
@@ -385,6 +416,43 @@ class TaskManager extends _events.default {
     }
   }
 
+  /**
+   * True when the current agent's task is a wxApp-managed outdial (thick-client telephony).
+   */
+  static isWxAppManagedOutdialTask(agentId, payload, task, enableWxBetterTogether) {
+    const wxAppEnabled = task?.uiControlConfig?.enableWxBetterTogether ?? enableWxBetterTogether ?? false;
+    if (!wxAppEnabled) {
+      return false;
+    }
+    const effectiveAgentId = agentId ?? task?.data?.agentId;
+    const participants = payload.interaction?.participants ?? task?.data?.interaction?.participants;
+    const details = (0, _WebexCallingUtils.getWebexCallingDeviceDetailsForAgent)(effectiveAgentId, participants);
+    return details?.deviceType === 'wxApp';
+  }
+
+  /**
+   * True when ContactEnded represents an agent-terminated wxApp outdial that should
+   * enter wrapup with an outdial-failed popup (legacy AgentOutboundFailed parity).
+   */
+  static isAgentTerminatedOutdialWrapup(payload, wrapUpRequired, task, agentId, enableWxBetterTogether) {
+    const isOutdial = payload.interaction?.outboundType === 'OUTDIAL';
+    const agentTerminated = payload.terminatingParty === 'Agent';
+    if (!isOutdial || !agentTerminated) {
+      return false;
+    }
+    if (!TaskManager.isWxAppManagedOutdialTask(agentId, payload, task, enableWxBetterTogether)) {
+      return false;
+    }
+    const wxAppAnswerPending = task?.uiControlConfig?.wxAppAnswerPending ?? false;
+
+    // Pre-accept decline: decline() clears wxAppAnswerPending; backend may still send state wrapUp.
+    if (!wxAppAnswerPending && !wrapUpRequired) {
+      return false;
+    }
+    const interactionWrapUp = payload.interaction?.state === 'wrapUp';
+    return wrapUpRequired || interactionWrapUp || wxAppAnswerPending;
+  }
+
   /**
    * Register WebSocket message listeners for task events
    *
@@ -493,6 +561,9 @@ class TaskManager extends _events.default {
         this.taskCollection[interactionId] = task;
       }
     }
+    if (!task && MAIN_INTERACTION_CORRELATED_EVENTS.has(eventType)) {
+      task = this.findUniqueTaskByRelatedInteraction(message.data);
+    }
     const wasConsultedTask = Boolean(task?.data?.isConsulted);
     const computeWrapUpRequired = () => {
       if (message.data.wrapUpRequired !== undefined) {
@@ -507,7 +578,7 @@ class TaskManager extends _events.default {
       ...message.data,
       wrapUpRequired: computeWrapUpRequired()
     } : message.data;
-    const stateMachineEvent = TaskManager.mapEventToTaskStateMachineEvent(eventType, adjustedPayload, this.agentId);
+    const stateMachineEvent = TaskManager.mapEventToTaskStateMachineEvent(eventType, adjustedPayload, this.agentId, task, this.configFlags?.enableWxBetterTogether);
     _loggerProxy.default.info(`Handling task event ${eventType}`, {
       module: _constants.TASK_MANAGER_FILE,
       method: 'prepareEventContext',
@@ -521,6 +592,33 @@ class TaskManager extends _events.default {
     };
   }
 
+  /**
+   * Resolve lifecycle events that are emitted for the main interaction while the
+   * local task can still be indexed by a child consult interaction. Exact task
+   * keys are handled before this fallback. Multiple aliases of the same task are
+   * treated as one candidate; genuinely ambiguous matches are intentionally ignored.
+   */
+  findUniqueTaskByRelatedInteraction(payload) {
+    const payloadInteractionIds = new Set([payload.interactionId, payload.interaction?.interactionId, payload.interaction?.mainInteractionId, payload.interaction?.parentInteractionId, payload.interaction?.callProcessingDetails?.parentInteractionId].filter(interactionId => Boolean(interactionId)));
+    if (payloadInteractionIds.size === 0) return undefined;
+    const candidates = [...new Set(Object.values(this.taskCollection).filter(candidate => {
+      const taskInteraction = candidate?.data?.interaction;
+      const candidateInteractionIds = [candidate?.data?.interactionId, taskInteraction?.interactionId, taskInteraction?.mainInteractionId, taskInteraction?.parentInteractionId, taskInteraction?.callProcessingDetails?.parentInteractionId];
+      return candidateInteractionIds.some(interactionId => Boolean(interactionId) && payloadInteractionIds.has(interactionId));
+    }))];
+    if (candidates.length === 1) {
+      return candidates[0];
+    }
+    if (candidates.length > 1) {
+      _loggerProxy.default.warn('Unable to correlate task event to a unique main interaction task', {
+        module: _constants.TASK_MANAGER_FILE,
+        method: 'findUniqueTaskByRelatedInteraction',
+        interactionId: payload.interaction?.mainInteractionId || payload.interaction?.parentInteractionId || payload.interaction?.callProcessingDetails?.parentInteractionId || payload.interactionId
+      });
+    }
+    return undefined;
+  }
+
   /**
    * Handle task lifecycle events and determine required actions
    *
@@ -638,7 +736,7 @@ class TaskManager extends _events.default {
         wrapUpRequired: false,
         isConferenceInProgress: false,
         isAutoAnswering: false
-      }, this.configFlags, this.wrapupData, this.agentId);
+      }, this.configFlags, this.wrapupData, this.agentId, this.answerCallOnWebexService);
       this.setupTaskListeners(task);
       this.taskCollection[payload.interactionId] = task;
     } else {
@@ -664,7 +762,7 @@ class TaskManager extends _events.default {
       isConsulted: isConsultedTask,
       isAutoAnswering: shouldAutoAnswer
     };
-    const task = _TaskFactory.default.createTask(this.contact, this.webCallingService, taskData, this.configFlags, this.wrapupData, this.agentId);
+    const task = _TaskFactory.default.createTask(this.contact, this.webCallingService, taskData, this.configFlags, this.wrapupData, this.agentId, this.answerCallOnWebexService);
     this.setupTaskListeners(task);
     this.taskCollection[payload.interactionId] = task;
     return {
@@ -693,7 +791,7 @@ class TaskManager extends _events.default {
         isConferenceInProgress: (0, _TaskUtils.getIsConferenceInProgress)(payload),
         isAutoAnswering: shouldAutoAnswer
       };
-      task = _TaskFactory.default.createTask(this.contact, this.webCallingService, taskData, this.configFlags, this.wrapupData, this.agentId);
+      task = _TaskFactory.default.createTask(this.contact, this.webCallingService, taskData, this.configFlags, this.wrapupData, this.agentId, this.answerCallOnWebexService);
       this.setupTaskListeners(task);
       this.taskCollection[payload.interactionId] = task;
     }
@@ -713,6 +811,14 @@ class TaskManager extends _events.default {
       destinationType: taskData.destinationType ?? snapshot?.context?.consultDestinationType ?? null
     } : taskData;
     task.updateTaskData(updateTaskData);
+
+    // A main-interaction lifecycle event can re-key a child consult task. Remove
+    // any aliases first so consumers never observe duplicate task entries.
+    Object.entries(this.taskCollection).forEach(([taskId, candidate]) => {
+      if (candidate === task && taskId !== taskData.interactionId) {
+        delete this.taskCollection[taskId];
+      }
+    });
     this.taskCollection[taskData.interactionId] = task;
     return task;
   }
@@ -753,8 +859,8 @@ class TaskManager extends _events.default {
     task.on(_types.TASK_EVENTS.TASK_CLEANUP, (t, options) => {
       this.handleTaskCleanup(t);
       if (options?.removeFromCollection) {
-        const interactionId = t?.data?.interactionId;
-        if (interactionId && this.taskCollection[interactionId]) {
+        const taskIsStillCollected = Object.values(this.taskCollection).some(candidate => candidate === t);
+        if (taskIsStillCollected) {
           this.removeTaskFromCollection(t);
         }
       }
@@ -765,7 +871,11 @@ class TaskManager extends _events.default {
       task.cancelAutoWrapupTimer();
     }
     if (task?.data?.interactionId) {
-      delete this.taskCollection[task.data.interactionId];
+      Object.entries(this.taskCollection).forEach(([taskId, candidate]) => {
+        if (candidate === task) {
+          delete this.taskCollection[taskId];
+        }
+      });
       _loggerProxy.default.info(`Task removed from collection`, {
         module: _constants.TASK_MANAGER_FILE,
         method: _constants2.METHODS.REMOVE_TASK_FROM_COLLECTION,
@@ -810,7 +920,7 @@ class TaskManager extends _events.default {
         isConferenceInProgress: (0, _TaskUtils.getIsConferenceInProgress)(payload),
         isConsulted: false
       };
-      task = _TaskFactory.default.createTask(this.contact, this.webCallingService, taskData, this.configFlags, this.wrapupData, this.agentId);
+      task = _TaskFactory.default.createTask(this.contact, this.webCallingService, taskData, this.configFlags, this.wrapupData, this.agentId, this.answerCallOnWebexService);
       this.taskCollection[payload.interactionId] = task;
 
       // Transition the new task out of IDLE immediately so UI controls are
@@ -884,6 +994,52 @@ class TaskManager extends _events.default {
       ...this.taskCollection
     };
   }
+
+  /**
+   * Propagate runtime enableWxBetterTogether changes to config flags and active tasks.
+   */
+  applyEnableWxBetterTogether(enabled) {
+    if (this.configFlags) {
+      this.configFlags = {
+        ...this.configFlags,
+        enableWxBetterTogether: enabled
+      };
+    }
+    Object.values(this.taskCollection).forEach(task => {
+      task.setEnableWxBetterTogether(enabled);
+      if (enabled) {
+        TaskManager.syncWxAppMuteFromCallDetailsForTask(task);
+      }
+    });
+  }
+
+  /**
+   * Propagate wxApp mute state from Mercury sync to active voice tasks.
+   */
+  applyWxAppMuteStateFromSync(callId, muted) {
+    Object.values(this.taskCollection).forEach(task => {
+      task.applyWxAppMuteStateFromSync(callId, muted);
+    });
+  }
+
+  /**
+   * Re-seeds wxApp mute state from GET telephony/calls/{callId} for one task.
+   */
+  static syncWxAppMuteFromCallDetailsForTask(task) {
+    const sync = task.syncWxAppMuteFromCallDetails?.bind(task);
+    if (typeof sync === 'function') {
+      sync().catch(() => undefined);
+    }
+  }
+
+  /**
+   * Re-seeds wxApp mute for all engaged voice tasks (reload / runtime enable backfill).
+   */
+  syncWxAppMuteFromCallDetailsForAllTasks() {
+    Object.values(this.taskCollection).forEach(task => {
+      TaskManager.syncWxAppMuteFromCallDetailsForTask(task);
+    });
+  }
   static getTaskManager(apiAIAssistant, contact, webCallingService, webSocketManager, rtdWebSocketManager) {
     if (!TaskManager.taskManager) {
       TaskManager.taskManager = new TaskManager(apiAIAssistant, contact, webCallingService, webSocketManager, rtdWebSocketManager);