@webex/contact-center 3.12.0-task-refactor.7 → 3.12.0-task-refactor.9

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

@@ -78,6 +78,15 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
       [TaskEvent.HYDRATE]: {
         actions: ['updateTaskData', 'emitTaskHydrate'],
       },
+      // AgentConsultCreated from Stable Prod while already HELD/CONNECTED (external consult).
+      // Child states do not handle CONSULT_CREATED; wire here so updateTaskData + setConsultInitiator run.
+      [TaskEvent.CONSULT_CREATED]: {
+        actions: ['updateTaskData', 'setConsultInitiator'],
+      },
+      // AgentConsultFailed (RONA) while HELD/CONNECTED without passing through CONSULT_INITIATING.
+      [TaskEvent.CONSULT_FAILED]: {
+        actions: ['updateTaskData', 'handleConsultFailed'],
+      },
     },
     states: {
       [TaskState.IDLE]: {
@@ -290,6 +299,24 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
           [TaskEvent.TRANSFER_FAILED]: {
             actions: ['updateTaskData'],
           },
+          // AgentConsultEnded from Stable Prod while on connected leg (external end consult).
+          [TaskEvent.CONSULT_END]: [
+            {
+              guard: ({context, event}) => {
+                if (context.consultInitiator !== true) return false;
+                const taskData = getTaskDataFromEvent(event);
+                const mainId = taskData?.interaction?.mainInteractionId || taskData?.interactionId;
+
+                return Boolean(mainId && taskData?.interaction?.media?.[mainId]?.isHold === true);
+              },
+              target: TaskState.HELD,
+              actions: ['updateTaskData', 'clearConsultState', 'emitTaskConsultEnd'],
+            },
+            {
+              guard: ({context}) => context.consultInitiator === true,
+              actions: ['updateTaskData', 'clearConsultState', 'emitTaskConsultEnd'],
+            },
+          ],
           // AgentContactEnded Event
           [TaskEvent.CONTACT_ENDED]: [
             {
@@ -370,6 +397,18 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
             target: TaskState.CONSULT_INITIATING,
             actions: ['setConsultInitiator', 'setConsultDestination'],
           },
+          // AgentConsulting while main leg is held (Task Refactor / Stable Prod consult accept).
+          [TaskEvent.CONSULTING_ACTIVE]: {
+            target: TaskState.CONSULTING,
+            actions: [
+              'setConsultInitiator',
+              'setConsultDestination',
+              'setConsultAgentJoined',
+              'updateTaskData',
+              'emitTaskConsultAccepted',
+              'emitTaskConsulting',
+            ],
+          },
           // TODO: This may not be a valid transition, need to be removed
           // AgentConsultTransferred / AgentVTeamTransferred / AgentBlindTransferred
           [TaskEvent.TRANSFER_SUCCESS]: [
@@ -402,6 +441,10 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
               actions: ['updateTaskData', 'markEnded', 'emitTaskEnd'],
             },
           ],
+          // AgentConsultEnded from Stable Prod while main leg is held (external end consult).
+          [TaskEvent.CONSULT_END]: {
+            actions: ['updateTaskData', 'clearConsultState', 'emitTaskConsultEnd'],
+          },
           // TODO: This may not be a valid transition, this needs to be checked as well
           [TaskEvent.TASK_WRAPUP]: {
             target: TaskState.WRAPPING_UP,
@@ -437,6 +480,18 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
             target: TaskState.CONSULTING,
             actions: ['updateTaskData', 'setConsultInitiator'],
           },
+          // AgentConsulting (Task Refactor: AgentConsulting event, not CONSULT_SUCCESS)
+          [TaskEvent.CONSULTING_ACTIVE]: {
+            target: TaskState.CONSULTING,
+            actions: [
+              'setConsultInitiator',
+              'setConsultDestination',
+              'setConsultAgentJoined',
+              'updateTaskData',
+              'emitTaskConsultAccepted',
+              'emitTaskConsulting',
+            ],
+          },
           // AgentConsultFailed, API Failures, AgentCtqFailed
           [TaskEvent.CONSULT_FAILED]: [
             {
@@ -467,6 +522,18 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
               actions: ['updateTaskData', 'clearConsultState'],
             },
           ],
+          // AgentConsultEnded from Stable Prod during consult initiation (external end consult).
+          [TaskEvent.CONSULT_END]: [
+            {
+              guard: guards.isPrimaryMediaOnHold,
+              target: TaskState.HELD,
+              actions: ['updateTaskData', 'clearConsultState', 'emitTaskConsultEnd'],
+            },
+            {
+              target: TaskState.CONNECTED,
+              actions: ['updateTaskData', 'clearConsultState', 'emitTaskConsultEnd'],
+            },
+          ],
         },
       },
 
