@webex/contact-center 3.12.0-task-refactor.4 → 3.12.0-task-refactor.6

package/package.json

@@ -83,5 +83,5 @@
     "typedoc": "^0.25.0",
     "typescript": "5.4.5"
   },
-  "version": "3.12.0-task-refactor.4"
+  "version": "3.12.0-task-refactor.6"
 }

package/src/services/task/TaskManager.ts

@@ -291,7 +291,7 @@ export default class TaskManager extends EventEmitter {
         return {type: TaskEvent.RONA, taskData: payload, reason: payload.reason};
 
       case CC_EVENTS.AGENT_OUTBOUND_FAILED:
-        return {type: TaskEvent.OUTBOUND_FAILED, reason: payload.reason};
+        return {type: TaskEvent.OUTBOUND_FAILED, taskData: payload, reason: payload.reason};
 
       case CC_EVENTS.CONTACT_RECORDING_STARTED:
         return {type: TaskEvent.RECORDING_STARTED, taskData: payload};

package/src/services/task/TaskUtils.ts

@@ -13,13 +13,14 @@ import {TaskContext} from './state-machine/types';
  * @returns true if customer is in the call
  */
 export const getIsCustomerInCall = (interaction: Interaction, interactionId: string): boolean => {
-  const mainCallMedia = interaction.media[interactionId];
-  if (!mainCallMedia?.participants) {
+  const mainCallMedia = interaction.media?.[interactionId];
+  const participants = interaction.participants;
+  if (!mainCallMedia?.participants || !participants) {
     return false;
   }
 
   return mainCallMedia.participants.some((participantId: string) => {
-    const participant = interaction.participants[participantId];
+    const participant = participants[participantId];
 
     return participant?.pType === PARTICIPANT_TYPE.CUSTOMER && !participant.hasLeft;
   });
@@ -37,14 +38,15 @@ export const getConferenceParticipantsCount = (
   interaction: Interaction,
   interactionId: string
 ): number => {
-  const mainCallMedia = interaction.media[interactionId];
-  if (!mainCallMedia?.participants) {
+  const mainCallMedia = interaction.media?.[interactionId];
+  const participants = interaction.participants;
+  if (!mainCallMedia?.participants || !participants) {
     return 0;
   }
 
   let count = 0;
   for (const participantId of mainCallMedia.participants) {
-    const participant = interaction.participants[participantId];
+    const participant = participants[participantId];
     if (
       participant &&
       participant.pType !== PARTICIPANT_TYPE.CUSTOMER &&

package/src/services/task/state-machine/TaskStateMachine.ts

@@ -123,16 +123,22 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
             actions: ['initializeTask', 'emitTaskIncoming'],
           },
 
+          // AgentOutboundFailed can arrive before TASK_INCOMING due to race conditions
+          [TaskEvent.OUTBOUND_FAILED]: {
+            target: TaskState.TERMINATED,
+            actions: ['updateTaskData', 'markEnded', 'emitTaskOutdialFailed', 'emitTaskEnd'],
+          },
+
           // EP-DN split-leg ordering can deliver AgentConsulting before HYDRATE/TASK_INCOMING.
           // Do not drop it in IDLE; bootstrap to CONSULTING using event taskData.
           [TaskEvent.CONSULTING_ACTIVE]: {
             target: TaskState.CONSULTING,
             actions: [
-              'updateTaskData',
               'setConsultInitiator',
               'setConsultDestination',
               'setConsultFromConference',
               'setConsultAgentJoined',
+              'updateTaskData',
               'emitTaskConsultAccepted',
               'emitTaskConsulting',
             ],
@@ -190,7 +196,7 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
             },
             {
               target: TaskState.TERMINATED,
-              actions: ['updateTaskData', 'markEnded', 'emitTaskOutdialFailed', 'emitTaskReject'],
+              actions: ['updateTaskData', 'markEnded', 'emitTaskOutdialFailed', 'emitTaskEnd'],
             },
           ],
           // AgentConsulting comes for received after the initial consult is accepted
@@ -198,8 +204,9 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
             {
               target: TaskState.CONSULTING,
               actions: [
-                'updateTaskData',
                 'setConsultAgentJoined',
+                'setConsultDestination',
+                'updateTaskData',
                 'emitTaskConsultAccepted',
                 'emitTaskConsulting',
               ],
@@ -226,15 +233,25 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
 
       [TaskState.CONNECTED]: {
         on: {
+          // AgentConsultConferenced / ParticipantJoinedConference can arrive while connected.
+          [TaskEvent.CONFERENCE_START]: {
+            target: TaskState.CONFERENCING,
+            actions: [
+              'updateTaskData',
+              'syncTaskDataFromEvent',
+              'clearConsultState',
+              'emitTaskConferenceStarted',
+            ],
+          },
           // AgentConsulting may arrive while machine is CONNECTED (EP-DN/event ordering).
           // Derive consultInitiator from payload so controls are set correctly.
           [TaskEvent.CONSULTING_ACTIVE]: {
             target: TaskState.CONSULTING,
             actions: [
-              'updateTaskData',
               'setConsultInitiator',
               'setConsultDestination',
               'setConsultAgentJoined',
+              'updateTaskData',
               'emitTaskConsultAccepted',
               'emitTaskConsulting',
             ],
@@ -323,6 +340,22 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
 
       [TaskState.HELD]: {
         on: {
+          // Conference can be merged while this agent is in held state after refresh/recovery.
+          [TaskEvent.CONFERENCE_START]: {
+            target: TaskState.CONFERENCING,
+            actions: [
+              'updateTaskData',
+              'syncTaskDataFromEvent',
+              'clearConsultState',
+              'emitTaskConferenceStarted',
+            ],
+          },
+          [TaskEvent.PAUSE_RECORDING]: {
+            actions: ['updateTaskData', 'setRecordingState', 'emitTaskRecordingPaused'],
+          },
+          [TaskEvent.RESUME_RECORDING]: {
+            actions: ['updateTaskData', 'setRecordingState', 'emitTaskRecordingResumed'],
+          },
           // Click of the unhold button
           [TaskEvent.UNHOLD_INITIATED]: {
             target: TaskState.RESUME_INITIATING,
@@ -442,9 +475,9 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
           // AgentConsulting updates consulted agent arrival
           [TaskEvent.CONSULTING_ACTIVE]: {
             actions: [
-              'updateTaskData',
               'setConsultAgentJoined',
               'setConsultDestination',
+              'updateTaskData',
               'emitTaskConsulting',
             ],
           },
@@ -452,14 +485,33 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
           // AgentConsultEnded
           [TaskEvent.CONSULT_END]: [
             {
-              // Initiator returning to conference (flag set OR backend still shows conference)
+              // Initiator returning to conference only while conference is still active.
               guard: ({context, event}) =>
                 context.consultInitiator === true &&
-                (context.consultFromConference === true ||
-                  guards.conferenceInProgressFromEvent({context, event})),
+                guards.conferenceInProgressFromEvent({context, event}),
               target: TaskState.CONFERENCING,
               actions: ['updateTaskData', 'clearConsultState', 'emitTaskConsultEnd'],
             },
+            {
+              // Conference consult ended after conference downgrade while main leg is held.
+              guard: ({context, event}) =>
+                context.consultInitiator === true &&
+                context.consultFromConference === true &&
+                !guards.conferenceInProgressFromEvent({context, event}) &&
+                guards.isConferenceHoldParticipantFromEvent({context, event}),
+              target: TaskState.HELD,
+              actions: ['updateTaskData', 'clearConsultState', 'emitTaskConsultEnd'],
+            },
+            {
+              // Conference consult ended after conference downgrade while main leg is connected.
+              guard: ({context, event}) =>
+                context.consultInitiator === true &&
+                context.consultFromConference === true &&
+                !guards.conferenceInProgressFromEvent({context, event}) &&
+                !guards.isConferenceHoldParticipantFromEvent({context, event}),
+              target: TaskState.CONNECTED,
+              actions: ['updateTaskData', 'clearConsultState', 'emitTaskConsultEnd'],
+            },
             {
               // Initiator already switched back to the main/customer leg
               guard: ({context}) =>
@@ -468,13 +520,18 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
               actions: ['updateTaskData', 'clearConsultState', 'emitTaskConsultEnd'],
             },
             {
-              // Customer left during consult → WRAPPING_UP
+              // Interaction terminated during consult (customer left) → WRAPPING_UP
               guard: ({context, event}) => {
+                // if (context.consultInitiator !== true) return false;
+                // const taskData = getTaskDataFromEvent(event);
                 const taskData = getTaskDataFromEvent(event);
                 const cpd = taskData?.interaction?.callProcessingDetails;
                 if (cpd?.hasCustomerLeft !== 'true') return false;
 
-                return shouldWrapUpForThisAgent(context, taskData);
+                return (
+                  taskData?.interaction?.isTerminated === true &&
+                  shouldWrapUpForThisAgent(context, taskData)
+                );
               },
               target: TaskState.WRAPPING_UP,
               actions: [
@@ -692,12 +749,40 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
             },
           ],
 
-          [TaskEvent.HOLD_SUCCESS]: {
-            actions: ['updateTaskData', 'setHoldState', 'emitTaskHold'],
-          },
-          [TaskEvent.UNHOLD_SUCCESS]: {
-            actions: ['updateTaskData', 'syncTaskDataFromEvent', 'setHoldState', 'emitTaskResume'],
-          },
+          [TaskEvent.HOLD_SUCCESS]: [
+            {
+              // Conference already downgraded (no other agents) and backend hold arrives.
+              // Move to HELD so the UI renders resume action.
+              guard: guards.shouldDowngradeConferenceToConnected,
+              target: TaskState.HELD,
+              actions: ['updateTaskData', 'setHoldState', 'emitTaskHold'],
+            },
+            {
+              actions: ['updateTaskData', 'setHoldState', 'emitTaskHold'],
+            },
+          ],
+          [TaskEvent.UNHOLD_SUCCESS]: [
+            {
+              // Conference already downgraded (no other agents) and backend unhold arrives.
+              // Move to CONNECTED so hold action is available again.
+              guard: guards.shouldDowngradeConferenceToConnected,
+              target: TaskState.CONNECTED,
+              actions: [
+                'updateTaskData',
+                'syncTaskDataFromEvent',
+                'setHoldState',
+                'emitTaskResume',
+              ],
+            },
+            {
+              actions: [
+                'updateTaskData',
+                'syncTaskDataFromEvent',
+                'setHoldState',
+                'emitTaskResume',
+              ],
+            },
+          ],
 
           // Start a new consult from within an active conference
           [TaskEvent.CONSULT]: {

package/src/services/task/state-machine/actions.ts

@@ -11,9 +11,16 @@ import {
   TaskActionArgs,
   RecordingStateUpdate,
 } from './types';
-import {TaskEvent, TaskState, INTERACTION_STATE} from './constants';
+import {
+  TaskEvent,
+  TaskState,
+  INTERACTION_STATE,
+  CONSULT_STATE,
+  MEDIA_TYPE_CONSULT,
+} from './constants';
 import {DestinationType, TaskData} from '../types';
 import {computeUIControls, getDefaultUIControls} from './uiControlsComputer';
+import {getIsConferenceInProgress} from '../TaskUtils';
 import {hasActiveConsultInPostCall} from './guards';
 
 const determineConsultInitiator = (
@@ -74,6 +81,113 @@ const deriveRecordingState = (taskData?: TaskData | null): RecordingStateUpdate
   return update;
 };
 
+const isActiveConsultState = (taskData: TaskData | undefined, selfAgentId?: string): boolean => {
+  if (taskData?.interaction?.state === INTERACTION_STATE.CONSULTING) return true;
+  if (selfAgentId) {
+    const selfParticipant = taskData?.interaction?.participants?.[selfAgentId] as any;
+    const hasConsultMedia = Object.values(taskData?.interaction?.media ?? {}).some(
+      (media: any) => media?.mType === MEDIA_TYPE_CONSULT
+    );
+    const isPendingOrActiveSelfConsult =
+      selfParticipant?.consultState === CONSULT_STATE.CONSULTING ||
+      selfParticipant?.consultState === 'consultInitiated';
+    if (isPendingOrActiveSelfConsult && hasConsultMedia && taskData?.isConsulted === false) {
+      return true;
+    }
+  }
+  if (taskData?.interaction?.state === INTERACTION_STATE.POST_CALL && selfAgentId) {
+    const selfParticipant = taskData.interaction?.participants?.[selfAgentId] as any;
+    const hasConsultMedia = Object.values(taskData.interaction?.media ?? {}).some(
+      (media: any) => media?.mType === MEDIA_TYPE_CONSULT
+    );
+    if (selfParticipant?.consultState === CONSULT_STATE.CONSULTING && hasConsultMedia) return true;
+  }
+
+  return false;
+};
+
+const isSelfConsultingOrPending = (
+  taskData: TaskData | undefined,
+  selfAgentId?: string
+): boolean => {
+  if (!taskData || !selfAgentId) return false;
+  const selfParticipant = taskData?.interaction?.participants?.[selfAgentId] as any;
+
+  return (
+    selfParticipant?.consultState === CONSULT_STATE.CONSULTING ||
+    selfParticipant?.consultState === 'consultInitiated'
+  );
+};
+
+const hasJoinedConsultDestination = (taskData: TaskData | undefined): boolean => {
+  if (!taskData?.interaction) return false;
+  const participants = taskData.interaction.participants as any;
+  const cpd = taskData.interaction.callProcessingDetails as any;
+  const backendSaysJoined = cpd?.consultDestinationAgentJoined === 'true';
+  if (backendSaysJoined) return true;
+  if (!participants) return false;
+
+  return Object.values(participants).some((p: any) => {
+    if (!p || p.isConsulted !== true || p.hasLeft) return false;
+
+    return p.hasJoined === true || p.consultState === CONSULT_STATE.CONSULTING;
+  });
+};
+
+const deriveConsultCallHeldFromTaskData = (taskData: TaskData | undefined): boolean | undefined => {
+  if (!taskData?.interaction) return undefined;
+
+  const eventType = taskData.type;
+  if (eventType === 'AgentContactHeld') return true;
+  if (eventType === 'AgentContactUnheld') return false;
+
+  const consultMediaId = taskData.consultMediaResourceId;
+
+  const consultMedia: any = consultMediaId
+    ? taskData.interaction.media?.[consultMediaId]
+    : Object.values(taskData.interaction.media ?? {}).find(
+        (m: any) => m?.mType === MEDIA_TYPE_CONSULT
+      );
+
+  if (!consultMedia) return undefined;
+
+  return Boolean(consultMedia.isHold);
+};
+
+const getTaskStateForUiControls = (
+  taskData: TaskData | undefined,
+  selfAgentId: string | undefined
+): TaskState => {
+  if (!taskData?.interaction) {
+    return TaskState.IDLE;
+  }
+
+  if (taskData.interaction.isTerminated === true) {
+    return TaskState.WRAPPING_UP;
+  }
+
+  if (isActiveConsultState(taskData, selfAgentId)) {
+    return TaskState.CONSULTING;
+  }
+
+  if (
+    taskData.interaction.state === INTERACTION_STATE.CONFERENCE ||
+    getIsConferenceInProgress(taskData)
+  ) {
+    return TaskState.CONFERENCING;
+  }
+
+  const mainMediaId = taskData.interaction.mainInteractionId || taskData.interactionId;
+  const isMainHeld = Boolean(
+    mainMediaId && taskData.interaction.media?.[mainMediaId]?.isHold === true
+  );
+  if (taskData.interaction.state === 'hold' || isMainHeld) {
+    return TaskState.HELD;
+  }
+
+  return TaskState.CONNECTED;
+};
+
 const deriveTaskDataUpdates = (context: TaskContext, taskData: TaskData | undefined) =>
   taskData
     ? (() => {
@@ -84,8 +198,14 @@ const deriveTaskDataUpdates = (context: TaskContext, taskData: TaskData | undefi
 
         const selfAgentId = context.uiControlConfig.agentId ?? taskData?.agentId;
         const consultingActive =
-          taskData?.interaction?.state === INTERACTION_STATE.CONSULTING ||
+          isActiveConsultState(taskData, selfAgentId) ||
           hasActiveConsultInPostCall(taskData, selfAgentId);
+        const conferenceFromPayload =
+          taskData?.interaction?.state === INTERACTION_STATE.CONFERENCE ||
+          getIsConferenceInProgress(taskData);
+        const selfConsultingOrPending = isSelfConsultingOrPending(taskData, selfAgentId);
+        const inferredConsultingInitiator =
+          selfConsultingOrPending && taskData?.isConsulted === false;
 
         if (taskData.destAgentId) {
           const isEpDnWithStoredId =
@@ -102,24 +222,26 @@ const deriveTaskDataUpdates = (context: TaskContext, taskData: TaskData | undefi
           const consultInitiator = determineConsultInitiator(taskData, selfAgentId);
           if (consultInitiator !== undefined) {
             updates.consultInitiator = consultInitiator;
-          } else if (consultingActive && taskData.isConsulted === false) {
+          } else if (
+            inferredConsultingInitiator ||
+            (consultingActive && taskData.isConsulted === false)
+          ) {
             updates.consultInitiator = true;
           }
         }
 
+        const effectiveConsultInitiator = updates.consultInitiator ?? context.consultInitiator;
+        if (
+          effectiveConsultInitiator &&
+          conferenceFromPayload &&
+          (consultingActive || selfConsultingOrPending || Boolean(taskData?.consultMediaResourceId))
+        ) {
+          updates.consultFromConference = true;
+        }
+
         if (consultingActive && taskData.interaction) {
-          if (!context.consultDestinationAgentJoined) {
-            const hasJoinedConsultee = Boolean(
-              taskData.interaction.participants &&
-                Object.values(taskData.interaction.participants).some(
-                  (p: any) => p?.isConsulted === true && !p?.hasLeft
-                )
-            );
-            const cpd = taskData.interaction?.callProcessingDetails;
-            const backendSaysJoined = cpd?.consultDestinationAgentJoined === 'true';
-            if (hasJoinedConsultee || backendSaysJoined)
-              updates.consultDestinationAgentJoined = true;
-          }
+          const joinedConsultee = hasJoinedConsultDestination(taskData);
+          if (joinedConsultee) updates.consultDestinationAgentJoined = true;
 
           if (!context.consultDestinationType && !updates.consultDestinationType) {
             const hasEpDnParticipant = Boolean(
@@ -131,20 +253,22 @@ const deriveTaskDataUpdates = (context: TaskContext, taskData: TaskData | undefi
             if (hasEpDnParticipant) updates.consultDestinationType = 'entryPoint' as any;
           }
 
-          const effectiveConsultInitiator = updates.consultInitiator ?? context.consultInitiator;
           if (effectiveConsultInitiator) {
-            const consultMediaId = taskData.consultMediaResourceId;
-            const consultMedia: any = consultMediaId
-              ? taskData.interaction.media?.[consultMediaId]
-              : Object.values(taskData.interaction.media ?? {}).find(
-                  (m: any) => m?.mType === 'consult'
-                );
-            if (consultMedia) {
-              updates.consultCallHeld = Boolean(consultMedia.isHold);
+            const consultCallHeld = deriveConsultCallHeldFromTaskData(taskData);
+            if (consultCallHeld !== undefined) {
+              updates.consultCallHeld = consultCallHeld;
             }
           }
         }
 
+        const nextContext = {
+          ...context,
+          ...updates,
+        } as TaskContext;
+        const inferredState = getTaskStateForUiControls(taskData, selfAgentId);
+
+        updates.uiControls = computeUIControls(inferredState, nextContext, taskData);
+
         return updates;
       })()
     : {};

package/src/services/task/state-machine/guards.ts

@@ -120,6 +120,20 @@ export const guards = {
 
     if (taskData?.interaction?.state === INTERACTION_STATE.CONSULTING) return true;
 
+    // Hydrate can report interaction as conference/hold while this agent is actively consulting.
+    // Detect consult by participant consultState + consult media, independent of top-level state.
+    const selfAgentId = getSelfAgentId(context, taskData);
+    const selfParticipant = selfAgentId ? taskData?.interaction?.participants?.[selfAgentId] : null;
+    const hasConsultMedia = Object.values(taskData?.interaction?.media ?? {}).some(
+      (media: any) => media?.mType === MEDIA_TYPE_CONSULT
+    );
+    const selfActiveConsult = selfParticipant?.consultState === CONSULT_STATE.CONSULTING;
+    const selfPendingConsultInitiated =
+      selfParticipant?.consultState === 'consultInitiated' && taskData?.isConsulted === false;
+    if ((selfActiveConsult || selfPendingConsultInitiated) && hasConsultMedia) {
+      return true;
+    }
+
     // EP_DN consulted agent: backend reports state as 'connected' but CPD indicates consult
     const cpd = taskData?.interaction?.callProcessingDetails;
     if (
@@ -135,6 +149,24 @@ export const guards = {
       return true;
     }
 
+    // Customer left during consult: interaction state is "post_call" but consult
+    // between agents is still active. Detect via agent's consultState + consult media.
+    if (taskData?.interaction?.state === INTERACTION_STATE.POST_CALL) {
+      const postCallSelfAgentId = getSelfAgentId(context, taskData);
+      const postCallSelfParticipant = postCallSelfAgentId
+        ? taskData?.interaction?.participants?.[postCallSelfAgentId]
+        : null;
+      const hasPostCallConsultMedia = Object.values(taskData?.interaction?.media ?? {}).some(
+        (media: any) => media?.mType === MEDIA_TYPE_CONSULT
+      );
+      if (
+        postCallSelfParticipant?.consultState === CONSULT_STATE.CONSULTING &&
+        hasPostCallConsultMedia
+      ) {
+        return true;
+      }
+    }
+
     return false;
   },
 
@@ -183,6 +215,20 @@ export const guards = {
     return getIsConferenceInProgress(taskData);
   },
 
+  /**
+   * Conference hold signal for conference-downgraded consult-end transitions.
+   * Backend can report this as boolean or string.
+   */
+  isConferenceHoldParticipantFromEvent: ({context, event}: GuardParams): boolean => {
+    const taskData = getTaskDataFromEvent(event) ?? context.taskData;
+    const callProcessingDetails = taskData?.interaction?.callProcessingDetails as
+      | {conferenceHoldParticipant?: boolean | string}
+      | undefined;
+    const conferenceHoldParticipant = callProcessingDetails?.conferenceHoldParticipant;
+
+    return conferenceHoldParticipant === true || conferenceHoldParticipant === 'true';
+  },
+
   /**
    * Conference downgrade check specifically for transitioning back to CONNECTED.
    *