@webex/contact-center 3.10.0-next.2 → 3.10.0-next.21

package/src/services/task/index.ts

@@ -1,12 +1,7 @@
 import EventEmitter from 'events';
 import {CALL_EVENT_KEYS, LocalMicrophoneStream} from '@webex/calling';
 import {CallId} from '@webex/calling/dist/types/common/types';
-import {
-  generateTaskErrorObject,
-  deriveConsultTransferDestinationType,
-  getDestinationAgentId,
-  buildConsultConferenceParamData,
-} from '../core/Utils';
+import {generateTaskErrorObject, calculateDestAgentId, calculateDestType} from '../core/Utils';
 import {Failure} from '../core/GlobalTypes';
 import {LoginOption} from '../../types';
 import {TASK_FILE} from '../../constants';
@@ -1447,35 +1442,31 @@ export default class Task extends EventEmitter implements ITask {
   public async consultTransfer(
     consultTransferPayload?: ConsultTransferPayLoad
   ): Promise<TaskResponse> {
-    try {
-      // Get the destination agent ID using custom logic from participants data
-      const destAgentId = getDestinationAgentId(
-        this.data.interaction?.participants,
-        this.data.agentId
-      );
-
-      // Resolve the target id (queue consult transfers go to the accepted agent)
-      if (!destAgentId) {
-        throw new Error('No agent has accepted this queue consult yet');
-      }
+    // Get the destination agent ID using custom logic from participants data
+    const destAgentId = calculateDestAgentId(this.data.interaction, this.agentId);
 
-      LoggerProxy.info(
-        `Initiating consult transfer to ${consultTransferPayload?.to || destAgentId}`,
-        {
-          module: TASK_FILE,
-          method: METHODS.CONSULT_TRANSFER,
-          interactionId: this.data.interactionId,
-        }
-      );
-      // Obtain payload based on desktop logic using TaskData
-      const finalDestinationType = deriveConsultTransferDestinationType(this.data);
-
-      // By default we always use the computed destAgentId as the target id
-      const consultTransferRequest: ConsultTransferPayLoad = {
-        to: destAgentId,
-        destinationType: finalDestinationType,
-      };
+    // Resolve the target id (queue consult transfers go to the accepted agent)
+    if (!destAgentId) {
+      throw new Error('No agent has accepted this queue consult yet');
+    }
 
+    LoggerProxy.info(
+      `Initiating consult transfer to ${consultTransferPayload?.to || destAgentId}`,
+      {
+        module: TASK_FILE,
+        method: METHODS.CONSULT_TRANSFER,
+        interactionId: this.data.interactionId,
+      }
+    );
+
+    // Derive destination type from the participant's type property
+    const destType = calculateDestType(this.data.interaction, this.agentId);
+    // By default we always use the computed destAgentId as the target id
+    const consultTransferRequest: ConsultTransferPayLoad = {
+      to: destAgentId,
+      destinationType: destType,
+    };
+    try {
       const result = await this.contact.consultTransfer({
         interactionId: this.data.interactionId,
         data: consultTransferRequest,
@@ -1513,17 +1504,12 @@ export default class Task extends EventEmitter implements ITask {
         errorData: err.data?.errorData,
         reasonCode: err.data?.reasonCode,
       };
-      const failedDestinationType = deriveConsultTransferDestinationType(this.data);
-      const failedDestAgentId = getDestinationAgentId(
-        this.data.interaction?.participants,
-        this.data.agentId
-      );
       this.metricsManager.trackEvent(
         METRIC_EVENT_NAMES.TASK_TRANSFER_FAILED,
         {
           taskId: this.data.interactionId,
-          destination: failedDestAgentId || '',
-          destinationType: failedDestinationType,
+          destination: destAgentId || '',
+          destinationType: destType,
           isConsultTransfer: true,
           error: error.toString(),
           ...taskErrorProps,
@@ -1556,28 +1542,36 @@ export default class Task extends EventEmitter implements ITask {
    * ```
    */
   public async consultConference(): Promise<TaskResponse> {
+    // Get the destination agent ID dynamically from participants
+    // This handles multi-party conference scenarios, CBT (Capacity Based Team), and EP-DN cases
+    const destAgentId = calculateDestAgentId(this.data.interaction, this.agentId);
+
+    // Validate that we have a destination agent (for queue consult scenarios)
+    if (!destAgentId) {
+      throw new Error('No agent has accepted this queue consult yet');
+    }
+
+    // Get the destination agent ID for fetching destination type
+    // This helps determine the correct participant type for CBT (Capacity Based Team) and EP-DN scenarios
+    const destAgentType = calculateDestType(this.data.interaction, this.agentId);
+
     // Extract consultation conference data from task data (used in both try and catch)
     const consultationData = {
       agentId: this.agentId,
-      destAgentId: this.data.destAgentId,
-      destinationType: this.data.destinationType || 'agent',
+      to: destAgentId,
+      destinationType: destAgentType || this.data.destinationType || 'agent',
     };
 
     try {
-      LoggerProxy.info(`Initiating consult conference to ${consultationData.destAgentId}`, {
+      LoggerProxy.info(`Initiating consult conference to ${destAgentId}`, {
         module: TASK_FILE,
         method: METHODS.CONSULT_CONFERENCE,
         interactionId: this.data.interactionId,
       });
 
-      const paramsDataForConferenceV2 = buildConsultConferenceParamData(
-        consultationData,
-        this.data.interactionId
-      );
-
       const response = await this.contact.consultConference({
-        interactionId: paramsDataForConferenceV2.interactionId,
-        data: paramsDataForConferenceV2.data,
+        interactionId: this.data.interactionId,
+        data: consultationData,
       });
 
       // Track success metrics (following consultTransfer pattern)
@@ -1585,9 +1579,9 @@ export default class Task extends EventEmitter implements ITask {
         METRIC_EVENT_NAMES.TASK_CONFERENCE_START_SUCCESS,
         {
           taskId: this.data.interactionId,
-          destination: paramsDataForConferenceV2.data.to,
-          destinationType: paramsDataForConferenceV2.data.destinationType,
-          agentId: paramsDataForConferenceV2.data.agentId,
+          destination: consultationData.to,
+          destinationType: consultationData.destinationType,
+          agentId: consultationData.agentId,
           ...MetricsManager.getCommonTrackingFieldForAQMResponse(response),
         },
         ['operational', 'behavioral', 'business']
@@ -1610,20 +1604,13 @@ export default class Task extends EventEmitter implements ITask {
         reasonCode: err.data?.reasonCode,
       };
 
-      // Track failure metrics (following consultTransfer pattern)
-      // Build conference data for error tracking using extracted data
-      const failedParamsData = buildConsultConferenceParamData(
-        consultationData,
-        this.data.interactionId
-      );
-
       this.metricsManager.trackEvent(
         METRIC_EVENT_NAMES.TASK_CONFERENCE_START_FAILED,
         {
           taskId: this.data.interactionId,
-          destination: failedParamsData.data.to,
-          destinationType: failedParamsData.data.destinationType,
-          agentId: failedParamsData.data.agentId,
+          destination: consultationData.to,
+          destinationType: consultationData.destinationType,
+          agentId: consultationData.agentId,
           error: error.toString(),
           ...taskErrorProps,
           ...MetricsManager.getCommonTrackingFieldForAQMResponseFailed(error.details || {}),

package/src/services/task/types.ts

@@ -347,6 +347,18 @@ export enum TASK_EVENTS {
    */
   TASK_REJECT = 'task:rejected',
 
+  /**
+   * Triggered when an outdial call fails
+   * @example
+   * ```typescript
+   * task.on(TASK_EVENTS.TASK_OUTDIAL_FAILED, (reason: string) => {
+   *   console.log('Outdial failed:', reason);
+   *   // Handle outdial failure
+   * });
+   * ```
+   */
+  TASK_OUTDIAL_FAILED = 'task:outdialFailed',
+
   /**
    * Triggered when a task is populated with data
    * @example
@@ -371,6 +383,22 @@ export enum TASK_EVENTS {
    */
   TASK_OFFER_CONTACT = 'task:offerContact',
 
+  /**
+   * Triggered when a task has been successfully auto-answered
+   * This event is emitted after the SDK automatically accepts a task due to:
+   * - WebRTC calls with auto-answer enabled
+   * - Agent-initiated outdial calls
+   * - Other auto-answer scenarios
+   * @example
+   * ```typescript
+   * task.on(TASK_EVENTS.TASK_AUTO_ANSWERED, (task: ITask) => {
+   *   console.log('Task auto-answered:', task.data.interactionId);
+   *   // Update UI - enable cancel button, etc.
+   * });
+   * ```
+   */
+  TASK_AUTO_ANSWERED = 'task:autoAnswered',
+
   /**
    * Triggered when a conference is being established
    * @example
@@ -490,6 +518,30 @@ export enum TASK_EVENTS {
    * ```
    */
   TASK_PARTICIPANT_LEFT_FAILED = 'task:participantLeftFailed',
+
+  /**
+   * Triggered when a contact is merged
+   * @example
+   * ```typescript
+   * task.on(TASK_EVENTS.TASK_MERGED, (task: ITask) => {
+   *   console.log('Contact merged:', task.data.interactionId);
+   *   // Handle contact merge
+   * });
+   * ```
+   */
+  TASK_MERGED = 'task:merged',
+
+  /**
+   * Triggered when a participant enters post-call activity state
+   * @example
+   * ```typescript
+   * task.on(TASK_EVENTS.TASK_POST_CALL_ACTIVITY, (task: ITask) => {
+   *   console.log('Participant in post-call activity:', task.data.interactionId);
+   *   // Handle post-call activity
+   * });
+   * ```
+   */
+  TASK_POST_CALL_ACTIVITY = 'task:postCallActivity',
 }
 
 /**
@@ -636,6 +688,8 @@ export type Interaction = {
     BLIND_TRANSFER_IN_PROGRESS?: boolean;
     /** Desktop view configuration for Flow Control */
     fcDesktopView?: string;
+    /** Agent ID who initiated the outdial call */
+    outdialAgentId?: string;
   };
   /** Main interaction identifier for related interactions */
   mainInteractionId?: string;
@@ -757,8 +811,14 @@ export type TaskData = {
   isWebCallMute?: boolean;
   /** Identifier for reservation interaction */
   reservationInteractionId?: string;
+  /** Identifier for the reserved agent channel (used for campaign tasks) */
+  reservedAgentChannelId?: string;
   /** Indicates if wrap-up is required for this task */
   wrapUpRequired?: boolean;
+  /** Indicates if auto-answer is in progress for this task */
+  isAutoAnswering?: boolean;
+  /** Indicates if wrap-up is required for this task */
+  agentsPendingWrapUp?: string[];
 };
 
 /**
@@ -1005,19 +1065,6 @@ 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

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

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

@@ -152,6 +152,20 @@ describe('metrics/behavioral-events', () => {
         verb: 'fail',
       });
 
+      expect(getEventTaxonomy(METRIC_EVENT_NAMES.TASK_AUTO_ANSWER_SUCCESS)).toEqual({
+        product,
+        agent: 'user',
+        target: 'task_auto_answer',
+        verb: 'complete',
+      });
+
+      expect(getEventTaxonomy(METRIC_EVENT_NAMES.TASK_AUTO_ANSWER_FAILED)).toEqual({
+        product,
+        agent: 'user',
+        target: 'task_auto_answer',
+        verb: 'fail',
+      });
+
       expect(getEventTaxonomy('' as METRIC_EVENT_NAMES)).toEqual(undefined);
     });
   });

package/test/unit/spec/services/core/Utils.ts

@@ -229,7 +229,7 @@ describe('Utils', () => {
       });
     });
 
-    it('should return DUPLICATE_LOCATION message and fieldName for DN number', () => {
+    it('should return DUPLICATE_LOCATION message and fieldName for dial number', () => {
       const failure = {data: {reason: 'DUPLICATE_LOCATION'}} as Failure;
       const result = Utils.getStationLoginErrorData(failure, LoginOption.AGENT_DN);
       expect(result).toEqual({
@@ -277,53 +277,284 @@ describe('Utils', () => {
     });
   });
 
-  describe('getDestinationAgentId', () => {
-    const currentAgentId = 'agent-current-123';
+  describe('getConsultedAgentId', () => {
+    const currentAgentId = 'agent-123';
 
-    it('returns another Agent id when present and not in wrap-up', () => {
-      const participants: any = {
-        [currentAgentId]: {type: 'Agent', id: currentAgentId, isWrapUp: false},
-        agent1: {type: 'Agent', id: 'agent-1', isWrapUp: false},
-        customer1: {type: 'Customer', id: 'cust-1', isWrapUp: false},
+    it('should return consulted agent ID from consult media', () => {
+      const media: any = {
+        mainCall: {
+          mType: 'mainCall',
+          participants: [currentAgentId, 'customer-1'],
+        },
+        consultCall: {
+          mType: 'consult',
+          participants: [currentAgentId, 'agent-456'],
+        },
+      };
+
+      const result = Utils.getConsultedAgentId(media, currentAgentId);
+      expect(result).toBe('agent-456');
+    });
+
+    it('should return empty string when no consult media exists', () => {
+      const media: any = {
+        mainCall: {
+          mType: 'mainCall',
+          participants: [currentAgentId, 'customer-1'],
+        },
       };
 
-      const result = Utils.getDestinationAgentId(participants, currentAgentId);
-      expect(result).toBe('agent-1');
+      const result = Utils.getConsultedAgentId(media, currentAgentId);
+      expect(result).toBe('');
     });
 
-    it('ignores self and wrap-up participants', () => {
-      const participants: any = {
-        [currentAgentId]: {type: 'Agent', id: currentAgentId, isWrapUp: false},
-        agentWrap: {type: 'Agent', id: 'agent-wrap', isWrapUp: true},
+    it('should return empty string when current agent is not in consult participants', () => {
+      const media: any = {
+        consultCall: {
+          mType: 'consult',
+          participants: ['other-agent-1', 'other-agent-2'],
+        },
       };
 
-      const result = Utils.getDestinationAgentId(participants, currentAgentId);
+      const result = Utils.getConsultedAgentId(media, currentAgentId);
+      expect(result).toBe('');
+    });
+
+    it('should handle empty media object', () => {
+      const result = Utils.getConsultedAgentId({}, currentAgentId);
       expect(result).toBe('');
     });
 
-    it('supports DN, EpDn and entryPoint types', () => {
-      const participantsDN: any = {
-        [currentAgentId]: {type: 'Agent', id: currentAgentId, isWrapUp: false},
-        dn1: {type: 'DN', id: 'dn-1', isWrapUp: false},
+    it('should handle multiple media entries and find consult', () => {
+      const media: any = {
+        media1: {mType: 'mainCall', participants: [currentAgentId]},
+        media2: {mType: 'hold', participants: []},
+        media3: {mType: 'consult', participants: [currentAgentId, 'consulted-agent']},
+      };
+
+      const result = Utils.getConsultedAgentId(media, currentAgentId);
+      expect(result).toBe('consulted-agent');
+    });
+  });
+
+  describe('getDestAgentIdForCBT', () => {
+    it('should return destination agent ID for CBT scenario', () => {
+      const interaction: any = {
+        participants: {
+          'agent-uuid-123': {
+            type: 'Agent',
+            pType: 'dn',
+            dn: '5551234567',
+            id: 'agent-uuid-123',
+          },
+          'customer-1': {
+            type: 'Customer',
+            pType: 'Customer',
+            id: 'customer-1',
+          },
+        },
+      };
+      const consultingAgent = '5551234567'; // Phone number, not in participants as key
+
+      const result = Utils.getDestAgentIdForCBT(interaction, consultingAgent);
+      expect(result).toBe('agent-uuid-123');
+    });
+
+    it('should return empty string when consultingAgent is in participants (non-CBT)', () => {
+      const interaction: any = {
+        participants: {
+          'agent-123': {
+            type: 'Agent',
+            pType: 'Agent',
+            id: 'agent-123',
+          },
+        },
       };
-      expect(Utils.getDestinationAgentId(participantsDN, currentAgentId)).toBe('dn-1');
+      const consultingAgent = 'agent-123'; // Exists as key in participants
+
+      const result = Utils.getDestAgentIdForCBT(interaction, consultingAgent);
+      expect(result).toBe('');
+    });
 
-      const participantsEpDn: any = {
-        [currentAgentId]: {type: 'Agent', id: currentAgentId, isWrapUp: false},
-        epdn1: {type: 'EpDn', id: 'epdn-1', isWrapUp: false},
+    it('should return empty string when no matching dial number found', () => {
+      const interaction: any = {
+        participants: {
+          'agent-uuid-123': {
+            type: 'Agent',
+            pType: 'dn',
+            dn: '5559999999',
+            id: 'agent-uuid-123',
+          },
+        },
       };
-      expect(Utils.getDestinationAgentId(participantsEpDn, currentAgentId)).toBe('epdn-1');
+      const consultingAgent = '5551234567'; // Different number
+
+      const result = Utils.getDestAgentIdForCBT(interaction, consultingAgent);
+      expect(result).toBe('');
+    });
 
-      const participantsEntry: any = {
-        [currentAgentId]: {type: 'Agent', id: currentAgentId, isWrapUp: false},
-        entry1: {type: 'entryPoint', id: 'entry-1', isWrapUp: false},
+    it('should return empty string when consultingAgent is empty', () => {
+      const interaction: any = {
+        participants: {
+          'agent-uuid-123': {
+            type: 'Agent',
+            pType: 'dn',
+            dn: '5551234567',
+          },
+        },
       };
-      expect(Utils.getDestinationAgentId(participantsEntry, currentAgentId)).toBe('entry-1');
+
+      const result = Utils.getDestAgentIdForCBT(interaction, '');
+      expect(result).toBe('');
     });
 
-    it('returns empty string when participants is missing or empty', () => {
-      expect(Utils.getDestinationAgentId(undefined as any, currentAgentId)).toBe('');
-      expect(Utils.getDestinationAgentId({} as any, currentAgentId)).toBe('');
+    it('should match only when participant type is dial number and type is Agent', () => {
+      const interaction: any = {
+        participants: {
+          'participant-1': {
+            type: 'Customer',
+            pType: 'dn',
+            dn: '5551234567',
+          },
+          'participant-2': {
+            type: 'Agent',
+            pType: 'Agent',
+            dn: '5551234567',
+          },
+          'participant-3': {
+            type: 'Agent',
+            pType: 'dn',
+            dn: '5551234567',
+            id: 'correct-agent',
+          },
+        },
+      };
+
+      const result = Utils.getDestAgentIdForCBT(interaction, '5551234567');
+      expect(result).toBe('participant-3');
+    });
+
+    it('should handle case-insensitive participant type comparison', () => {
+      const interaction: any = {
+        participants: {
+          'agent-uuid': {
+            type: 'Agent',
+            pType: 'DN', // Uppercase (dial number)
+            dn: '5551234567',
+          },
+        },
+      };
+
+      const result = Utils.getDestAgentIdForCBT(interaction, '5551234567');
+      expect(result).toBe('agent-uuid');
     });
   });
+
+  describe('calculateDestAgentId', () => {
+    const currentAgentId = 'agent-123';
+
+    it('should return destAgentIdCBT when found', () => {
+      const interaction: any = {
+        media: {
+          consult: {
+            mType: 'consult',
+            participants: [currentAgentId, '5551234567'],
+          },
+        },
+        participants: {
+          'agent-uuid-456': {
+            type: 'Agent',
+            pType: 'dn',
+            dn: '5551234567',
+            id: 'agent-uuid-456',
+          },
+        },
+      };
+
+      const result = Utils.calculateDestAgentId(interaction, currentAgentId);
+      expect(result).toBe('agent-uuid-456');
+    });
+
+    it('should return participant id for regular agent when not CBT', () => {
+      const consultedAgentId = 'agent-456';
+      const interaction: any = {
+        media: {
+          consult: {
+            mType: 'consult',
+            participants: [currentAgentId, consultedAgentId],
+          },
+        },
+        participants: {
+          [consultedAgentId]: {
+            type: 'Agent',
+            id: consultedAgentId,
+          },
+        },
+      };
+
+      const result = Utils.calculateDestAgentId(interaction, currentAgentId);
+      expect(result).toBe(consultedAgentId);
+    });
+
+    it('should return epId for EpDn type participants', () => {
+      const consultedAgentId = 'epdn-456';
+      const interaction: any = {
+        media: {
+          consult: {
+            mType: 'consult',
+            participants: [currentAgentId, consultedAgentId],
+          },
+        },
+        participants: {
+          [consultedAgentId]: {
+            type: 'EpDn',
+            id: consultedAgentId,
+            epId: 'entry-point-id-789',
+          },
+        },
+      };
+
+      const result = Utils.calculateDestAgentId(interaction, currentAgentId);
+      expect(result).toBe('entry-point-id-789');
+    });
+
+    it('should return undefined when no consulting agent found', () => {
+      const interaction: any = {
+        media: {
+          mainCall: {
+            mType: 'mainCall',
+            participants: [currentAgentId],
+          },
+        },
+        participants: {},
+      };
+
+      const result = Utils.calculateDestAgentId(interaction, currentAgentId);
+      expect(result).toBeUndefined();
+    });
+
+    it('should handle CBT scenario when phone number is not a direct participant key', () => {
+      const interaction: any = {
+        media: {
+          consult: {
+            mType: 'consult',
+            participants: [currentAgentId, '5551234567'], // Phone number in media
+          },
+        },
+        participants: {
+          // Note: '5551234567' is NOT a key - this is CBT
+          'agent-uuid-cbt': {
+            type: 'Agent',
+            pType: 'dn',
+            dn: '5551234567', // Found by matching DN
+            id: 'agent-uuid-cbt',
+          },
+        },
+      };
+
+      const result = Utils.calculateDestAgentId(interaction, currentAgentId);
+      expect(result).toBe('agent-uuid-cbt'); // Returns the CBT agent
+    });
+  });
+
 });