@@ -482,6 +549,29 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
             ],
           },
 
+          // AgentConsultFailed (RONA / consultee declined) while the initiator is already in
+          // CONSULTING (AgentConsulting arrived during ringing). Mirror CONSULT_INITIATING so the
+          // initiator returns to their own leg (HELD when main is on hold, else CONNECTED) instead
+          // of staying in CONSULTING. Without this, handleConsultFailed clears consultInitiator but
+          // the machine stays in CONSULTING, so the trailing AgentConsultEnded falls through the
+          // CONSULT_END "consulted agent" branch to TERMINATED and wrongly clears the task.
+          [TaskEvent.CONSULT_FAILED]: [
+            {
+              guard: ({context}) => context.consultFromConference === true,
+              target: TaskState.CONFERENCING,
+              actions: ['updateTaskData', 'handleConsultFailed'],
+            },
+            {
+              guard: guards.isPrimaryMediaOnHold,
+              target: TaskState.HELD,
+              actions: ['updateTaskData', 'handleConsultFailed'],
+            },
+            {
+              target: TaskState.CONNECTED,
+              actions: ['updateTaskData', 'handleConsultFailed'],
+            },
+          ],
+
           // AgentConsultEnded
           [TaskEvent.CONSULT_END]: [
             {
@@ -790,6 +880,20 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
             actions: ['setConsultInitiator', 'setConsultDestination', 'setConsultFromConference'],
           },
 
+          // AgentConsulting while still in conference (EP-DN/external ordering).
+          [TaskEvent.CONSULTING_ACTIVE]: {
+            target: TaskState.CONSULTING,
+            actions: [
+              'setConsultInitiator',
+              'setConsultDestination',
+              'setConsultFromConference',
+              'setConsultAgentJoined',
+              'updateTaskData',
+              'emitTaskConsultAccepted',
+              'emitTaskConsulting',
+            ],
+          },
+
           // Participant leaves - handle conference downgrade scenarios
           [TaskEvent.PARTICIPANT_LEAVE]: [
             {

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

@@ -88,10 +88,20 @@ const isActiveConsultState = (taskData: TaskData | undefined, selfAgentId?: stri
     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) {
+    // Pending consult before destination joins stays HELD, not CONSULTING.
+    if (
+      selfParticipant?.consultState === 'consultInitiated' &&
+      !hasJoinedConsultDestination(taskData, selfAgentId) &&
+      hasConsultMedia &&
+      taskData?.isConsulted === false
+    ) {
+      return false;
+    }
+    if (
+      selfParticipant?.consultState === CONSULT_STATE.CONSULTING &&
+      hasConsultMedia &&
+      taskData?.isConsulted === false
+    ) {
       return true;
     }
   }
@@ -119,7 +129,42 @@ const isSelfConsultingOrPending = (
   );
 };
 
-const hasJoinedConsultDestination = (taskData: TaskData | undefined): boolean => {
+const isDnOnConsultMedia = (taskData: TaskData | undefined, selfAgentId?: string): boolean => {
+  if (!taskData?.interaction?.participants) return false;
+
+  const consultMedia: any = taskData.consultMediaResourceId
+    ? taskData.interaction.media?.[taskData.consultMediaResourceId]
+    : Object.values(taskData.interaction.media ?? {}).find(
+        (m: any) => m?.mType === MEDIA_TYPE_CONSULT
+      );
+  const consultParticipantIds = new Set(consultMedia?.participants ?? []);
+  if (consultParticipantIds.size === 0) return false;
+
+  return Object.values(taskData.interaction.participants).some((p: any) => {
+    if (!p || p.hasLeft || p.id === selfAgentId) return false;
+    if (!consultParticipantIds.has(p.id)) return false;
+    const pType = String(p.pType ?? '').toUpperCase();
+
+    return pType === 'DN' || pType === 'EP-DN' || pType === 'EP_DN';
+  });
+};
+
+const mapConsultDestinationType = (
+  destinationType: string | undefined
+): DestinationType | undefined => {
+  if (!destinationType) return undefined;
+  const normalized = String(destinationType).toUpperCase();
+  if (normalized === 'DN' || normalized === 'EP-DN' || normalized === 'EP_DN') {
+    return 'entryPoint' as DestinationType;
+  }
+
+  return destinationType as DestinationType;
+};
+
+const hasJoinedConsultDestination = (
+  taskData: TaskData | undefined,
+  selfAgentId?: string
+): boolean => {
   if (!taskData?.interaction) return false;
   const participants = taskData.interaction.participants as any;
   const cpd = taskData.interaction.callProcessingDetails as any;
@@ -127,6 +172,20 @@ const hasJoinedConsultDestination = (taskData: TaskData | undefined): boolean =>
   if (backendSaysJoined) return true;
   if (!participants) return false;
 
+  const effectiveSelfAgentId = selfAgentId ?? taskData.agentId;
+  const selfParticipant = effectiveSelfAgentId
+    ? (participants[effectiveSelfAgentId] as {consultState?: string} | undefined)
+    : undefined;
+
+  if (
+    taskData.type === 'AgentConsulting' &&
+    selfParticipant?.consultState === CONSULT_STATE.CONSULTING &&
+    taskData.isConsulted === false &&
+    isDnOnConsultMedia(taskData, effectiveSelfAgentId)
+  ) {
+    return true;
+  }
+
   return Object.values(participants).some((p: any) => {
     if (!p || p.isConsulted !== true || p.hasLeft) return false;
 
@@ -154,7 +213,7 @@ const deriveConsultCallHeldFromTaskData = (taskData: TaskData | undefined): bool
   return Boolean(consultMedia.isHold);
 };
 
-const getTaskStateForUiControls = (
+export const getTaskStateForUiControls = (
   taskData: TaskData | undefined,
   selfAgentId: string | undefined
 ): TaskState => {
@@ -214,11 +273,25 @@ const deriveTaskDataUpdates = (context: TaskContext, taskData: TaskData | undefi
             updates.consultDestinationAgentId = taskData.destAgentId;
           }
         }
+
+        const isConsultTerminalEvent =
+          taskData.type === 'AgentConsultEnded' || taskData.type === 'AgentConsultFailed';
+
+        if (isConsultTerminalEvent) {
+          updates.consultInitiator = false;
+          updates.consultFromConference = false;
+          updates.consultDestinationAgentJoined = false;
+          updates.consultCallHeld = false;
+          updates.consultDestinationType = null;
+          updates.consultDestinationAgentId = null;
+          updates.transferConferenceRequested = false;
+        }
+
         if (consultingActive && taskData.destinationType) {
-          updates.consultDestinationType = taskData.destinationType as DestinationType;
+          updates.consultDestinationType = mapConsultDestinationType(taskData.destinationType);
         }
 
-        if (!context.consultInitiator) {
+        if (!isConsultTerminalEvent && !context.consultInitiator) {
           const consultInitiator = determineConsultInitiator(taskData, selfAgentId);
           if (consultInitiator !== undefined) {
             updates.consultInitiator = consultInitiator;
@@ -232,6 +305,7 @@ const deriveTaskDataUpdates = (context: TaskContext, taskData: TaskData | undefi
 
         const effectiveConsultInitiator = updates.consultInitiator ?? context.consultInitiator;
         if (
+          !isConsultTerminalEvent &&
           effectiveConsultInitiator &&
           conferenceFromPayload &&
           (consultingActive || selfConsultingOrPending || Boolean(taskData?.consultMediaResourceId))
@@ -239,16 +313,37 @@ const deriveTaskDataUpdates = (context: TaskContext, taskData: TaskData | undefi
           updates.consultFromConference = true;
         }
 
-        if (consultingActive && taskData.interaction) {
-          const joinedConsultee = hasJoinedConsultDestination(taskData);
-          if (joinedConsultee) updates.consultDestinationAgentJoined = true;
+        if (
+          !isConsultTerminalEvent &&
+          (consultingActive || selfConsultingOrPending) &&
+          taskData.interaction
+        ) {
+          const joinedConsultee = hasJoinedConsultDestination(taskData, selfAgentId);
+          const selfParticipant = selfAgentId
+            ? (taskData.interaction.participants?.[selfAgentId] as
+                | {consultState?: string}
+                | undefined)
+            : undefined;
+          const agentConsultingSelfJoined =
+            taskData.type === 'AgentConsulting' &&
+            effectiveConsultInitiator &&
+            selfParticipant?.consultState === CONSULT_STATE.CONSULTING;
+
+          if (joinedConsultee || agentConsultingSelfJoined) {
+            updates.consultDestinationAgentJoined = true;
+          } else if (selfParticipant?.consultState === 'consultInitiated') {
+            updates.consultDestinationAgentJoined = false;
+          }
 
           if (!context.consultDestinationType && !updates.consultDestinationType) {
             const hasEpDnParticipant = Boolean(
               taskData.interaction.participants &&
-                Object.values(taskData.interaction.participants).some(
-                  (p: any) => p?.pType === 'EP-DN' && !p?.hasLeft
-                )
+                Object.values(taskData.interaction.participants).some((p: any) => {
+                  if (p?.hasLeft) return false;
+                  const pType = String(p?.pType ?? '').toUpperCase();
+
+                  return pType === 'EP-DN' || pType === 'EP_DN' || pType === 'DN';
+                })
             );
             if (hasEpDnParticipant) updates.consultDestinationType = 'entryPoint' as any;
           }
@@ -303,7 +398,7 @@ export function createInitialContext(
 
 export function updateUIControls(currentState: TaskState) {
   return assign(({context}: TaskActionArgs) => ({
-    uiControls: computeUIControls(currentState, context),
+    uiControls: computeUIControls(currentState, context, context.taskData ?? undefined),
   }));
 }
 
@@ -349,7 +444,27 @@ export const actions: TaskActionsMap = {
     return {};
   }),
 
-  handleConsultFailed: assign({consultDestinationAgentJoined: false, consultInitiator: false}),
+  handleConsultFailed: assign(({context, event}: TaskActionArgs) => {
+    const taskData = getTaskDataFromEvent(event) ?? context.taskData;
+    const cleared = {
+      consultDestinationType: null,
+      consultDestinationAgentId: null,
+      consultDestinationAgentJoined: false,
+      consultInitiator: false,
+      exitingConference: false,
+      consultCallHeld: false,
+      consultFromConference: false,
+      transferConferenceRequested: false,
+    };
+    const selfAgentId = context.uiControlConfig.agentId ?? taskData?.agentId;
+    const nextContext = {...context, ...cleared, taskData} as TaskContext;
+    const inferredState = getTaskStateForUiControls(taskData, selfAgentId);
+
+    return {
+      ...cleared,
+      uiControls: computeUIControls(inferredState, nextContext, taskData),
+    };
+  }),
   handleConferenceStarted: assign({consultInitiator: false}),
 
   setConsultDestination: assign(({event}: TaskActionArgs) => {
@@ -423,15 +538,26 @@ export const actions: TaskActionsMap = {
     return {};
   }),
 
-  clearConsultState: assign({
-    consultDestinationType: null,
-    consultDestinationAgentId: null,
-    consultDestinationAgentJoined: false,
-    consultInitiator: false,
-    exitingConference: false,
-    consultCallHeld: false,
-    consultFromConference: false,
-    transferConferenceRequested: false,
+  clearConsultState: assign(({context, event}: TaskActionArgs) => {
+    const cleared = {
+      consultDestinationType: null,
+      consultDestinationAgentId: null,
+      consultDestinationAgentJoined: false,
+      consultInitiator: false,
+      exitingConference: false,
+      consultCallHeld: false,
+      consultFromConference: false,
+      transferConferenceRequested: false,
+    };
+    const taskData = context.taskData ?? getTaskDataFromEvent(event);
+    const selfAgentId = context.uiControlConfig.agentId ?? taskData?.agentId;
+    const nextContext = {...context, ...cleared, taskData} as TaskContext;
+    const inferredState = getTaskStateForUiControls(taskData, selfAgentId);
+
+    return {
+      ...cleared,
+      uiControls: computeUIControls(inferredState, nextContext, taskData),
+    };
   }),
 
   setTransferConferenceRequested: assign({transferConferenceRequested: true}),