@webex/contact-center 3.9.0-next.10 → 3.9.0-next.11

package/src/services/task/types.ts

@@ -370,6 +370,126 @@ export enum TASK_EVENTS {
    * ```
    */
   TASK_OFFER_CONTACT = 'task:offerContact',
+
+  /**
+   * Triggered when a conference is being established
+   * @example
+   * ```typescript
+   * task.on(TASK_EVENTS.TASK_CONFERENCE_ESTABLISHING, (task: ITask) => {
+   *   console.log('Conference establishing:', task.data.interactionId);
+   *   // Handle conference setup in progress
+   * });
+   * ```
+   */
+  TASK_CONFERENCE_ESTABLISHING = 'task:conferenceEstablishing',
+
+  /**
+   * Triggered when a conference is started successfully
+   * @example
+   * ```typescript
+   * task.on(TASK_EVENTS.TASK_CONFERENCE_STARTED, (task: ITask) => {
+   *   console.log('Conference started:', task.data.interactionId);
+   *   // Handle conference start
+   * });
+   * ```
+   */
+  TASK_CONFERENCE_STARTED = 'task:conferenceStarted',
+
+  /**
+   * Triggered when a conference fails to start
+   * @example
+   * ```typescript
+   * task.on(TASK_EVENTS.TASK_CONFERENCE_FAILED, (task: ITask) => {
+   *   console.log('Conference failed:', task.data.interactionId);
+   *   // Handle conference failure
+   * });
+   * ```
+   */
+  TASK_CONFERENCE_FAILED = 'task:conferenceFailed',
+
+  /**
+   * Triggered when a conference is ended successfully
+   * @example
+   * ```typescript
+   * task.on(TASK_EVENTS.TASK_CONFERENCE_ENDED, (task: ITask) => {
+   *   console.log('Conference ended:', task.data.interactionId);
+   *   // Handle conference end
+   * });
+   * ```
+   */
+  TASK_CONFERENCE_ENDED = 'task:conferenceEnded',
+
+  /**
+   * Triggered when a participant joins the conference
+   * @example
+   * ```typescript
+   * task.on(TASK_EVENTS.TASK_PARTICIPANT_JOINED, (task: ITask) => {
+   *   console.log('Participant joined conference:', task.data.interactionId);
+   *   // Handle participant joining
+   * });
+   * ```
+   */
+  TASK_PARTICIPANT_JOINED = 'task:participantJoined',
+
+  /**
+   * Triggered when a participant leaves the conference
+   * @example
+   * ```typescript
+   * task.on(TASK_EVENTS.TASK_PARTICIPANT_LEFT, (task: ITask) => {
+   *   console.log('Participant left conference:', task.data.interactionId);
+   *   // Handle participant leaving
+   * });
+   * ```
+   */
+  TASK_PARTICIPANT_LEFT = 'task:participantLeft',
+
+  /**
+   * Triggered when conference transfer is successful
+   * @example
+   * ```typescript
+   * task.on(TASK_EVENTS.TASK_CONFERENCE_TRANSFERRED, (task: ITask) => {
+   *   console.log('Conference transferred:', task.data.interactionId);
+   *   // Handle successful conference transfer
+   * });
+   * ```
+   */
+  TASK_CONFERENCE_TRANSFERRED = 'task:conferenceTransferred',
+
+  /**
+   * Triggered when conference transfer fails
+   * @example
+   * ```typescript
+   * task.on(TASK_EVENTS.TASK_CONFERENCE_TRANSFER_FAILED, (task: ITask) => {
+   *   console.log('Conference transfer failed:', task.data.interactionId);
+   *   // Handle failed conference transfer
+   * });
+   * ```
+   */
+  TASK_CONFERENCE_TRANSFER_FAILED = 'task:conferenceTransferFailed',
+
+  /**
+   * Triggered when ending a conference fails
+   * @example
+   * ```typescript
+   * task.on(TASK_EVENTS.TASK_CONFERENCE_END_FAILED, (task: ITask) => {
+   *   console.log('Conference end failed:', task.data.interactionId);
+   *   // Handle failed conference end
+   * });
+   * ```
+   */
+  TASK_CONFERENCE_END_FAILED = 'task:conferenceEndFailed',
+
+  /**
+   * Triggered when participant exit from conference fails
+   * @example
+   * ```typescript
+   * task.on(TASK_EVENTS.TASK_PARTICIPANT_LEFT_FAILED, (task: ITask) => {
+   *   console.log('Participant failed to leave conference:', task.data.interactionId);
+   *   // Handle failed participant exit
+   * });
+   * ```
+   */
+  TASK_PARTICIPANT_LEFT_FAILED = 'task:participantLeftFailed',
 }
 
 /**
@@ -883,6 +1003,19 @@ export type ConsultConferenceData = {
   destinationType: string;
 };
 
+/**
+ * Legacy consultation conference data type matching Agent Desktop
+ * @public
+ */
+export type consultConferencePayloadData = {
+  /** Identifier of the agent initiating consult/conference */
+  agentId: string;
+  /** Type of destination (e.g., 'agent', 'queue') */
+  destinationType: string;
+  /** Identifier of the destination agent */
+  destAgentId: string;
+};
+
 /**
  * Parameters required for cancelling a consult to queue operation
  * @public

package/test/unit/spec/cc.ts

@@ -139,6 +139,7 @@ describe('webex.cc', () => {
       webSocketManager: mockWebSocketManager,
       task: undefined,
       setWrapupData: jest.fn(),
+      setAgentId: jest.fn(),
       registerIncomingCallEvent: jest.fn(),
       registerTaskListeners: jest.fn(),
       getTask: jest.fn(),

package/test/unit/spec/metrics/behavioral-events.ts

@@ -110,6 +110,48 @@ describe('metrics/behavioral-events', () => {
         verb: 'fail',
       });
 
+      expect(getEventTaxonomy(METRIC_EVENT_NAMES.TASK_CONFERENCE_START_SUCCESS)).toEqual({
+        product,
+        agent: 'user',
+        target: 'task_conference_start',
+        verb: 'complete',
+      });
+
+      expect(getEventTaxonomy(METRIC_EVENT_NAMES.TASK_CONFERENCE_START_FAILED)).toEqual({
+        product,
+        agent: 'user',
+        target: 'task_conference_start',
+        verb: 'fail',
+      });
+
+      expect(getEventTaxonomy(METRIC_EVENT_NAMES.TASK_CONFERENCE_END_SUCCESS)).toEqual({
+        product,
+        agent: 'user',
+        target: 'task_conference_end',
+        verb: 'complete',
+      });
+
+      expect(getEventTaxonomy(METRIC_EVENT_NAMES.TASK_CONFERENCE_END_FAILED)).toEqual({
+        product,
+        agent: 'user',
+        target: 'task_conference_end',
+        verb: 'fail',
+      });
+
+      expect(getEventTaxonomy(METRIC_EVENT_NAMES.TASK_CONFERENCE_TRANSFER_SUCCESS)).toEqual({
+        product,
+        agent: 'user',
+        target: 'task_conference_transfer',
+        verb: 'complete',
+      });
+
+      expect(getEventTaxonomy(METRIC_EVENT_NAMES.TASK_CONFERENCE_TRANSFER_FAILED)).toEqual({
+        product,
+        agent: 'user',
+        target: 'task_conference_transfer',
+        verb: 'fail',
+      });
+
       expect(getEventTaxonomy('' as METRIC_EVENT_NAMES)).toEqual(undefined);
     });
   });

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

@@ -1353,6 +1353,143 @@ describe('TaskManager', () => {
         expect(spy).toHaveBeenCalledWith(taskEvent, task);
       });
     });
+  });
+
+  describe('Conference event handling', () => {
+    let task;
+    
+    beforeEach(() => {
+      task = {
+        data: { interactionId: taskId },
+        emit: jest.fn(),
+        updateTaskData: jest.fn().mockImplementation((updatedData) => {
+          // Mock the updateTaskData method to actually update task.data
+          task.data = { ...task.data, ...updatedData };
+          return task;
+        }),
+      };
+      taskManager.taskCollection[taskId] = task;
+    });
+
+    it('should handle AGENT_CONSULT_CONFERENCED event', () => {
+      const payload = {
+        data: {
+          type: CC_EVENTS.AGENT_CONSULT_CONFERENCED,
+          interactionId: taskId,
+          isConferencing: true,
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+      expect(task.data.isConferencing).toBe(true);
+      expect(task.emit).toHaveBeenCalledWith(TASK_EVENTS.TASK_CONFERENCE_STARTED, task);
+    });
+
+    it('should handle AGENT_CONSULT_CONFERENCING event', () => {
+      const payload = {
+        data: {
+          type: CC_EVENTS.AGENT_CONSULT_CONFERENCING,
+          interactionId: taskId,
+          isConferencing: true,
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+      expect(task.data.isConferencing).toBe(true);
+      // No task event emission for conferencing - only for conferenced (completed)
+      expect(task.emit).not.toHaveBeenCalledWith(TASK_EVENTS.TASK_CONFERENCE_STARTED, task);
+    });
+
+    it('should handle AGENT_CONSULT_CONFERENCE_FAILED event', () => {
+      const payload = {
+        data: {
+          type: CC_EVENTS.AGENT_CONSULT_CONFERENCE_FAILED,
+          interactionId: taskId,
+          reason: 'Network error',
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+      expect(task.data.reason).toBe('Network error');
+      // No event emission expected for failure - handled by contact method promise rejection
+    });
+
+    it('should handle PARTICIPANT_JOINED_CONFERENCE event', () => {
+      const payload = {
+        data: {
+          type: CC_EVENTS.PARTICIPANT_JOINED_CONFERENCE,
+          interactionId: taskId,
+          participantId: 'new-participant-123',
+          participantType: 'agent',
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+      expect(task.data.participantId).toBe('new-participant-123');
+      expect(task.data.participantType).toBe('agent');
+      // No specific task event emission for participant joined - just data update
+    });
+
+    it('should handle PARTICIPANT_LEFT_CONFERENCE event', () => {
+      const payload = {
+        data: {
+          type: CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE,
+          interactionId: taskId,
+          isConferencing: false,
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+      expect(task.data.isConferencing).toBe(false);
+      expect(task.emit).toHaveBeenCalledWith(TASK_EVENTS.TASK_PARTICIPANT_LEFT, task);
+    });
+
+    it('should handle PARTICIPANT_LEFT_CONFERENCE_FAILED event', () => {
+      const payload = {
+        data: {
+          type: CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE_FAILED,
+          interactionId: taskId,
+          reason: 'Exit failed',
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+      expect(task.data.reason).toBe('Exit failed');
+      // No event emission expected for failure - handled by contact method promise rejection
+    });
+
+    it('should only update task for matching interactionId', () => {
+      const otherTaskId = 'other-task-id';
+      const otherTask = {
+        data: { interactionId: otherTaskId },
+        emit: jest.fn(),
+      };
+      taskManager.taskCollection[otherTaskId] = otherTask;
+
+      const payload = {
+        data: {
+          type: CC_EVENTS.AGENT_CONSULT_CONFERENCED,
+          interactionId: taskId,
+          isConferencing: true,
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+      // Only the matching task should be updated
+      expect(task.data.isConferencing).toBe(true);
+      expect(task.emit).toHaveBeenCalledWith(TASK_EVENTS.TASK_CONFERENCE_STARTED, task);
+      
+      // Other task should not be affected
+      expect(otherTask.data.isConferencing).toBeUndefined();
+      expect(otherTask.emit).not.toHaveBeenCalled();
+    });
   });  
 });
 

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

@@ -197,7 +197,37 @@ describe("Routing contacts", () => {
     const req = contact.wrapup({
       interactionId: "interactionId",
       data: { wrapUpReason: "testWrapUpReason", auxCodeId: "auxCodeID1234", isAutoWrapup: "on" }
-    } as any);
+  } as any);
+  expect(req).toBeDefined();
+});
+
+  it("consultConference", () => {
+    fakeAqm.pendingRequests = {};
+    const consultData = {
+      agentId: "current-agent-id",
+      to: "destination-agent-id",
+      destinationType: "agent"
+    };
+    const req = contact.consultConference({
+      interactionId: "test-interaction-123",
+      data: consultData
+    });
+    expect(req).toBeDefined();
+  });
+
+  it("exitConference", () => {
+    fakeAqm.pendingRequests = {};
+    const req = contact.exitConference({
+      interactionId: "test-interaction-456"
+    });
+    expect(req).toBeDefined();
+  });
+
+  it("conferenceTransfer", () => {
+    fakeAqm.pendingRequests = {};
+    const req = contact.conferenceTransfer({
+      interactionId: "test-interaction-transfer-123"
+    });
     expect(req).toBeDefined();
   });
 });

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

@@ -75,6 +75,9 @@ describe('Task', () => {
       wrapup: jest.fn().mockResolvedValue({}),
       pauseRecording: jest.fn().mockResolvedValue({}),
       resumeRecording: jest.fn().mockResolvedValue({}),
+      consultConference: jest.fn().mockResolvedValue({}),
+      exitConference: jest.fn().mockResolvedValue({}),
+      conferenceTransfer: jest.fn().mockResolvedValue({}),
     };
 
     mockMetricsManager = {
@@ -671,8 +674,8 @@ describe('Task', () => {
     expect(loggerLogSpy).toHaveBeenCalledWith(`Consult started successfully to ${consultPayload.to}`, {
       module: TASK_FILE,
       method: 'consult',
-      trackingId: expectedResponse.trackingId,
       interactionId: task.data.interactionId,
+      trackingId: '1234',
     });
     expect(mockMetricsManager.trackEvent).toHaveBeenCalledWith(
       METRIC_EVENT_NAMES.TASK_CONSULT_START_SUCCESS,
@@ -1575,4 +1578,184 @@ describe('Task', () => {
       });
     });
   });
+
+  describe('Conference methods', () => {
+    beforeEach(() => {
+      contactMock = {
+        consultConference: jest.fn(),
+        exitConference: jest.fn(),
+        conferenceTransfer: jest.fn(),
+      };
+
+      // Re-setup the getDestinationAgentId spy for conference methods
+      getDestinationAgentIdSpy = jest
+        .spyOn(Utils, 'getDestinationAgentId')
+        .mockReturnValue(taskDataMock.destAgentId);
+
+
+      task = new Task(contactMock, webCallingService, taskDataMock, {
+        wrapUpProps: { wrapUpReasonList: [] },
+        autoWrapEnabled: false,
+        autoWrapAfterSeconds: 0
+      }, taskDataMock.agentId);
+    });
+
+    describe('consultConference', () => {
+
+      it('should successfully start conference and emit event', async () => {
+        const mockResponse = {
+          trackingId: 'test-tracking-id',
+          interactionId: taskId,
+        };
+        contactMock.consultConference.mockResolvedValue(mockResponse);
+        
+
+        const result = await task.consultConference();
+
+        expect(contactMock.consultConference).toHaveBeenCalledWith({
+          interactionId: taskId,
+          data: {
+            agentId: taskDataMock.agentId, // From task data agent ID
+            to: taskDataMock.destAgentId, // From getDestinationAgentId() using task participants
+            destinationType: 'agent', // From consultation data
+          },
+        });
+        expect(result).toEqual(mockResponse);
+        expect(LoggerProxy.info).toHaveBeenCalledWith(`Initiating consult conference to ${taskDataMock.destAgentId}`, {
+          module: TASK_FILE,
+          method: 'consultConference',
+          interactionId: taskId,
+        });
+        expect(LoggerProxy.log).toHaveBeenCalledWith('Consult conference started successfully', {
+          module: TASK_FILE,
+          method: 'consultConference',
+          interactionId: taskId,
+        });
+      });
+
+      it('should handle basic validation scenarios', async () => {
+        // Agent Desktop logic validates data structure but not participant availability
+        // This test confirms the method works with the Agent Desktop data flow
+        const mockResponse = {
+          trackingId: 'test-tracking-validation',
+          interactionId: taskId,
+        };
+        contactMock.consultConference.mockResolvedValue(mockResponse);
+
+        const result = await task.consultConference();
+        expect(result).toEqual(mockResponse);
+      });
+
+      it('should handle and rethrow contact method errors', async () => {
+        const mockError = new Error('Conference start failed');
+        contactMock.consultConference.mockRejectedValue(mockError);
+        generateTaskErrorObjectSpy.mockReturnValue(mockError);
+
+        await expect(task.consultConference()).rejects.toThrow('Conference start failed');
+        expect(LoggerProxy.error).toHaveBeenCalledWith('Failed to start consult conference', {
+          module: TASK_FILE,
+          method: 'consultConference',
+          interactionId: taskId,
+        });
+      });
+    });
+
+    describe('exitConference', () => {
+      it('should successfully end conference and emit event', async () => {
+        const mockResponse = {
+          trackingId: 'test-tracking-id-end',
+          interactionId: taskId,
+        };
+        contactMock.exitConference.mockResolvedValue(mockResponse);
+
+        const result = await task.exitConference();
+
+        expect(contactMock.exitConference).toHaveBeenCalledWith({
+          interactionId: taskId,
+        });
+        expect(result).toEqual(mockResponse);
+        expect(LoggerProxy.info).toHaveBeenCalledWith('Exiting consult conference', {
+          module: TASK_FILE,
+          method: 'exitConference',
+          interactionId: taskId,
+        });
+        expect(LoggerProxy.log).toHaveBeenCalledWith('Consult conference exited successfully', {
+          module: TASK_FILE,
+          method: 'exitConference',
+          interactionId: taskId,
+        });
+      });
+
+      it('should throw error for invalid interaction ID', async () => {
+        task.data.interactionId = '';
+
+        await expect(task.exitConference()).rejects.toThrow('Error while performing exitConference');
+        expect(contactMock.exitConference).not.toHaveBeenCalled();
+      });
+
+      it('should handle and rethrow contact method errors', async () => {
+        const mockError = new Error('Conference end failed');
+        contactMock.exitConference.mockRejectedValue(mockError);
+        generateTaskErrorObjectSpy.mockReturnValue(mockError);
+
+        await expect(task.exitConference()).rejects.toThrow('Conference end failed');
+        expect(LoggerProxy.error).toHaveBeenCalledWith('Failed to exit consult conference', {
+          module: TASK_FILE,
+          method: 'exitConference',
+          interactionId: taskId,
+        });
+      });
+    });
+
+    // TODO: Uncomment this test section in future PR for Multi-Party Conference support (>3 participants)
+    // Conference transfer tests will be uncommented when implementing enhanced multi-party conference functionality
+    /*
+    describe('transferConference', () => {
+      it('should successfully transfer conference', async () => {
+        const mockResponse = {
+          trackingId: 'test-tracking-id-transfer',
+          interactionId: taskId,
+        };
+        contactMock.conferenceTransfer.mockResolvedValue(mockResponse);
+        
+        const result = await task.transferConference();
+
+        expect(contactMock.conferenceTransfer).toHaveBeenCalledWith({
+          interactionId: taskId,
+        });
+        expect(result).toEqual(mockResponse);
+        expect(LoggerProxy.info).toHaveBeenCalledWith('Transferring conference', {
+          module: TASK_FILE,
+          method: 'transferConference',
+          interactionId: taskId,
+        });
+        expect(LoggerProxy.log).toHaveBeenCalledWith('Conference transferred successfully', {
+          module: TASK_FILE,
+          method: 'transferConference',
+          interactionId: taskId,
+        });
+      });
+
+      it('should throw error for invalid interaction ID', async () => {
+        task.data.interactionId = '';
+
+        await expect(task.transferConference()).rejects.toThrow('Error while performing transferConference');
+        expect(contactMock.conferenceTransfer).not.toHaveBeenCalled();
+      });
+
+      it('should handle and rethrow contact method errors', async () => {
+        const mockError = new Error('Conference transfer failed');
+        contactMock.conferenceTransfer.mockRejectedValue(mockError);
+        generateTaskErrorObjectSpy.mockReturnValue(mockError);
+
+        await expect(task.transferConference()).rejects.toThrow('Conference transfer failed');
+        expect(LoggerProxy.error).toHaveBeenCalledWith('Failed to transfer conference', {
+          module: TASK_FILE,
+          method: 'transferConference',
+          interactionId: taskId,
+        });
+      });
+    });
+    */
+  });
 });