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

package/dist/services/task/state-machine/TaskStateMachine.js

@@ -0,0 +1,634 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createTaskStateMachine = createTaskStateMachine;
+exports.getTaskStateMachineConfig = getTaskStateMachineConfig;
+var _xstate = require("xstate");
+var _constants = require("./constants");
+var _actions = require("./actions");
+var _guards = require("./guards");
+var _TaskUtils = require("../TaskUtils");
+/**
+ * Task State Machine Configuration
+ *
+ * This file defines the XState state machine configuration for contact center tasks.
+ * It orchestrates state transitions, guards, and actions for task lifecycle management.
+ *
+ * GUARD FUNCTIONS: All guard logic is centralized in guards.ts for reusability and testing.
+ * This file imports and uses those guards via the `guards` object.
+ */
+
+const taskStateMachineSetup = (0, _xstate.setup)({
+  actors: {},
+  types: {
+    context: {},
+    events: {}
+  }
+});
+
+/**
+ * Get task state machine configuration with UI control config
+ * Defines all states, transitions, guards, and actions for task management
+ *
+ * @param uiControlConfig - UI control configuration
+ * @returns State machine configuration object
+ */
+function getTaskStateMachineConfig(uiControlConfig) {
+  /**
+   * Event mapping reference (CC WebSocket -> TaskEvent)
+   *
+   * AgentContactReserved      -> TaskEvent.TASK_INCOMING
+   * AgentOfferContact         -> TaskEvent.TASK_OFFERED
+   * AgentOfferConsult         -> TaskEvent.OFFER_CONSULT
+   * AgentConsulting           -> TaskEvent.CONSULTING_ACTIVE
+   * AgentConsultCreated       -> TaskEvent.CONSULT_CREATED
+   * AgentConsultTransferred   -> TaskEvent.TRANSFER_SUCCESS
+   * AgentContactAssigned      -> TaskEvent.ASSIGN
+   * AgentContactHeld          -> TaskEvent.HOLD_SUCCESS
+   * AgentContactUnheld        -> TaskEvent.UNHOLD_SUCCESS
+   * AgentConsultEnded         -> TaskEvent.CONSULT_END
+   * AgentContactEnded         -> TaskEvent.CONTACT_ENDED
+   * AgentWrapup               -> TaskEvent.TASK_WRAPUP (wrapUpRequired)
+   * AgentWrappedup            -> TaskEvent.WRAPUP_COMPLETE
+   *
+   * (See TaskManager.mapEventToTaskStateMachineEvent for the full mapping table.)
+   */
+  return {
+    id: 'taskStateMachine',
+    initial: _constants.TaskState.IDLE,
+    context: (0, _actions.createInitialContext)(uiControlConfig, _constants.TaskState.IDLE),
+    on: {
+      [_constants.TaskEvent.RECORDING_STARTED]: {
+        actions: ['updateTaskData', 'emitTaskRecordingStarted']
+      },
+      [_constants.TaskEvent.CONTACT_UPDATED]: {
+        actions: ['updateTaskData', 'syncTaskDataFromEvent']
+      },
+      [_constants.TaskEvent.CONTACT_OWNER_CHANGED]: {
+        actions: ['updateTaskData', 'syncTaskDataFromEvent']
+      },
+      // HYDRATE: Update task data from AgentContact event
+      // Note: State restoration with transitions is handled in IDLE state.
+      // This root-level handler is for when task is already in another state (just updates data).
+      [_constants.TaskEvent.HYDRATE]: {
+        actions: ['updateTaskData', 'emitTaskHydrate']
+      }
+    },
+    states: {
+      [_constants.TaskState.IDLE]: {
+        on: {
+          // HYDRATE: Restore state machine to correct state based on hydrated task data
+          // This handles page refresh/reconnection scenarios where task needs to be restored
+          // IMPORTANT: This MUST be in IDLE state (not root) because root-level events cannot
+          // transition to child states in XState
+          [_constants.TaskEvent.HYDRATE]: [{
+            guard: _guards.guards.isInteractionTerminated,
+            target: _constants.TaskState.WRAPPING_UP,
+            actions: ['updateTaskData', 'markEnded', 'emitTaskHydrate']
+          }, {
+            guard: _guards.guards.isInteractionConsulting,
+            target: _constants.TaskState.CONSULTING,
+            actions: ['updateTaskData', 'emitTaskHydrate']
+          }, {
+            guard: _guards.guards.isInteractionHeld,
+            target: _constants.TaskState.HELD,
+            actions: ['updateTaskData', 'emitTaskHydrate']
+          }, {
+            guard: _guards.guards.isInteractionConnected,
+            target: _constants.TaskState.CONNECTED,
+            actions: ['updateTaskData', 'emitTaskHydrate']
+          }, {
+            guard: _guards.guards.isConferencingByParticipants,
+            target: _constants.TaskState.CONFERENCING,
+            actions: ['updateTaskData', 'emitTaskHydrate']
+          }, {
+            // Default: just update data, stay in IDLE
+            actions: ['updateTaskData', 'emitTaskHydrate']
+          }],
+          // AgentContactReserved (applicable for direct incoming/consult/transfer/outdial)
+          [_constants.TaskEvent.TASK_INCOMING]: {
+            target: _constants.TaskState.OFFERED,
+            actions: ['initializeTask', 'emitTaskIncoming']
+          },
+          // EP-DN split-leg ordering can deliver AgentConsulting before HYDRATE/TASK_INCOMING.
+          // Do not drop it in IDLE; bootstrap to CONSULTING using event taskData.
+          [_constants.TaskEvent.CONSULTING_ACTIVE]: {
+            target: _constants.TaskState.CONSULTING,
+            actions: ['updateTaskData', 'setConsultInitiator', 'setConsultDestination', 'setConsultFromConference', 'setConsultAgentJoined', 'emitTaskConsultAccepted', 'emitTaskConsulting']
+          }
+        }
+      },
+      [_constants.TaskState.OFFERED]: {
+        on: {
+          // AgentContactOffer
+          [_constants.TaskEvent.TASK_OFFERED]: {
+            actions: ['updateTaskData', 'emitTaskOfferContact', 'requestAutoAnswer']
+          },
+          // AgentContactAssigned
+          [_constants.TaskEvent.ASSIGN]: [{
+            guard: _guards.guards.isConsultingAssignment,
+            target: _constants.TaskState.CONSULTING,
+            actions: ['updateTaskData', 'emitTaskConsultAccepted', 'emitTaskConsulting']
+          }, {
+            target: _constants.TaskState.CONNECTED,
+            actions: ['updateTaskData', 'emitTaskAssigned']
+          }],
+          // AgentOfferContactRONA
+          [_constants.TaskEvent.RONA]: {
+            target: _constants.TaskState.TERMINATED,
+            actions: ['updateTaskData', 'markEnded', 'emitTaskReject']
+          },
+          [_constants.TaskEvent.TASK_WRAPUP]: {
+            target: _constants.TaskState.TERMINATED,
+            actions: ['updateTaskData', 'markEnded', 'emitTaskEnd']
+          },
+          [_constants.TaskEvent.CONTACT_ENDED]: {
+            target: _constants.TaskState.TERMINATED,
+            actions: ['updateTaskData', 'markEnded', 'emitTaskEnd']
+          },
+          // This needs to be handled for all assign failed scenarios (contact, buddy)
+          // [AgentContactAssignFailed, AgentCtqFailed, AgentBlindTransferFailed,
+          //  AgentVTeamTransferFailed, AgentConsultTransferFailed]
+          [_constants.TaskEvent.ASSIGN_FAILED]: {
+            target: _constants.TaskState.TERMINATED,
+            actions: ['updateTaskData', 'markEnded', 'emitTaskReject']
+          },
+          [_constants.TaskEvent.INVITE_FAILED]: {
+            target: _constants.TaskState.TERMINATED,
+            actions: ['updateTaskData', 'markEnded', 'emitTaskReject']
+          },
+          [_constants.TaskEvent.OUTBOUND_FAILED]: [{
+            guard: _guards.guards.shouldWrapUp,
+            target: _constants.TaskState.WRAPPING_UP,
+            actions: ['updateTaskData', 'markEnded', 'emitTaskOutdialFailed', 'emitTaskWrapup']
+          }, {
+            target: _constants.TaskState.TERMINATED,
+            actions: ['updateTaskData', 'markEnded', 'emitTaskOutdialFailed', 'emitTaskReject']
+          }],
+          // AgentConsulting comes for received after the initial consult is accepted
+          [_constants.TaskEvent.CONSULTING_ACTIVE]: [{
+            target: _constants.TaskState.CONSULTING,
+            actions: ['updateTaskData', 'setConsultAgentJoined', 'emitTaskConsultAccepted', 'emitTaskConsulting']
+          }],
+          // agentOfferConsult happens only on the receiver side of consult
+          [_constants.TaskEvent.OFFER_CONSULT]: {
+            actions: ['updateTaskData', 'emitTaskOfferConsult', 'requestAutoAnswer']
+          },
+          // AgentConsultFailed - when consulted agent (Agent 2) doesn't answer (RONA or decline)
+          // Clears the incoming consult notification by transitioning to TERMINATED
+          [_constants.TaskEvent.CONSULT_FAILED]: {
+            target: _constants.TaskState.TERMINATED,
+            actions: ['updateTaskData', 'clearConsultState', 'emitTaskReject']
+          },
+          // AgentConsultEnded - when consult initiator (Agent 1) ends the consult before
+          // the consulted agent (Agent 2) accepts. Clears the incoming notification.
+          [_constants.TaskEvent.CONSULT_END]: {
+            target: _constants.TaskState.TERMINATED,
+            actions: ['updateTaskData', 'clearConsultState', 'emitTaskReject']
+          }
+        }
+      },
+      [_constants.TaskState.CONNECTED]: {
+        on: {
+          // AgentConsulting may arrive while machine is CONNECTED (EP-DN/event ordering).
+          // Derive consultInitiator from payload so controls are set correctly.
+          [_constants.TaskEvent.CONSULTING_ACTIVE]: {
+            target: _constants.TaskState.CONSULTING,
+            actions: ['updateTaskData', 'setConsultInitiator', 'setConsultDestination', 'setConsultAgentJoined', 'emitTaskConsultAccepted', 'emitTaskConsulting']
+          },
+          // AgentContactAssigned can be resent after consult transfers; keep context in sync
+          [_constants.TaskEvent.ASSIGN]: {
+            target: _constants.TaskState.CONNECTED,
+            actions: ['updateTaskData', 'emitTaskAssigned']
+          },
+          // Click of hold button
+          [_constants.TaskEvent.HOLD_INITIATED]: {
+            target: _constants.TaskState.HOLD_INITIATING
+          },
+          // Remote hold from another login session (multi-login)
+          [_constants.TaskEvent.HOLD_SUCCESS]: {
+            target: _constants.TaskState.HELD,
+            actions: ['updateTaskData', 'setHoldState', 'emitTaskHold']
+          },
+          // Click of the consult button
+          [_constants.TaskEvent.CONSULT]: {
+            target: _constants.TaskState.CONSULT_INITIATING,
+            actions: ['setConsultInitiator', 'setConsultDestination']
+          },
+          // AgentConsultTransferred / AgentVTeamTransferred / AgentBlindTransferred
+          [_constants.TaskEvent.TRANSFER_SUCCESS]: [{
+            guard: _guards.guards.shouldWrapUpOrIsInitiator,
+            target: _constants.TaskState.WRAPPING_UP,
+            actions: ['updateTaskData', 'markEnded', 'clearConsultState', 'emitTaskWrapup']
+          }, {
+            // Receiver goes to connected as he receives transferSuccess event
+            actions: ['updateTaskData', 'clearConsultState']
+          }],
+          [_constants.TaskEvent.TRANSFER_FAILED]: {
+            actions: ['updateTaskData']
+          },
+          // AgentContactEnded Event
+          [_constants.TaskEvent.CONTACT_ENDED]: [{
+            // Conference still active → CONFERENCING
+            guard: _guards.guards.conferenceInProgressFromEvent,
+            target: _constants.TaskState.CONFERENCING,
+            actions: ['updateTaskData', 'emitTaskConferenceStarted', 'requestCleanup']
+          }, {
+            // Agent should wrap up → WRAPPING_UP
+            guard: _guards.guards.shouldWrapUp,
+            target: _constants.TaskState.WRAPPING_UP,
+            actions: ['updateTaskData', 'markEnded', 'emitTaskWrapup', 'requestCleanup']
+          }, {
+            // Consulted agent → TERMINATED
+            target: _constants.TaskState.TERMINATED,
+            actions: ['updateTaskData', 'markEnded', 'emitTaskEnd']
+          }],
+          [_constants.TaskEvent.TASK_WRAPUP]: {
+            target: _constants.TaskState.WRAPPING_UP,
+            actions: ['updateTaskData', 'markEnded', 'emitTaskWrapup']
+          },
+          [_constants.TaskEvent.PAUSE_RECORDING]: {
+            actions: ['updateTaskData', 'setRecordingState', 'emitTaskRecordingPaused']
+          },
+          [_constants.TaskEvent.RESUME_RECORDING]: {
+            actions: ['updateTaskData', 'setRecordingState', 'emitTaskRecordingResumed']
+          }
+        }
+      },
+      [_constants.TaskState.HOLD_INITIATING]: {
+        on: {
+          // AgentContactHeld Event
+          [_constants.TaskEvent.HOLD_SUCCESS]: {
+            target: _constants.TaskState.HELD,
+            actions: ['updateTaskData', 'setHoldState', 'emitTaskHold']
+          },
+          // AgentContactHoldFailed Event
+          [_constants.TaskEvent.HOLD_FAILED]: {
+            target: _constants.TaskState.CONNECTED,
+            actions: ['updateTaskData']
+          }
+        }
+      },
+      [_constants.TaskState.HELD]: {
+        on: {
+          // Click of the unhold button
+          [_constants.TaskEvent.UNHOLD_INITIATED]: {
+            target: _constants.TaskState.RESUME_INITIATING
+          },
+          // Remote resume from another login session (multi-login)
+          [_constants.TaskEvent.UNHOLD_SUCCESS]: {
+            target: _constants.TaskState.CONNECTED,
+            actions: ['updateTaskData', 'setHoldState', 'emitTaskResume']
+          },
+          // Click of the consult button
+          [_constants.TaskEvent.CONSULT]: {
+            target: _constants.TaskState.CONSULT_INITIATING,
+            actions: ['setConsultInitiator', 'setConsultDestination']
+          },
+          // TODO: This may not be a valid transition, need to be removed
+          // AgentConsultTransferred / AgentVTeamTransferred / AgentBlindTransferred
+          [_constants.TaskEvent.TRANSFER_SUCCESS]: [{
+            guard: _guards.guards.shouldWrapUpOrIsInitiator,
+            target: _constants.TaskState.WRAPPING_UP,
+            actions: ['updateTaskData', 'markEnded', 'emitTaskWrapup']
+          }, {
+            target: _constants.TaskState.CONNECTED,
+            actions: ['updateTaskData', 'clearConsultState']
+          }],
+          [_constants.TaskEvent.TRANSFER_FAILED]: {
+            actions: ['updateTaskData']
+          },
+          [_constants.TaskEvent.CONTACT_ENDED]: [{
+            guard: _guards.guards.conferenceInProgressFromEvent,
+            target: _constants.TaskState.CONFERENCING,
+            actions: ['updateTaskData', 'emitTaskConferenceStarted', 'requestCleanup']
+          }, {
+            guard: _guards.guards.shouldWrapUp,
+            target: _constants.TaskState.WRAPPING_UP,
+            actions: ['updateTaskData', 'markEnded', 'emitTaskWrapup', 'requestCleanup']
+          }, {
+            target: _constants.TaskState.TERMINATED,
+            actions: ['updateTaskData', 'markEnded', 'emitTaskEnd']
+          }],
+          // TODO: This may not be a valid transition, this needs to be checked as well
+          [_constants.TaskEvent.TASK_WRAPUP]: {
+            target: _constants.TaskState.WRAPPING_UP,
+            actions: ['updateTaskData', 'markEnded', 'emitTaskWrapup']
+          }
+        }
+      },
+      [_constants.TaskState.RESUME_INITIATING]: {
+        on: {
+          [_constants.TaskEvent.UNHOLD_SUCCESS]: {
+            target: _constants.TaskState.CONNECTED,
+            actions: ['updateTaskData', 'setHoldState', 'emitTaskResume']
+          },
+          [_constants.TaskEvent.UNHOLD_FAILED]: {
+            target: _constants.TaskState.HELD
+          }
+        }
+      },
+      [_constants.TaskState.CONSULT_INITIATING]: {
+        on: {
+          [_constants.TaskEvent.HOLD_SUCCESS]: {
+            actions: ['updateTaskData']
+          },
+          [_constants.TaskEvent.HOLD_FAILED]: {
+            target: _constants.TaskState.CONNECTED,
+            actions: ['updateTaskData', 'handleConsultFailed']
+          },
+          // AgentConsulting
+          // NOTE: Don't set consultDestinationAgentJoined here - wait for CONSULTING_ACTIVE
+          [_constants.TaskEvent.CONSULT_SUCCESS]: {
+            target: _constants.TaskState.CONSULTING,
+            actions: ['updateTaskData', 'setConsultInitiator']
+          },
+          // AgentConsultFailed, API Failures, AgentCtqFailed
+          [_constants.TaskEvent.CONSULT_FAILED]: [{
+            // Consult from conference → back to CONFERENCING
+            guard: ({
+              context
+            }) => context.consultFromConference === true,
+            target: _constants.TaskState.CONFERENCING,
+            actions: ['updateTaskData', 'handleConsultFailed']
+          }, {
+            guard: _guards.guards.isPrimaryMediaOnHold,
+            target: _constants.TaskState.HELD,
+            actions: ['updateTaskData', 'handleConsultFailed']
+          }, {
+            target: _constants.TaskState.CONNECTED,
+            actions: ['updateTaskData', 'handleConsultFailed']
+          }],
+          // AgentCtqCancelled Event
+          [_constants.TaskEvent.CTQ_CANCEL]: [{
+            guard: _guards.guards.isPrimaryMediaOnHold,
+            target: _constants.TaskState.HELD,
+            actions: ['updateTaskData', 'clearConsultState']
+          }, {
+            target: _constants.TaskState.CONNECTED,
+            actions: ['updateTaskData', 'clearConsultState']
+          }]
+        }
+      },
+      [_constants.TaskState.CONSULTING]: {
+        on: {
+          // AgentConsulting updates consulted agent arrival
+          [_constants.TaskEvent.CONSULTING_ACTIVE]: {
+            actions: ['updateTaskData', 'setConsultAgentJoined', 'setConsultDestination', 'emitTaskConsulting']
+          },
+          // AgentConsultEnded
+          [_constants.TaskEvent.CONSULT_END]: [{
+            // Initiator returning to conference (flag set OR backend still shows conference)
+            guard: ({
+              context,
+              event
+            }) => context.consultInitiator === true && (context.consultFromConference === true || _guards.guards.conferenceInProgressFromEvent({
+              context,
+              event
+            })),
+            target: _constants.TaskState.CONFERENCING,
+            actions: ['updateTaskData', 'clearConsultState', 'emitTaskConsultEnd']
+          }, {
+            // Initiator already switched back to the main/customer leg
+            guard: ({
+              context
+            }) => context.consultInitiator === true && context.consultCallHeld === true,
+            target: _constants.TaskState.CONNECTED,
+            actions: ['updateTaskData', 'clearConsultState', 'emitTaskConsultEnd']
+          }, {
+            // Initiator (no conference) → HELD
+            guard: ({
+              context
+            }) => context.consultInitiator === true,
+            target: _constants.TaskState.HELD,
+            actions: ['updateTaskData', 'clearConsultState', 'emitTaskConsultEnd']
+          }, {
+            // Consulted agent → TERMINATED
+            target: _constants.TaskState.TERMINATED,
+            actions: ['updateTaskData']
+          }],
+          // Switch between consult and main call (UI-driven toggle)
+          [_constants.TaskEvent.SWITCH_TO_MAIN_CALL]: {
+            actions: ['handleSwitchToMainCall', 'emitTaskSwitchCall']
+          },
+          [_constants.TaskEvent.SWITCH_TO_CONSULT]: {
+            actions: ['handleSwitchToConsult', 'emitTaskSwitchCall']
+          },
+          [_constants.TaskEvent.HOLD_SUCCESS]: {
+            actions: ['updateTaskData', 'setHoldState', 'emitTaskHold']
+          },
+          [_constants.TaskEvent.UNHOLD_SUCCESS]: {
+            actions: ['updateTaskData', 'setHoldState', 'emitTaskResume']
+          },
+          [_constants.TaskEvent.TRANSFER_SUCCESS]: [{
+            guard: _guards.guards.shouldWrapUpOrIsInitiator,
+            target: _constants.TaskState.WRAPPING_UP,
+            actions: ['updateTaskData', 'markEnded', 'clearConsultState', 'emitTaskWrapup']
+          }, {
+            target: _constants.TaskState.CONNECTED,
+            actions: ['updateTaskData', 'clearConsultState']
+          }],
+          [_constants.TaskEvent.TRANSFER_FAILED]: {
+            actions: ['updateTaskData']
+          },
+          [_constants.TaskEvent.TRANSFER_CONFERENCE]: {
+            // Track that this agent initiated the conference transfer so we can
+            // apply the correct lifecycle transition when success arrives.
+            actions: ['setTransferConferenceRequested', 'emitTaskTransferConference']
+          },
+          [_constants.TaskEvent.TRANSFER_CONFERENCE_SUCCESS]: [{
+            guard: ({
+              context
+            }) => context.transferConferenceRequested !== true,
+            actions: ['updateTaskData', 'handleTransferConferenceSuccess', 'clearTransferConferenceRequested']
+          }, {
+            guard: _guards.guards.shouldWrapUp,
+            target: _constants.TaskState.WRAPPING_UP,
+            actions: ['updateTaskData', 'markEnded', 'clearConsultState', 'handleTransferConferenceSuccess', 'clearTransferConferenceRequested', 'emitTaskWrapup']
+          }, {
+            // Non-initiator (consulted agent) stays in CONFERENCING
+            guard: ({
+              context
+            }) => !context.consultInitiator,
+            target: _constants.TaskState.CONFERENCING,
+            actions: ['updateTaskData', 'clearConsultState', 'handleTransferConferenceSuccess', 'clearTransferConferenceRequested']
+          }, {
+            target: _constants.TaskState.TERMINATED,
+            actions: ['updateTaskData', 'markEnded', 'clearConsultState', 'handleTransferConferenceSuccess', 'clearTransferConferenceRequested', 'emitTaskEnd']
+          }],
+          [_constants.TaskEvent.TRANSFER_CONFERENCE_FAILED]: {
+            actions: ['clearTransferConferenceRequested', 'emitTaskTransferConferenceFailed']
+          },
+          // AgentContactAssigned - receiver side becomes connected to customer
+          [_constants.TaskEvent.ASSIGN]: {
+            target: _constants.TaskState.CONNECTED,
+            actions: ['updateTaskData', 'emitTaskAssigned']
+          },
+          // AgentContactEnded
+          [_constants.TaskEvent.CONTACT_ENDED]: {
+            target: _constants.TaskState.WRAPPING_UP,
+            actions: ['updateTaskData', 'markEnded', 'clearConsultState', 'emitTaskWrapup', 'requestCleanup']
+          },
+          [_constants.TaskEvent.TASK_WRAPUP]: {
+            target: _constants.TaskState.WRAPPING_UP,
+            actions: ['updateTaskData', 'markEnded', 'clearConsultState', 'emitTaskWrapup']
+          },
+          [_constants.TaskEvent.MERGE_TO_CONFERENCE]: {
+            target: _constants.TaskState.CONF_INITIATING
+          },
+          // AgentConsultConferenced, ParticipantJoinedConference
+          [_constants.TaskEvent.CONFERENCE_START]: {
+            target: _constants.TaskState.CONFERENCING,
+            actions: ['handleConferenceStarted', 'clearConsultState']
+          }
+        }
+      },
+      [_constants.TaskState.CONF_INITIATING]: {
+        on: {
+          // AgentConsultConferenced, ParticipantJoinedConference
+          [_constants.TaskEvent.CONFERENCE_START]: {
+            target: _constants.TaskState.CONFERENCING,
+            actions: ['handleConferenceStarted']
+          },
+          // AgentConsultConferenceFailed
+          [_constants.TaskEvent.CONFERENCE_FAILED]: {
+            target: _constants.TaskState.CONSULTING,
+            actions: ['handleConferenceFailed', 'emitTaskConferenceFailed']
+          }
+        }
+      },
+      [_constants.TaskState.CONFERENCING]: {
+        on: {
+          [_constants.TaskEvent.CONFERENCE_START]: {
+            actions: ['updateTaskData', 'clearConsultState', 'emitTaskConferenceStarted']
+          },
+          [_constants.TaskEvent.EXIT_CONFERENCE_SUCCESS]: [{
+            guard: _guards.guards.shouldWrapUp,
+            target: _constants.TaskState.WRAPPING_UP,
+            actions: ['updateTaskData', 'markEnded', 'clearConsultState', 'emitTaskWrapup']
+          }, {
+            target: _constants.TaskState.TERMINATED,
+            actions: ['updateTaskData', 'markEnded', 'clearConsultState', 'emitTaskEnd']
+          }],
+          // Needed as all agents in conference get this event, hence we need to clear the consult state
+          [_constants.TaskEvent.CONSULT_END]: {
+            actions: ['updateTaskData', 'clearConsultState']
+          },
+          [_constants.TaskEvent.HOLD_SUCCESS]: {
+            actions: ['updateTaskData', 'setHoldState', 'emitTaskHold']
+          },
+          [_constants.TaskEvent.UNHOLD_SUCCESS]: {
+            actions: ['updateTaskData', 'setHoldState', 'emitTaskResume']
+          },
+          // Start a new consult from within an active conference
+          [_constants.TaskEvent.CONSULT]: {
+            target: _constants.TaskState.CONSULT_INITIATING,
+            actions: ['setConsultInitiator', 'setConsultDestination', 'setConsultFromConference']
+          },
+          // Participant leaves - handle conference downgrade scenarios
+          [_constants.TaskEvent.PARTICIPANT_LEAVE]: [{
+            // Only the leaving agent should wrap up → WRAPPING_UP
+            guard: params => _guards.guards.didCurrentAgentLeaveConference(params) && _guards.guards.shouldWrapUp(params),
+            target: _constants.TaskState.WRAPPING_UP,
+            actions: ['updateTaskData', 'handleParticipantLeft', 'markEnded', 'clearConsultState', 'emitTaskParticipantLeft', 'emitTaskWrapup']
+          }, {
+            // Only the leaving agent (no wrapup) → TERMINATED
+            guard: _guards.guards.didCurrentAgentLeaveConference,
+            target: _constants.TaskState.TERMINATED,
+            actions: ['updateTaskData', 'handleParticipantLeft', 'markEnded', 'clearConsultState', 'emitTaskParticipantLeft', 'emitTaskEnd']
+          }, {
+            // Conference downgraded, customer present → CONNECTED
+            guard: params => !_guards.guards.didCurrentAgentLeaveConference(params) && _guards.guards.shouldDowngradeConferenceToConnected(params),
+            target: _constants.TaskState.CONNECTED,
+            actions: ['updateTaskData', 'handleParticipantLeft', 'clearConsultState', 'emitTaskParticipantLeft', 'emitTaskConferenceEnded']
+          }, {
+            actions: ['updateTaskData', 'handleParticipantLeft', 'emitTaskParticipantLeft']
+          }],
+          [_constants.TaskEvent.TRANSFER_CONFERENCE]: {
+            actions: ['setTransferConferenceRequested', 'emitTaskTransferConference']
+          },
+          [_constants.TaskEvent.TRANSFER_CONFERENCE_SUCCESS]: [{
+            // Not initiated by this agent → just refresh backend state.
+            guard: ({
+              context
+            }) => context.transferConferenceRequested !== true,
+            actions: ['updateTaskData', 'handleTransferConferenceSuccess', 'clearTransferConferenceRequested']
+          }],
+          [_constants.TaskEvent.TRANSFER_CONFERENCE_FAILED]: {
+            actions: ['clearTransferConferenceRequested', 'emitTaskTransferConferenceFailed']
+          },
+          // Conference ends explicitly
+          [_constants.TaskEvent.CONFERENCE_END]: [{
+            // Agent who should wrap up → WRAPPING_UP
+            guard: _guards.guards.shouldWrapUp,
+            target: _constants.TaskState.WRAPPING_UP,
+            actions: ['updateTaskData', 'markEnded', 'clearConsultState', 'emitTaskWrapup']
+          }, {
+            // Customer still in call → CONNECTED
+            guard: ({
+              context,
+              event
+            }) => {
+              if (context.exitingConference === true) return false;
+              const taskData = event?.taskData ?? context.taskData;
+              if (!taskData?.interaction) return false;
+              const mainCallId = taskData.interaction.mainInteractionId || taskData.interactionId;
+              if (!mainCallId) return false;
+              return (0, _TaskUtils.getIsCustomerInCall)(taskData.interaction, mainCallId);
+            },
+            target: _constants.TaskState.CONNECTED,
+            actions: ['updateTaskData', 'clearConsultState', 'emitTaskConferenceEnded']
+          }, {
+            // Otherwise → TERMINATED
+            target: _constants.TaskState.TERMINATED,
+            actions: ['updateTaskData', 'markEnded', 'clearConsultState', 'emitTaskEnd']
+          }],
+          // CONTACT_ENDED in conference
+          [_constants.TaskEvent.CONTACT_ENDED]: [{
+            // Conference still active → stay
+            actions: ['updateTaskData', 'requestCleanup']
+          }]
+        }
+      },
+      [_constants.TaskState.WRAPPING_UP]: {
+        // Only emit wrapup event on entry - task:end should only be emitted when COMPLETED
+        entry: ['emitTaskWrapup'],
+        on: {
+          // AgentWrappedup Event
+          [_constants.TaskEvent.WRAPUP_COMPLETE]: {
+            target: _constants.TaskState.COMPLETED,
+            actions: ['updateTaskData']
+          }
+        }
+      },
+      [_constants.TaskState.COMPLETED]: {
+        type: 'final',
+        entry: ['emitTaskWrappedup', 'cleanupResources']
+      },
+      [_constants.TaskState.TERMINATED]: {
+        type: 'final',
+        entry: ['cleanupResources']
+      }
+    }
+  };
+}
+
+/**
+ * Create a task state machine instance using only the built-in actions.
+ * The resulting machine is ready for most consumers that rely on the default
+ * context mutators declared in actions.ts.
+ *
+ * @param uiControlConfig - UI control configuration
+ * @returns StateMachine instance for task management
+ */
+function createTaskStateMachine(uiControlConfig, options) {
+  return taskStateMachineSetup.createMachine(getTaskStateMachineConfig(uiControlConfig)).provide({
+    actions: {
+      ..._actions.actions,
+      ...(options?.actions ?? {})
+    }
+  });
+}
+//# sourceMappingURL=TaskStateMachine.js.map