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

package/dist/types/services/task/state-machine/TaskStateMachine.d.ts

@@ -50,6 +50,10 @@ export declare function getTaskStateMachineConfig(uiControlConfig: UIControlConf
                     target: TaskState;
                     actions: string[];
                 };
+                OUTBOUND_FAILED: {
+                    target: TaskState;
+                    actions: string[];
+                };
                 CONSULTING_ACTIVE: {
                     target: TaskState;
                     actions: string[];
@@ -522,6 +526,10 @@ export declare function createTaskStateMachine(uiControlConfig: UIControlConfig,
                     target: TaskState;
                     actions: string[];
                 };
+                OUTBOUND_FAILED: {
+                    target: TaskState;
+                    actions: string[];
+                };
                 CONSULTING_ACTIVE: {
                     target: TaskState;
                     actions: string[];

package/dist/types/services/task/voice/Voice.d.ts

@@ -1,6 +1,7 @@
 import routingContact from '../contact';
 import { ConsultPayload, ConsultEndPayload, ResumeRecordingPayload, TaskData, TaskResponse, IVoice, VoiceUIControlOptions, TransferPayLoad } from '../types';
 import Task from '../Task';
+import { TaskActionArgs } from '../state-machine';
 import { WrapupData } from '../../config/types';
 export default class Voice extends Task implements IVoice {
     constructor(contact: ReturnType<typeof routingContact>, data: TaskData, callOptions?: VoiceUIControlOptions, wrapupData?: WrapupData, agentId?: string);
@@ -162,22 +163,22 @@ export default class Voice extends Task implements IVoice {
      */
     switchCall(): Promise<TaskResponse>;
     protected getChannelSpecificActionOverrides(): {
-        emitTaskHold: ({ event }: import("../state-machine").TaskActionArgs) => void;
-        emitTaskResume: ({ event }: import("../state-machine").TaskActionArgs) => void;
-        emitTaskRecordingStarted: ({ event }: import("../state-machine").TaskActionArgs) => void;
-        emitTaskRecordingPaused: ({ event }: import("../state-machine").TaskActionArgs) => void;
-        emitTaskRecordingPauseFailed: ({ event }: import("../state-machine").TaskActionArgs) => void;
-        emitTaskRecordingResumed: ({ event }: import("../state-machine").TaskActionArgs) => void;
-        emitTaskRecordingResumeFailed: ({ event }: import("../state-machine").TaskActionArgs) => void;
-        emitTaskParticipantJoined: ({ event }: import("../state-machine").TaskActionArgs) => void;
-        emitTaskParticipantLeft: ({ event }: import("../state-machine").TaskActionArgs) => void;
-        emitTaskConferenceStarted: ({ event }: import("../state-machine").TaskActionArgs) => void;
-        emitTaskConferenceEnded: ({ event }: import("../state-machine").TaskActionArgs) => void;
-        emitTaskConferenceFailed: ({ event }: import("../state-machine").TaskActionArgs) => void;
-        emitTaskExitConference: ({ event }: import("../state-machine").TaskActionArgs) => void;
-        emitTaskTransferConference: ({ event }: import("../state-machine").TaskActionArgs) => void;
-        emitTaskSwitchCall: ({ event }: import("../state-machine").TaskActionArgs) => void;
-        emitTaskTransferConferenceFailed: ({ event }: import("../state-machine").TaskActionArgs) => void;
-        emitTaskOutdialFailed: ({ event }: import("../state-machine").TaskActionArgs) => void;
+        emitTaskHold: ({ event }: TaskActionArgs) => void;
+        emitTaskResume: ({ event }: TaskActionArgs) => void;
+        emitTaskRecordingStarted: ({ event }: TaskActionArgs) => void;
+        emitTaskRecordingPaused: ({ event }: TaskActionArgs) => void;
+        emitTaskRecordingPauseFailed: ({ event }: TaskActionArgs) => void;
+        emitTaskRecordingResumed: ({ event }: TaskActionArgs) => void;
+        emitTaskRecordingResumeFailed: ({ event }: TaskActionArgs) => void;
+        emitTaskParticipantJoined: ({ event }: TaskActionArgs) => void;
+        emitTaskParticipantLeft: ({ event }: TaskActionArgs) => void;
+        emitTaskConferenceStarted: ({ event }: TaskActionArgs) => void;
+        emitTaskConferenceEnded: ({ event }: TaskActionArgs) => void;
+        emitTaskConferenceFailed: ({ event }: TaskActionArgs) => void;
+        emitTaskExitConference: ({ event }: TaskActionArgs) => void;
+        emitTaskTransferConference: ({ event }: TaskActionArgs) => void;
+        emitTaskSwitchCall: ({ event }: TaskActionArgs) => void;
+        emitTaskTransferConferenceFailed: ({ event }: TaskActionArgs) => void;
+        emitTaskOutdialFailed: ({ event }: TaskActionArgs) => void;
     };
 }

package/dist/webex.js

@@ -41,7 +41,7 @@ if (!global.Buffer) {
  */
 const Webex = _webexCore.default.extend({
   webex: true,
-  version: `3.12.0-task-refactor.4`
+  version: `3.12.0-task-refactor.5`
 });
 
 /**

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.5"
 }

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/state-machine/TaskStateMachine.ts

@@ -123,6 +123,12 @@ 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]: {
@@ -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

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

@@ -182,16 +182,18 @@ function computeVoiceInteractionUIControls(
 
   return {
     // Accept/Decline: Voice tasks in offered state
-    // For outdial, accept is disabled (auto-answer handles it), decline remains enabled
-    // For Extension mode (non-WebRTC), accept shows as disabled "Ringing" button
+    // 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 === TaskState.OFFERED && !interaction?.isTerminated
         ? {isVisible: true, isEnabled: isWebrtc && !isOutdial}
         : DISABLED,
-    decline:
-      isWebrtc && state === TaskState.OFFERED && !interaction?.isTerminated
-        ? VISIBLE_ENABLED
-        : DISABLED,
+    decline: (() => {
+      if (!isWebrtc || state !== TaskState.OFFERED || interaction?.isTerminated) return DISABLED;
+
+      return isOutdial ? VISIBLE_DISABLED : VISIBLE_ENABLED;
+    })(),
 
     // Hold: visible in connected/held/conference, disabled in conference/consulting
     hold: (() => {

package/src/services/task/voice/Voice.ts

@@ -25,7 +25,7 @@ import Task from '../Task';
 import LoggerProxy from '../../../logger-proxy';
 import MetricsManager from '../../../metrics/MetricsManager';
 import {METRIC_EVENT_NAMES} from '../../../metrics/constants';
-import {TaskState, TaskEvent} from '../state-machine';
+import {TaskState, TaskEvent, TaskActionArgs} from '../state-machine';
 import {WrapupData} from '../../config/types';
 import {getConsultMediaResourceId, getIsConferenceInProgress} from '../TaskUtils';
 
@@ -1252,9 +1252,13 @@ export default class Voice extends Task implements IVoice {
         TASK_EVENTS.TASK_CONFERENCE_TRANSFER_FAILED,
         {updateTaskData: true}
       ),
-      emitTaskOutdialFailed: this.createEmitSelfAction(TASK_EVENTS.TASK_OUTDIAL_FAILED, {
-        updateTaskData: true,
-      }),
+      emitTaskOutdialFailed: ({event}: TaskActionArgs) => {
+        if (event && 'taskData' in event && event.taskData) {
+          this.updateTaskData(event.taskData as TaskData);
+        }
+        const reason = (event as {reason?: string})?.reason || 'Outdial failed';
+        this.emit(TASK_EVENTS.TASK_OUTDIAL_FAILED, reason);
+      },
     };
   }
 }

package/test/unit/spec/services/task/TaskManager.ts

@@ -1280,6 +1280,32 @@ describe('TaskManager', () => {
     sendStateMachineEventSpy.mockRestore();
   });
 
+  it('should pass taskData in OUTBOUND_FAILED event for shouldWrapUp guard evaluation', () => {
+    const task = taskManager.getTask(taskId);
+    const sendStateMachineEventSpy = jest.spyOn(task, 'sendStateMachineEvent');
+    const payload = {
+      data: {
+        type: CC_EVENTS.AGENT_OUTBOUND_FAILED,
+        interactionId: taskId,
+        reason: 'CUSTOMER_BUSY',
+        agentsPendingWrapUp: ['agent-123'],
+        interaction: {
+          outboundType: 'OUTDIAL',
+          isTerminated: true,
+        },
+      },
+    };
+    webSocketManagerMock.emit('message', JSON.stringify(payload));
+    const stateMachineEvent = expectLastStateMachineEvent(
+      sendStateMachineEventSpy,
+      TaskEvent.OUTBOUND_FAILED
+    );
+    expect(stateMachineEvent?.taskData).toBeDefined();
+    expect(stateMachineEvent?.taskData?.agentsPendingWrapUp).toEqual(['agent-123']);
+    expect(stateMachineEvent?.taskData?.interaction?.outboundType).toBe('OUTDIAL');
+    sendStateMachineEventSpy.mockRestore();
+  });
+
   it('should handle AGENT_OUTBOUND_FAILED gracefully when task is undefined', () => {
     const payload = {
       data: {

package/test/unit/spec/services/task/state-machine/TaskStateMachine.ts

@@ -573,4 +573,65 @@ describe('Task state machine', () => {
       expect(service.getSnapshot().value).toBe(TaskState.TERMINATED);
     });
   });
+
+  describe('OUTBOUND_FAILED handling', () => {
+    it('transitions from IDLE to TERMINATED on OUTBOUND_FAILED (race condition)', () => {
+      const service = startMachine();
+      expect(service.getSnapshot().value).toBe(TaskState.IDLE);
+
+      const taskData = createTaskData({
+        interaction: {
+          outboundType: 'OUTDIAL',
+          isTerminated: true,
+        } as any,
+      });
+
+      service.send({type: TaskEvent.OUTBOUND_FAILED, taskData, reason: 'CUSTOMER_BUSY'});
+      expect(service.getSnapshot().value).toBe(TaskState.TERMINATED);
+    });
+
+    it('transitions from OFFERED to TERMINATED on OUTBOUND_FAILED without wrapup', () => {
+      const service = startMachine();
+      const offerTaskData = createTaskData({
+        interaction: {
+          outboundType: 'OUTDIAL',
+        } as any,
+      });
+
+      service.send({type: TaskEvent.TASK_INCOMING, taskData: offerTaskData});
+      expect(service.getSnapshot().value).toBe(TaskState.OFFERED);
+
+      const failedTaskData = createTaskData({
+        interaction: {
+          outboundType: 'OUTDIAL',
+          isTerminated: true,
+        } as any,
+      });
+      service.send({type: TaskEvent.OUTBOUND_FAILED, taskData: failedTaskData, reason: 'CUSTOMER_BUSY'});
+      expect(service.getSnapshot().value).toBe(TaskState.TERMINATED);
+    });
+
+    it('transitions from OFFERED to WRAPPING_UP on OUTBOUND_FAILED when wrapup is required', () => {
+      const service = startMachine();
+      const offerTaskData = createTaskData({
+        interaction: {
+          outboundType: 'OUTDIAL',
+        } as any,
+      });
+
+      service.send({type: TaskEvent.TASK_INCOMING, taskData: offerTaskData});
+      expect(service.getSnapshot().value).toBe(TaskState.OFFERED);
+
+      const failedTaskData = createTaskData({
+        agentId: 'agent-1',
+        agentsPendingWrapUp: ['agent-1'],
+        interaction: {
+          outboundType: 'OUTDIAL',
+          isTerminated: true,
+        } as any,
+      });
+      service.send({type: TaskEvent.OUTBOUND_FAILED, taskData: failedTaskData, reason: 'CUSTOMER_BUSY'});
+      expect(service.getSnapshot().value).toBe(TaskState.WRAPPING_UP);
+    });
+  });
 });

package/test/unit/spec/services/task/state-machine/uiControlsComputer.ts

@@ -146,6 +146,54 @@ describe('uiControlsComputer consult initiator controls', () => {
   });
 });
 
+describe('uiControlsComputer outdial accept/decline controls', () => {
+  function createOutdialContext(voiceVariant: 'webrtc' | 'pstn' = 'webrtc'): TaskContext {
+    const taskData = createTaskData({
+      interaction: {
+        outboundType: 'OUTDIAL',
+        state: 'new',
+        isTerminated: false,
+      } as any,
+    });
+    return {
+      taskData,
+      consultInitiator: false,
+      exitingConference: false,
+      consultFromConference: false,
+      transferConferenceRequested: false,
+      consultDestinationType: null,
+      consultDestinationAgentId: null,
+      consultDestinationAgentJoined: false,
+      consultCallHeld: false,
+      recordingControlsAvailable: false,
+      recordingInProgress: false,
+      uiControlConfig: {
+        isEndTaskEnabled: true,
+        isEndConsultEnabled: true,
+        channelType: TASK_CHANNEL_TYPE.VOICE,
+        isRecordingEnabled: false,
+        agentId: 'agent-1',
+        voiceVariant,
+      },
+      uiControls: getDefaultUIControls(),
+    };
+  }
+
+  it('accept is visible but disabled for WebRTC outdial in OFFERED state', () => {
+    const context = createOutdialContext('webrtc');
+    const uiControls = computeUIControls(TaskState.OFFERED, context, context.taskData);
+
+    expect(uiControls.main.accept).toEqual({isVisible: true, isEnabled: false});
+  });
+
+  it('decline is visible but disabled for WebRTC outdial in OFFERED state', () => {
+    const context = createOutdialContext('webrtc');
+    const uiControls = computeUIControls(TaskState.OFFERED, context, context.taskData);
+
+    expect(uiControls.main.decline).toEqual({isVisible: true, isEnabled: false});
+  });
+});
+
 describe('uiControlsComputer conference controls', () => {
   function createConferenceTaskData(participantCount: number) {
     const participants: Record<string, any> = {

package/test/unit/spec/services/task/voice/Voice.ts

@@ -72,6 +72,30 @@ describe('Voice Task', () => {
     jest.clearAllMocks();
   });
 
+  describe('emitTaskOutdialFailed', () => {
+    it('emits the failure reason string instead of the Task object', () => {
+      const taskData = createBaseData({
+        interaction: {
+          outboundType: 'OUTDIAL',
+        } as any,
+      });
+      const voice = new Voice(dummyContact, taskData, {});
+      const emitSpy = jest.spyOn(voice, 'emit');
+
+      voice.sendStateMachineEvent({
+        type: TaskEvent.OUTBOUND_FAILED,
+        taskData,
+        reason: 'CUSTOMER_BUSY',
+      });
+
+      const outdialFailedCall = emitSpy.mock.calls.find(
+        (call) => call[0] === 'task:outdialFailed'
+      );
+      expect(outdialFailedCall).toBeDefined();
+      expect(outdialFailedCall![1]).toBe('CUSTOMER_BUSY');
+    });
+  });
+
   it('hides end and endConsult when disabled', () => {
     const voice = new Voice(dummyContact, createBaseData(), {
       isEndTaskEnabled: false,