@webex/contact-center 3.12.0-next.9 → 3.12.0-next.90

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

@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isEventOfType = isEventOfType;
+var _constants = require("./constants");
+/**
+ * Task State Machine Types
+ *
+ * Type definitions for the XState-based task state machine.
+ * These types define states, events, context, and schemas for task lifecycle management.
+ */
+
+/**
+ * Represents a participant in a conference call
+ */
+
+/**
+ * UI Control configuration for the task
+ */
+
+/**
+ * Task state machine context.
+ * Only stores data that cannot be derived from state machine state.
+ */
+
+/**
+ * Base event type - all events have a type property
+ */
+
+/**
+ * Event payload mapping - defines the payload for each event type
+ */
+
+/**
+ * Union of all possible event payloads
+ */
+
+/**
+ * Type guard to check event type
+ */
+function isEventOfType(event, type) {
+  return Boolean(event && event.type === type);
+}
+
+/**
+ * Recording control state for UI controls computer
+ */
+
+/**
+ * State machine configuration type
+ */
+//# sourceMappingURL=types.js.map

package/dist/services/task/state-machine/types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_constants","require","isEventOfType","event","type","Boolean"],"sources":["types.ts"],"sourcesContent":["/**\n * Task State Machine Types\n *\n * Type definitions for the XState-based task state machine.\n * These types define states, events, context, and schemas for task lifecycle management.\n */\n\nimport type {AnyStateNodeConfig, ActionFunctionMap, EventObject, ActionArgs} from 'xstate';\nimport {DestinationType, TaskChannelType, TaskData, TaskUIControls, VoiceVariant} from '../types';\nimport {TaskEvent, TaskState} from './constants';\n\n/**\n * Represents a participant in a conference call\n */\nexport interface ConferenceParticipant {\n  /** Unique identifier for the participant */\n  id: string;\n  /** Type of participant (agent, customer, or external party) */\n  type: 'AGENT' | 'CUSTOMER' | 'EXTERNAL';\n  /** Display name of the participant */\n  name?: string;\n  /** Timestamp when participant joined the conference */\n  joinedAt: Date;\n  /** Whether this participant initiated the conference */\n  isInitiator: boolean;\n  /** Whether this participant can be removed from the conference */\n  canBeRemoved: boolean;\n}\n\n/**\n * UI Control configuration for the task\n */\nexport interface UIControlConfig {\n  /** Whether end call button is enabled (config option) */\n  isEndTaskEnabled: boolean;\n  /** Whether end consult button is enabled (config option) */\n  isEndConsultEnabled: boolean;\n  /** Channel type determines which controls are available */\n  channelType: TaskChannelType;\n  /** Optional voice channel variant to toggle WebRTC-specific controls */\n  voiceVariant?: VoiceVariant;\n  /** Whether recording controls should be shown for this task */\n  isRecordingEnabled: boolean;\n  /** Current agent ID for ownership checks (transfer conference) */\n  agentId?: string;\n}\n\n/**\n * Task state machine context.\n * Only stores data that cannot be derived from state machine state.\n */\nexport interface TaskContext {\n  taskData: TaskData | null;\n\n  // Consult tracking\n  consultInitiator: boolean;\n  exitingConference: boolean;\n  consultFromConference: boolean;\n  transferConferenceRequested: boolean;\n  consultDestinationType: DestinationType | null;\n  consultDestinationAgentId: string | null;\n  consultDestinationAgentJoined: boolean;\n  consultCallHeld: boolean;\n\n  // Recording\n  recordingControlsAvailable: boolean;\n  recordingInProgress: boolean;\n\n  // UI\n  uiControlConfig: UIControlConfig;\n  uiControls: TaskUIControls;\n}\n\nexport type RecordingStateUpdate = Partial<\n  Pick<TaskContext, 'recordingControlsAvailable' | 'recordingInProgress'>\n>;\n\n/**\n * Base event type - all events have a type property\n */\ntype BaseEvent<T extends TaskEvent> = {type: T};\n\n/**\n * Event payload mapping - defines the payload for each event type\n */\ninterface TaskEventPayloadMap {\n  [TaskEvent.TASK_INCOMING]: BaseEvent<TaskEvent.TASK_INCOMING> & {\n    taskData: TaskData;\n    /** Set when campaign preview reservation accept is receieved */\n    isCampaignReservationAccept?: boolean;\n  };\n  [TaskEvent.TASK_OFFERED]: BaseEvent<TaskEvent.TASK_OFFERED> & {taskData: TaskData};\n  [TaskEvent.OFFER_CONSULT]: BaseEvent<TaskEvent.OFFER_CONSULT> & {taskData: TaskData};\n  [TaskEvent.HYDRATE]: BaseEvent<TaskEvent.HYDRATE> & {taskData: TaskData; agentId?: string};\n  [TaskEvent.CONTACT_UPDATED]: BaseEvent<TaskEvent.CONTACT_UPDATED> & {taskData: TaskData};\n  [TaskEvent.CONTACT_OWNER_CHANGED]: BaseEvent<TaskEvent.CONTACT_OWNER_CHANGED> & {\n    taskData: TaskData;\n  };\n  [TaskEvent.ASSIGN]: BaseEvent<TaskEvent.ASSIGN> & {taskData: TaskData};\n  [TaskEvent.HOLD_INITIATED]: BaseEvent<TaskEvent.HOLD_INITIATED> & {mediaResourceId: string};\n  [TaskEvent.HOLD_SUCCESS]: BaseEvent<TaskEvent.HOLD_SUCCESS> & {\n    mediaResourceId: string;\n    taskData?: TaskData;\n  };\n  [TaskEvent.HOLD_FAILED]: BaseEvent<TaskEvent.HOLD_FAILED> & {\n    reason?: string;\n    mediaResourceId: string;\n  };\n  [TaskEvent.UNHOLD_INITIATED]: BaseEvent<TaskEvent.UNHOLD_INITIATED> & {mediaResourceId: string};\n  [TaskEvent.UNHOLD_SUCCESS]: BaseEvent<TaskEvent.UNHOLD_SUCCESS> & {\n    mediaResourceId: string;\n    taskData?: TaskData;\n  };\n  [TaskEvent.UNHOLD_FAILED]: BaseEvent<TaskEvent.UNHOLD_FAILED> & {\n    reason?: string;\n    mediaResourceId: string;\n  };\n  [TaskEvent.CONSULT]: BaseEvent<TaskEvent.CONSULT> & {\n    destination: string;\n    destAgentId?: string;\n    destinationType: DestinationType;\n  };\n  [TaskEvent.CONSULT_SUCCESS]: BaseEvent<TaskEvent.CONSULT_SUCCESS> & {taskData?: TaskData};\n  [TaskEvent.CONSULT_CREATED]: BaseEvent<TaskEvent.CONSULT_CREATED> & {taskData: TaskData};\n  [TaskEvent.CONSULTING_ACTIVE]: BaseEvent<TaskEvent.CONSULTING_ACTIVE> & {\n    consultDestinationAgentJoined: boolean;\n    taskData?: TaskData;\n  };\n  [TaskEvent.CONSULT_END]: BaseEvent<TaskEvent.CONSULT_END> & {taskData?: TaskData};\n  [TaskEvent.CONSULT_FAILED]: BaseEvent<TaskEvent.CONSULT_FAILED> & {\n    reason?: string;\n    taskData?: TaskData;\n  };\n  [TaskEvent.MERGE_TO_CONFERENCE]: BaseEvent<TaskEvent.MERGE_TO_CONFERENCE>;\n  [TaskEvent.CONFERENCE_START]: BaseEvent<TaskEvent.CONFERENCE_START> & {\n    participants?: ConferenceParticipant[];\n    taskData?: TaskData;\n  };\n  [TaskEvent.CONFERENCE_FAILED]: BaseEvent<TaskEvent.CONFERENCE_FAILED> & {\n    reason?: string;\n    taskData?: TaskData;\n  };\n  [TaskEvent.CONFERENCE_END]: BaseEvent<TaskEvent.CONFERENCE_END> & {taskData: TaskData};\n  [TaskEvent.TRANSFER_CONFERENCE]: BaseEvent<TaskEvent.TRANSFER_CONFERENCE> & {agentId?: string};\n  [TaskEvent.PARTICIPANT_LEAVE]: BaseEvent<TaskEvent.PARTICIPANT_LEAVE> & {\n    participantId?: string;\n    taskData: TaskData;\n  };\n  [TaskEvent.EXIT_CONFERENCE]: BaseEvent<TaskEvent.EXIT_CONFERENCE> & {agentId?: string};\n  [TaskEvent.EXIT_CONFERENCE_SUCCESS]: BaseEvent<TaskEvent.EXIT_CONFERENCE_SUCCESS> & {\n    taskData: TaskData;\n  };\n  [TaskEvent.EXIT_CONFERENCE_FAILED]: BaseEvent<TaskEvent.EXIT_CONFERENCE_FAILED> & {\n    reason?: string;\n  };\n  [TaskEvent.TRANSFER_CONFERENCE_SUCCESS]: BaseEvent<TaskEvent.TRANSFER_CONFERENCE_SUCCESS> & {\n    taskData: TaskData;\n  };\n  [TaskEvent.TRANSFER_CONFERENCE_FAILED]: BaseEvent<TaskEvent.TRANSFER_CONFERENCE_FAILED> & {\n    reason?: string;\n  };\n  [TaskEvent.RECORDING_STARTED]: BaseEvent<TaskEvent.RECORDING_STARTED> & {taskData: TaskData};\n  [TaskEvent.PAUSE_RECORDING]: BaseEvent<TaskEvent.PAUSE_RECORDING> & {taskData: TaskData};\n  [TaskEvent.RESUME_RECORDING]: BaseEvent<TaskEvent.RESUME_RECORDING> & {taskData: TaskData};\n  [TaskEvent.TRANSFER_SUCCESS]: BaseEvent<TaskEvent.TRANSFER_SUCCESS> & {taskData?: TaskData};\n  [TaskEvent.TRANSFER_FAILED]: BaseEvent<TaskEvent.TRANSFER_FAILED> & {\n    reason?: string;\n    taskData?: TaskData;\n  };\n  [TaskEvent.WRAPUP_COMPLETE]: BaseEvent<TaskEvent.WRAPUP_COMPLETE> & {taskData?: TaskData};\n  [TaskEvent.TASK_WRAPUP]: BaseEvent<TaskEvent.TASK_WRAPUP> & {taskData?: TaskData};\n  [TaskEvent.RONA]: BaseEvent<TaskEvent.RONA> & {taskData?: TaskData; reason?: string};\n  [TaskEvent.CONTACT_ENDED]: BaseEvent<TaskEvent.CONTACT_ENDED> & {taskData: TaskData};\n  [TaskEvent.ASSIGN_FAILED]: BaseEvent<TaskEvent.ASSIGN_FAILED> & {reason?: string};\n  [TaskEvent.INVITE_FAILED]: BaseEvent<TaskEvent.INVITE_FAILED> & {reason?: string};\n  [TaskEvent.OUTBOUND_FAILED]: BaseEvent<TaskEvent.OUTBOUND_FAILED> & {\n    reason?: string;\n    taskData?: TaskData;\n  };\n  [TaskEvent.CAMPAIGN_PREVIEW_ACCEPT_FAILED]: BaseEvent<TaskEvent.CAMPAIGN_PREVIEW_ACCEPT_FAILED> & {\n    taskData?: TaskData;\n  };\n  [TaskEvent.CAMPAIGN_PREVIEW_SKIP_FAILED]: BaseEvent<TaskEvent.CAMPAIGN_PREVIEW_SKIP_FAILED> & {\n    taskData?: TaskData;\n  };\n  [TaskEvent.CAMPAIGN_PREVIEW_REMOVE_FAILED]: BaseEvent<TaskEvent.CAMPAIGN_PREVIEW_REMOVE_FAILED> & {\n    taskData?: TaskData;\n  };\n  [TaskEvent.SWITCH_TO_MAIN_CALL]: BaseEvent<TaskEvent.SWITCH_TO_MAIN_CALL>;\n  [TaskEvent.SWITCH_TO_CONSULT]: BaseEvent<TaskEvent.SWITCH_TO_CONSULT>;\n  [TaskEvent.ACCEPT]: BaseEvent<TaskEvent.ACCEPT>;\n  [TaskEvent.DECLINE]: BaseEvent<TaskEvent.DECLINE>;\n  [TaskEvent.END]: BaseEvent<TaskEvent.END> & {taskData?: TaskData};\n  [TaskEvent.CTQ_CANCEL]: BaseEvent<TaskEvent.CTQ_CANCEL> & {taskData: TaskData};\n  [TaskEvent.CTQ_CANCEL_FAILED]: BaseEvent<TaskEvent.CTQ_CANCEL_FAILED> & {taskData: TaskData};\n}\n\n/**\n * Union of all possible event payloads\n */\nexport type TaskEventPayload = TaskEventPayloadMap[TaskEvent];\n\n/**\n * Type guard to check event type\n */\nexport function isEventOfType<T extends TaskEvent>(\n  event: TaskEventPayload | undefined,\n  type: T\n): event is TaskEventPayloadMap[T] {\n  return Boolean(event && event.type === type);\n}\n\n/**\n * Recording control state for UI controls computer\n */\nexport interface RecordingControlState {\n  available: boolean;\n  inProgress: boolean;\n}\n\n/**\n * State machine configuration type\n */\nexport interface TaskStateMachineConfig {\n  id: string;\n  initial: TaskState;\n  context: TaskContext;\n  states: Record<string, AnyStateNodeConfig>;\n}\n\nexport type TaskActionsMap = ActionFunctionMap<\n  TaskContext,\n  TaskEventPayload,\n  never,\n  {type: string; params: undefined},\n  never,\n  never,\n  EventObject\n>;\n\nexport type TaskActionArgs = ActionArgs<TaskContext, TaskEventPayload, TaskEventPayload>;\n"],"mappings":";;;;;;AASA,IAAAA,UAAA,GAAAC,OAAA;AATA;AACA;AACA;AACA;AACA;AACA;;AAMA;AACA;AACA;;AAgBA;AACA;AACA;;AAgBA;AACA;AACA;AACA;;AA2BA;AACA;AACA;;AAGA;AACA;AACA;;AAiHA;AACA;AACA;;AAGA;AACA;AACA;AACO,SAASC,aAAaA,CAC3BC,KAAmC,EACnCC,IAAO,EAC0B;EACjC,OAAOC,OAAO,CAACF,KAAK,IAAIA,KAAK,CAACC,IAAI,KAAKA,IAAI,CAAC;AAC9C;;AAEA;AACA;AACA;;AAMA;AACA;AACA","ignoreList":[]}

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

@@ -0,0 +1,553 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.computeUIControls = computeUIControls;
+exports.getDefaultUIControls = getDefaultUIControls;
+exports.haveUIControlsChanged = haveUIControlsChanged;
+var _types = require("../types");
+var _constants = require("./constants");
+var _TaskUtils = require("../TaskUtils");
+/**
+ * UI Controls Computer - Centralized logic for computing UI control states
+ */
+
+const DISABLED = {
+  isVisible: false,
+  isEnabled: false
+};
+const VISIBLE_ENABLED = {
+  isVisible: true,
+  isEnabled: true
+};
+const VISIBLE_DISABLED = {
+  isVisible: true,
+  isEnabled: false
+};
+function getDefaultInteractionUIControls() {
+  return {
+    accept: DISABLED,
+    decline: DISABLED,
+    hold: DISABLED,
+    mute: DISABLED,
+    end: DISABLED,
+    transfer: DISABLED,
+    consult: DISABLED,
+    consultTransfer: DISABLED,
+    endConsult: DISABLED,
+    recording: DISABLED,
+    conference: DISABLED,
+    wrapup: DISABLED,
+    exitConference: DISABLED,
+    transferConference: DISABLED,
+    mergeToConference: DISABLED,
+    switch: DISABLED
+  };
+}
+function createTaskUIControls(main, consult, activeLeg) {
+  return {
+    main,
+    consult,
+    activeLeg
+  };
+}
+function getDefaultUIControls() {
+  return createTaskUIControls(getDefaultInteractionUIControls(), getDefaultInteractionUIControls(), 'main');
+}
+
+/** Consult media must exist on the interaction payload, not only as a stale resource id. */
+function hasConsultMediaInInteraction(interaction, consultMediaResourceId) {
+  const media = interaction?.media ?? {};
+  const hasConsultLeg = Object.values(media).some(entry => entry?.mType === 'consult');
+  if (hasConsultLeg) return true;
+  if (!consultMediaResourceId) return false;
+  return Boolean(media[consultMediaResourceId]);
+}
+function computeVoiceInteractionUIControls(state, context, config, fallbackTaskData, currentLeg = 'main') {
+  // Early exit for idle
+  if (state === _constants.TaskState.IDLE) {
+    return getDefaultInteractionUIControls();
+  }
+
+  // Prefer live task.data (fallback) over stale state-machine snapshot during multi-login sync.
+  const taskData = fallbackTaskData ?? context.taskData ?? null;
+  const interaction = taskData?.interaction;
+  const mainCallId = interaction?.mainInteractionId || taskData?.interactionId;
+  const isWebrtc = config.voiceVariant === _types.VOICE_VARIANT.WEBRTC;
+  const isOutdial = interaction?.outboundType === 'OUTDIAL';
+  const serverHold = (0, _TaskUtils.getServerHoldStateForControls)(context, mainCallId, fallbackTaskData);
+
+  // Backend-derived checks
+  const customerInCall = interaction && mainCallId ? (0, _TaskUtils.getIsCustomerInCall)(interaction, mainCallId) : false;
+  // EP-DN/secondary legs can have incomplete media participant lists; fall back to participants map.
+  const customerPresent = customerInCall || Boolean(interaction && interaction.participants && Object.values(interaction.participants).some(p => p?.pType === 'Customer' && !p?.hasLeft));
+  const participantCount = interaction && mainCallId ? (0, _TaskUtils.getConferenceParticipantsCount)(interaction, mainCallId) : 0;
+  const maxParticipants = participantCount >= _constants.MAX_PARTICIPANTS_IN_MULTIPARTY_CONFERENCE;
+  const selfAgentId = config.agentId ?? taskData?.agentId;
+  const consultInProgress = (0, _TaskUtils.getIsConsultInProgressForConferenceControls)(interaction, mainCallId, selfAgentId);
+  const conferenceFromBackend = taskData ? (0, _TaskUtils.getIsConferenceInProgress)(taskData) : false;
+  // Note: ownership is used by some controls; keep computations local to those controls
+
+  // Context flags (set by state machine actions)
+  const {
+    consultInitiator,
+    consultDestinationAgentJoined,
+    consultDestinationType,
+    consultCallHeld,
+    consultFromConference
+  } = context;
+  const {
+    recordingControlsAvailable
+  } = context;
+
+  // EP_DN consults are "ready" as soon as the consult is created (EP accepts routing immediately).
+  // Backend sends destinationType as 'EP-DN'; SDK method uses 'entryPoint' — check both.
+  const isEpDnConsult = consultDestinationType === 'entryPoint' || consultDestinationType === 'EP-DN';
+  const stateImpliesHeld = state === _constants.TaskState.HELD || state === _constants.TaskState.RESUME_INITIATING;
+  const stateImpliesConnected = state === _constants.TaskState.CONNECTED || state === _constants.TaskState.HOLD_INITIATING;
+  const isHeld = stateImpliesHeld || serverHold === true;
+  const isConnected = stateImpliesConnected || !stateImpliesHeld && serverHold === false;
+
+  // State categories for cleaner logic
+  const isConsulting = state === _constants.TaskState.CONSULTING || state === _constants.TaskState.CONSULT_INITIATING || state === _constants.TaskState.CONF_INITIATING;
+  const isConferencing = state === _constants.TaskState.CONFERENCING;
+  const isWrappingUp = state === _constants.TaskState.WRAPPING_UP;
+  const selfInMainCall = Boolean(selfAgentId) && Boolean(mainCallId) && Boolean(interaction?.media?.[mainCallId]?.participants?.includes(selfAgentId));
+  const consultMedia = Object.values(interaction?.media ?? {}).find(media => media?.mediaResourceId === taskData?.consultMediaResourceId || media?.mType === 'consult');
+  const selfParticipant = selfAgentId ? interaction?.participants?.[selfAgentId] : null;
+  const selfInConsultCall = Boolean(selfAgentId) && Boolean(consultMedia?.participants?.includes(selfAgentId));
+  const hasConsultMedia = hasConsultMediaInInteraction(interaction, taskData?.consultMediaResourceId);
+  const isConsultEndedForSelf = taskData?.type === 'AgentConsultEnded' || taskData?.type === 'AgentConsultFailed' || selfParticipant?.consultState === 'consultCompleted' && !hasConsultMedia && taskData?.isConsulted === false;
+  const effectiveConsultInitiator = isConsultEndedForSelf ? false : consultInitiator;
+  const effectiveConsultCallHeld = isConsultEndedForSelf ? false : consultCallHeld;
+  const effectiveConsultFromConference = isConsultEndedForSelf ? false : consultFromConference;
+  const effectiveConsultDestinationAgentJoined = isConsultEndedForSelf ? false : consultDestinationAgentJoined;
+  // After a consult ends for self, the backend stops sending consult media but the merged
+  // task.data can still carry the stale consult-media entry (reconcileData never deletes keys).
+  // Treat it as gone so post-consult main-leg controls (consult retry) are not blocked.
+  const effectiveHasConsultMedia = isConsultEndedForSelf ? false : hasConsultMedia;
+  const isConsultDestinationReady = effectiveConsultDestinationAgentJoined || isEpDnConsult;
+  const conferenceActive = isConferencing || conferenceFromBackend || effectiveConsultFromConference;
+  // Treat consult initiator as "in conference" even if mainCall participant list lags while consulting.
+  const inConference = conferenceActive && (isConferencing || selfInMainCall || effectiveConsultInitiator);
+
+  // Check if this is a consulted agent (must be after isConsulting is computed).
+  const isSoleAgentOnCall = participantCount <= 1 && selfInMainCall && !isConsulting && !inConference;
+  const isConsulted = inConference || isSoleAgentOnCall ? false : (0, _TaskUtils.getIsConsultedAgentForControls)(taskData, context, isConsulting) || !effectiveConsultInitiator && (selfParticipant?.isConsulted === true || selfParticipant?.consultState === 'consulting');
+
+  // Active call = can perform call operations
+  const isActive = state === _constants.TaskState.CONNECTED || state === _constants.TaskState.HELD || state === _constants.TaskState.HOLD_INITIATING || state === _constants.TaskState.RESUME_INITIATING || isConsulting || isConferencing;
+
+  // Consulted agents have limited controls until they're in conference or wrapup
+  // Use inConference (not isConferencing) so controls remain enabled after state downgrade
+  const hasFullControls = !isConsulted || effectiveConsultInitiator || inConference || isWrappingUp;
+  const consultOwnedBySelf = effectiveConsultInitiator || Boolean(selfAgentId) && taskData?.consultingAgentId === selfAgentId;
+  const selfConsultPendingOnConsultMedia = selfParticipant?.consultState === 'consultInitiated' && !taskData?.isConsulted && hasConsultMedia;
+  const ownerParticipant = interaction?.owner ? interaction.participants?.[interaction.owner] : undefined;
+  const otherAgentConsultInProgress = Boolean(interaction?.participants && Object.values(interaction.participants).some(participant => {
+    if (!participant || participant.hasLeft) return false;
+    if (participant.id === selfAgentId) return false;
+    if (participant.pType !== 'AGENT') return false;
+    return participant.consultState === 'consultInitiated' || participant.consultState === 'consultReserved' || participant.consultState === 'consulting' || participant.currentState === 'consulting';
+  }));
+  const isHydratedConferenceConsultPending = inConference && selfConsultPendingOnConsultMedia && !effectiveConsultDestinationAgentJoined;
+  const hasParallelConsultLeg = !isConsultEndedForSelf && consultOwnedBySelf && !isConsulting && !isConsulted && (consultInProgress || effectiveConsultCallHeld || hasConsultMedia);
+  const activeLegForConferenceConsult = effectiveConsultCallHeld ? 'main' : 'consult';
+  const isCurrentLegActive = currentLeg === activeLegForConferenceConsult;
+  const isConferenceConsultTransferContext = inConference && effectiveConsultInitiator && hasConsultMedia && isConsultDestinationReady;
+  const consultLegOnHold = isConsulting && effectiveConsultCallHeld;
+  const callProcessingDetails = interaction?.callProcessingDetails;
+  const conferenceHoldParticipant = callProcessingDetails?.conferenceHoldParticipant === true || callProcessingDetails?.conferenceHoldParticipant === 'true';
+  const postDeclineHeldMainLeg = consultInitiator && !consultDestinationAgentJoined && isHeld && inConference && conferenceHoldParticipant;
+  const postConsultCompletedHeldMainLeg = selfParticipant?.consultState === 'consultCompleted' && isHeld && inConference && !isConsulting;
+  const nonOwnerPostConsultCompletedHeldMainLeg = isHeld && inConference && !isConsulting && !consultInitiator && Boolean(selfAgentId) && Boolean(interaction?.owner) && selfAgentId !== interaction?.owner && ownerParticipant?.consultState === 'consultCompleted';
+  const isConsultPendingBeforeJoin = selfParticipant?.consultState === 'consultInitiated' && !consultDestinationAgentJoined;
+  const hideExitConferenceWhileConsultPending = currentLeg === 'main' && inConference && isConsultPendingBeforeJoin && (consultFromConference || consultInitiator || taskData?.type === 'AgentConsultCreated' || consultInProgress || isConsulting);
+  const hideExitConferenceDuringActiveConsultFromConference = inConference && consultInitiator && consultDestinationAgentJoined && (isConsulting || taskData?.type === 'AgentConsulting' || selfParticipant?.consultState === 'consulting');
+  const hideExitConferenceOnMainLegForEpDnConsultFromConference = currentLeg === 'main' && inConference && consultFromConference && consultInitiator && (isConsulting || consultInProgress || taskData?.type === 'AgentConsultCreated' || taskData?.type === 'AgentConsulting' || selfParticipant?.consultState === 'consultInitiated' || selfParticipant?.consultState === 'consulting');
+  const forceHeldPostConsultControls = !hideExitConferenceWhileConsultPending && (postDeclineHeldMainLeg || postConsultCompletedHeldMainLeg);
+  const selfOnConsultLeg = selfParticipant?.consultState === 'consulting' || selfParticipant?.currentState === 'consulting';
+  const showMainLegConferenceControlsDuringConsult = currentLeg === 'main' && inConference && consultInProgress && !selfOnConsultLeg;
+  const allowHeldMainLegControlsForNonInitiator = showMainLegConferenceControlsDuringConsult && !isHydratedConferenceConsultPending;
+  const isConsultRequestedPhase = isConsultPendingBeforeJoin && !isConsulted && (consultInitiator || Boolean(selfAgentId) && selfParticipant?.consultState === 'consultInitiated' && taskData?.agentId === selfAgentId);
+  const isConsultUnansweredFailure = currentLeg === 'main' && !inConference && !taskData?.isConsulted && !effectiveHasConsultMedia && isHeld && selfParticipant?.consultState === 'consultCompleted' && (taskData?.type === 'AgentConsultFailed' || taskData?.type === 'AgentConsultEnded' || isConsultEndedForSelf);
+  if (isConsultUnansweredFailure) {
+    const recordingControl = recordingControlsAvailable && config.isRecordingEnabled && !inConference ? VISIBLE_ENABLED : DISABLED;
+    return {
+      ...getDefaultInteractionUIControls(),
+      hold: VISIBLE_ENABLED,
+      transfer: VISIBLE_ENABLED,
+      consult: VISIBLE_ENABLED,
+      recording: recordingControl,
+      end: VISIBLE_DISABLED
+    };
+  }
+  if (isConsultRequestedPhase) {
+    if (currentLeg === 'main') {
+      return {
+        ...getDefaultInteractionUIControls(),
+        transfer: VISIBLE_DISABLED,
+        conference: VISIBLE_DISABLED,
+        end: VISIBLE_DISABLED
+      };
+    }
+    if (currentLeg === 'consult') {
+      return {
+        ...getDefaultInteractionUIControls(),
+        endConsult: VISIBLE_ENABLED,
+        switch: VISIBLE_DISABLED,
+        transfer: VISIBLE_DISABLED,
+        transferConference: inConference ? VISIBLE_DISABLED : DISABLED,
+        mergeToConference: VISIBLE_DISABLED
+      };
+    }
+  }
+  return {
+    // Accept/Decline: Voice tasks in offered state
+    // Desktop/WebRTC + inbound: accept enabled (agent manually accepts)
+    // Desktop/WebRTC + outdial: accept disabled (auto-answer handles it; Widgets show "Accept" disabled)
+    // Extension mode (non-WebRTC): accept disabled (Widgets show "Ringing...")
+    accept: state === _constants.TaskState.OFFERED && !interaction?.isTerminated ? {
+      isVisible: true,
+      isEnabled: isWebrtc && !isOutdial
+    } : DISABLED,
+    decline: (() => {
+      if (!isWebrtc || state !== _constants.TaskState.OFFERED || interaction?.isTerminated) return DISABLED;
+      return isOutdial ? VISIBLE_DISABLED : VISIBLE_ENABLED;
+    })(),
+    // Hold: visible in connected/held/conference, disabled in conference/consulting
+    hold: (() => {
+      if (!hasFullControls) return DISABLED;
+      if (forceHeldPostConsultControls) return VISIBLE_ENABLED;
+      if (consultOwnedBySelf && (isConsulting || hasParallelConsultLeg || effectiveConsultCallHeld)) {
+        return DISABLED;
+      }
+      if (hasParallelConsultLeg) return DISABLED;
+      if (state === _constants.TaskState.OFFERED) return DISABLED;
+      if (isWrappingUp) return DISABLED;
+      // Visibility: connected || held || inConference
+      if (!(isConnected || isHeld || inConference)) return DISABLED;
+      // Enabled: (connected || held) && !inConference && !isConsulting
+      const canHold = (isConnected || isHeld) && !inConference && !isConsulting;
+      return canHold ? VISIBLE_ENABLED : VISIBLE_DISABLED;
+    })(),
+    // Mute: WebRTC only, active calls; hidden entirely during wrapup
+    mute: (() => {
+      if (!isWebrtc) return DISABLED;
+      if (isWrappingUp) return DISABLED;
+      if (currentLeg === 'consult' && !selfInConsultCall) return DISABLED;
+      // The consulted agent has no separate consult leg; their main leg is the active call, so
+      // mute stays available while they consult (the heuristic below targets the initiator's
+      // inactive leg, not the consultee's only leg).
+      const isConsultedActiveMainLeg = isConsulted && currentLeg === 'main';
+      if ((isConsulting || hasParallelConsultLeg) && !isCurrentLegActive && !isConsultedActiveMainLeg) {
+        return VISIBLE_DISABLED;
+      }
+      if (isConsulting) return VISIBLE_ENABLED;
+      if (isConnected || isHeld || isConferencing) {
+        if (inConference) return VISIBLE_ENABLED;
+        return isHeld ? VISIBLE_DISABLED : VISIBLE_ENABLED;
+      }
+      return DISABLED;
+    })(),
+    // End: varies by state; during consulting only on main leg (consult held)
+    end: (() => {
+      if (allowHeldMainLegControlsForNonInitiator) return VISIBLE_ENABLED;
+      if (showMainLegConferenceControlsDuringConsult) return VISIBLE_DISABLED;
+      if (isHydratedConferenceConsultPending && currentLeg === 'main') return VISIBLE_DISABLED;
+      if (!config.isEndTaskEnabled && !isWebrtc) return DISABLED;
+      if (hasParallelConsultLeg) {
+        return isConnected && isEpDnConsult ? VISIBLE_ENABLED : VISIBLE_DISABLED;
+      }
+      if (isConsulting) {
+        if (currentLeg === 'consult' && consultCallHeld) return DISABLED;
+        return consultInitiator && consultCallHeld ? VISIBLE_ENABLED : DISABLED;
+      }
+      if (inConference) {
+        if (isConsulted) return DISABLED;
+        if (forceHeldPostConsultControls) return VISIBLE_DISABLED;
+        if (consultInProgress) return VISIBLE_DISABLED;
+        return isWrappingUp ? VISIBLE_DISABLED : VISIBLE_ENABLED;
+      }
+      if (!hasFullControls) return DISABLED;
+      if (isActive) return isHeld || isWrappingUp ? VISIBLE_DISABLED : VISIBLE_ENABLED;
+      return DISABLED;
+    })(),
+    // Transfer: connected/held/conference
+    transfer: (() => {
+      if (isHydratedConferenceConsultPending) return VISIBLE_DISABLED;
+      if (isConferenceConsultTransferContext && currentLeg === 'main' && isCurrentLegActive) {
+        return DISABLED;
+      }
+      if (inConference && isConsulting && consultInitiator) return DISABLED;
+      if (hasParallelConsultLeg) {
+        if (!customerPresent) return DISABLED;
+        if (state === _constants.TaskState.CONNECTED) return VISIBLE_ENABLED;
+        if (state === _constants.TaskState.HELD) return VISIBLE_DISABLED;
+      }
+      if (isConsulting) {
+        if (!consultInitiator) return DISABLED;
+        if (!customerPresent) return VISIBLE_DISABLED;
+        if (consultLegOnHold) return VISIBLE_DISABLED;
+        return isConsultDestinationReady ? VISIBLE_ENABLED : VISIBLE_DISABLED;
+      }
+      if (!hasFullControls) return DISABLED;
+      if (inConference) {
+        // Real conference (multiple agents): transfer is hidden
+        // Pending conference (only self agent): transfer remains available
+        return participantCount > 1 ? DISABLED : VISIBLE_ENABLED;
+      }
+      if (state === _constants.TaskState.CONNECTED || state === _constants.TaskState.HELD) return VISIBLE_ENABLED;
+      return DISABLED;
+    })(),
+    // Consult: connected/held/conference when conditions met
+    consult: (() => {
+      const isConnectedOrHeld = state === _constants.TaskState.CONNECTED || state === _constants.TaskState.HELD;
+      if (isHeld && !inConference && !effectiveHasConsultMedia && selfParticipant?.consultState === 'consultCompleted' && !taskData?.isConsulted) {
+        const canRetryConsult = !maxParticipants && customerPresent && !otherAgentConsultInProgress;
+        return {
+          isVisible: true,
+          isEnabled: canRetryConsult
+        };
+      }
+      if (inConference && nonOwnerPostConsultCompletedHeldMainLeg) return VISIBLE_DISABLED;
+      if (hasParallelConsultLeg) return DISABLED;
+      if (!hasFullControls || !(isConnectedOrHeld || inConference)) {
+        return DISABLED;
+      }
+
+      // In conference: behavior depends on whether it's a real multi-agent conference
+      if (inConference) {
+        // Pending conference (only self agent): consult disabled
+        if (participantCount <= 1) return VISIBLE_DISABLED;
+        // Real conference: consult enabled if conditions met
+        const canFromConference = !maxParticipants && customerPresent && !consultInProgress && !otherAgentConsultInProgress && !isConsulting;
+        return {
+          isVisible: true,
+          isEnabled: canFromConference
+        };
+      }
+
+      // Enabled conditions for connected/held
+      const canFromConnected = !maxParticipants && customerPresent && !consultInProgress && !isConsulted;
+      return {
+        isVisible: true,
+        isEnabled: canFromConnected
+      };
+    })(),
+    // ConsultTransfer: always hidden (use transfer button)
+    consultTransfer: DISABLED,
+    // EndConsult: during consulting
+    endConsult: (() => {
+      if (!isConsulting) return DISABLED;
+      if (isConsulted && isConferencing) return DISABLED;
+      if (!isConsulted && isConferencing && !(consultInitiator && conferenceFromBackend)) {
+        return DISABLED;
+      }
+      return {
+        isVisible: true,
+        isEnabled: consultInitiator || config.isEndConsultEnabled
+      };
+    })(),
+    // Recording: connected/held, hidden in real conference, visible in pending conference
+    recording: (() => {
+      if (!recordingControlsAvailable || !config.isRecordingEnabled) return DISABLED;
+      if (!hasFullControls || isConsulting) return DISABLED;
+      if (inConference) {
+        // Real conference (multiple agents): recording hidden
+        // Pending conference (only self agent): recording available
+        return participantCount > 1 ? DISABLED : VISIBLE_ENABLED;
+      }
+      if (hasParallelConsultLeg && !customerPresent) return DISABLED;
+      if (state === _constants.TaskState.CONNECTED || state === _constants.TaskState.HELD) {
+        return VISIBLE_ENABLED;
+      }
+      return DISABLED;
+    })(),
+    // Conference: during consulting, enabled on both legs when agent joined
+    // Label changes based on leg: "Conference" on main leg, "Merge" on consult leg
+    conference: (() => {
+      if (isHydratedConferenceConsultPending && currentLeg === 'main') return VISIBLE_DISABLED;
+      if (hasParallelConsultLeg) {
+        if (!customerPresent) return DISABLED;
+        if (state === _constants.TaskState.CONNECTED) {
+          return maxParticipants ? VISIBLE_DISABLED : VISIBLE_ENABLED;
+        }
+        if (state === _constants.TaskState.HELD) return VISIBLE_DISABLED;
+        return DISABLED;
+      }
+      if (!hasFullControls || !isConsulting) return DISABLED;
+      if (!consultInitiator) return DISABLED;
+      if (!customerPresent) return VISIBLE_DISABLED;
+      if (consultLegOnHold) return VISIBLE_DISABLED;
+      return isConsultDestinationReady && !maxParticipants ? VISIBLE_ENABLED : VISIBLE_DISABLED;
+    })(),
+    // Wrapup: wrapping up state
+    wrapup: isWrappingUp ? VISIBLE_ENABLED : DISABLED,
+    // ExitConference: in conference with multiple agents in main call
+    exitConference: (() => {
+      if (hideExitConferenceWhileConsultPending) return DISABLED;
+      if (hideExitConferenceOnMainLegForEpDnConsultFromConference) return DISABLED;
+      if (allowHeldMainLegControlsForNonInitiator) return VISIBLE_ENABLED;
+      if (showMainLegConferenceControlsDuringConsult) return VISIBLE_DISABLED;
+      if (hideExitConferenceDuringActiveConsultFromConference) return DISABLED;
+      if (forceHeldPostConsultControls) return VISIBLE_DISABLED;
+      if (isConsulted && !isConferencing) return DISABLED;
+      if (!inConference) return DISABLED;
+      if (participantCount <= 1) return DISABLED;
+      if (consultInProgress) return VISIBLE_DISABLED;
+      const consultingFromConference = consultInitiator && isConsulting && conferenceFromBackend;
+      return consultingFromConference ? VISIBLE_DISABLED : VISIBLE_ENABLED;
+    })(),
+    // TransferConference: in conference with active consult, owner consulting from conference
+    transferConference: (() => {
+      if (isConferenceConsultTransferContext && !isCurrentLegActive) return VISIBLE_DISABLED;
+      const consultLegTransferAvailable = currentLeg === 'consult' && inConference && consultInitiator && hasConsultMedia;
+      const selfConsultingOnParticipantState = selfParticipant?.consultState === 'consulting';
+      const conferenceTransferAvailable = consultLegTransferAvailable || inConference && consultInitiator && hasConsultMedia && (isConsulting || consultInProgress || selfConsultingOnParticipantState);
+      if (consultLegOnHold) return DISABLED;
+      if (hasParallelConsultLeg && !conferenceTransferAvailable) return DISABLED;
+      if (!conferenceTransferAvailable && (!inConference || !isConsulting)) return DISABLED;
+      if (!consultInitiator || isConsulted) return DISABLED;
+      return isConsultDestinationReady ? VISIBLE_ENABLED : VISIBLE_DISABLED;
+    })(),
+    // MergeToConference: mirrors conference control, enabled on both legs
+    mergeToConference: (() => {
+      if (isHydratedConferenceConsultPending && currentLeg === 'consult') return VISIBLE_DISABLED;
+      if (!isConsulting || !consultInitiator) return DISABLED;
+      if (!customerPresent) return VISIBLE_DISABLED;
+      if (consultLegOnHold) return VISIBLE_DISABLED;
+      return isConsultDestinationReady && !maxParticipants ? VISIBLE_ENABLED : VISIBLE_DISABLED;
+    })(),
+    // Switch: visible only on the currently active leg
+    switch: (() => {
+      if (isHydratedConferenceConsultPending && currentLeg === 'consult') return VISIBLE_DISABLED;
+      if (!customerPresent && hasParallelConsultLeg) return DISABLED;
+      if (currentLeg === 'consult') {
+        if (!isConsulting || !consultInitiator || consultCallHeld) return DISABLED;
+        if (!customerPresent) return VISIBLE_DISABLED;
+        return isConsultDestinationReady ? VISIBLE_ENABLED : VISIBLE_DISABLED;
+      }
+      if (hasParallelConsultLeg && state === _constants.TaskState.CONNECTED) {
+        return isConsultDestinationReady ? VISIBLE_ENABLED : VISIBLE_DISABLED;
+      }
+      return DISABLED;
+    })()
+  };
+}
+function computeDigitalInteractionUIControls(state, context, fallbackTaskData) {
+  const taskData = context.taskData ?? fallbackTaskData ?? null;
+  const isTerminated = taskData?.interaction?.isTerminated ?? false;
+  const isConnected = state === _constants.TaskState.CONNECTED;
+  const isWrappingUp = state === _constants.TaskState.WRAPPING_UP;
+  return {
+    accept: state === _constants.TaskState.OFFERED ? VISIBLE_ENABLED : DISABLED,
+    decline: DISABLED,
+    hold: DISABLED,
+    mute: DISABLED,
+    end: isConnected && !isWrappingUp ? VISIBLE_ENABLED : DISABLED,
+    transfer: isConnected && !isWrappingUp ? VISIBLE_ENABLED : DISABLED,
+    consult: DISABLED,
+    consultTransfer: DISABLED,
+    endConsult: DISABLED,
+    recording: DISABLED,
+    conference: DISABLED,
+    wrapup: isTerminated || isWrappingUp ? VISIBLE_ENABLED : DISABLED,
+    exitConference: DISABLED,
+    transferConference: DISABLED,
+    mergeToConference: DISABLED,
+    switch: DISABLED
+  };
+}
+function getVoiceLegState(currentState, context, config, fallbackTaskData) {
+  if (currentState === _constants.TaskState.WRAPPING_UP) {
+    return {
+      hasConsultLeg: false,
+      activeLeg: 'main',
+      mainState: currentState,
+      consultState: _constants.TaskState.CONSULTING
+    };
+  }
+  const taskData = fallbackTaskData ?? context.taskData ?? null;
+  const interaction = taskData?.interaction;
+  const mainCallId = interaction?.mainInteractionId || taskData?.interactionId;
+  const selfAgentId = config.agentId ?? taskData?.agentId;
+  const selfParticipant = selfAgentId ? interaction?.participants?.[selfAgentId] : null;
+  const hasConsultMedia = hasConsultMediaInInteraction(interaction, taskData?.consultMediaResourceId);
+  const isConsultEndedForSelf = taskData?.type === 'AgentConsultEnded' || taskData?.type === 'AgentConsultFailed' || selfParticipant?.consultState === 'consultCompleted' && !hasConsultMedia && taskData?.isConsulted === false;
+  const consultInProgress = (0, _TaskUtils.getIsConsultInProgressForConferenceControls)(interaction, mainCallId, selfAgentId);
+  const isConsultingState = currentState === _constants.TaskState.CONSULTING || currentState === _constants.TaskState.CONSULT_INITIATING || currentState === _constants.TaskState.CONF_INITIATING;
+  const consultOwnedBySelf = context.consultInitiator || Boolean(selfAgentId) && taskData?.consultingAgentId === selfAgentId;
+  const selfConsultPendingOnConsultMedia = selfParticipant?.consultState === 'consultInitiated' && !taskData?.isConsulted && hasConsultMedia;
+  const selfConsultingOnConsultMedia = selfParticipant?.consultState === 'consulting' && hasConsultMedia;
+  const isConsultUnansweredFailure = !taskData?.isConsulted && !hasConsultMedia && selfParticipant?.consultState === 'consultCompleted' && Boolean(mainCallId && taskData?.interaction?.media?.[mainCallId]?.isHold === true) && taskData?.interaction?.state !== 'conference' && !(0, _TaskUtils.getIsConferenceInProgress)(taskData);
+  const hasConsultLeg = Boolean(!isConsultEndedForSelf && !interaction?.isTerminated && !isConsultUnansweredFailure && (consultOwnedBySelf || selfConsultingOnConsultMedia || selfConsultPendingOnConsultMedia) && (consultInProgress || isConsultingState || context.consultCallHeld || hasConsultMedia));
+  if (!hasConsultLeg) {
+    let mainState = currentState;
+    if (isConsultEndedForSelf && taskData?.interaction) {
+      const resolvedMainId = taskData.interaction.mainInteractionId || taskData.interactionId;
+      const isMainHeld = Boolean(resolvedMainId && taskData.interaction.media?.[resolvedMainId]?.isHold === true);
+      if (taskData.interaction.state === 'conference' || (0, _TaskUtils.getIsConferenceInProgress)(taskData)) {
+        mainState = _constants.TaskState.CONFERENCING;
+      } else if (isMainHeld || taskData.interaction.state === 'hold') {
+        mainState = _constants.TaskState.HELD;
+      } else {
+        mainState = _constants.TaskState.CONNECTED;
+      }
+    }
+    return {
+      hasConsultLeg: false,
+      activeLeg: 'main',
+      mainState,
+      consultState: _constants.TaskState.CONSULTING
+    };
+  }
+  let mainState = _constants.TaskState.HELD;
+  if (currentState === _constants.TaskState.CONFERENCING) {
+    mainState = _constants.TaskState.CONFERENCING;
+  } else if (context.consultCallHeld) {
+    mainState = _constants.TaskState.CONNECTED;
+  }
+  return {
+    hasConsultLeg: true,
+    activeLeg: context.consultCallHeld ? 'main' : 'consult',
+    mainState,
+    consultState: isConsultingState ? currentState : _constants.TaskState.CONSULTING
+  };
+}
+function computeUIControls(currentState, context, fallbackTaskData) {
+  if (currentState === _constants.TaskState.TERMINATED || currentState === _constants.TaskState.COMPLETED) {
+    return getDefaultUIControls();
+  }
+  switch (context.uiControlConfig.channelType) {
+    case _types.TASK_CHANNEL_TYPE.VOICE:
+      {
+        const {
+          hasConsultLeg,
+          activeLeg,
+          mainState,
+          consultState
+        } = getVoiceLegState(currentState, context, context.uiControlConfig, fallbackTaskData);
+        const mainControls = computeVoiceInteractionUIControls(mainState, context, context.uiControlConfig, fallbackTaskData, 'main');
+        const consultControls = hasConsultLeg ? computeVoiceInteractionUIControls(consultState, context, context.uiControlConfig, fallbackTaskData, 'consult') : getDefaultInteractionUIControls();
+        return createTaskUIControls(mainControls, consultControls, activeLeg);
+      }
+    case _types.TASK_CHANNEL_TYPE.DIGITAL:
+      return createTaskUIControls(computeDigitalInteractionUIControls(currentState, context, fallbackTaskData), getDefaultInteractionUIControls(), 'main');
+    default:
+      return getDefaultUIControls();
+  }
+}
+function haveInteractionUIControlsChanged(previous, next) {
+  return Object.keys(next).some(key => {
+    const prev = previous[key];
+    const curr = next[key];
+    return prev.isVisible !== curr.isVisible || prev.isEnabled !== curr.isEnabled;
+  });
+}
+function haveUIControlsChanged(previous, next) {
+  if (!previous) return true;
+  return previous.activeLeg !== next.activeLeg || haveInteractionUIControlsChanged(previous.main, next.main) || haveInteractionUIControlsChanged(previous.consult, next.consult);
+}
+//# sourceMappingURL=uiControlsComputer.js.map