@webex/contact-center 3.10.0-next.9 → 3.10.0-wxc-disconnect.1

package/src/services/task/types.ts

@@ -490,30 +490,6 @@ 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',
 }
 
 /**
@@ -757,8 +733,6 @@ export type TaskData = {
   isConsulted?: boolean;
   /** Indicates if the task is in conference state */
   isConferencing: boolean;
-  /** Indicates if a conference is currently in progress (2+ active agents) */
-  isConferenceInProgress?: boolean;
   /** Identifier of agent who last updated the task */
   updatedBy?: string;
   /** Type of destination for transfer/consult */
@@ -781,8 +755,6 @@ 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;
 };
@@ -1031,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
@@ -1150,16 +1135,16 @@ export interface ITask extends EventEmitter {
   autoWrapup?: AutoWrapup;
 
   /**
-   * Cancels the auto-wrapup timer for the task.
-   * This method stops the auto-wrapup process if it is currently active.
+   * cancels the auto-wrapup timer for the task
+   * This method stops the auto-wrapup process if it is currently active
    * Note: This is supported only in single session mode. Not supported in multi-session mode.
    * @returns void
    */
   cancelAutoWrapupTimer(): void;
 
   /**
-   * Deregisters all web call event listeners.
-   * Used when cleaning up task resources.
+   * Deregisters all web call event listeners
+   * Used when cleaning up task resources
    * @ignore
    */
   unregisterWebCallListeners(): void;
@@ -1179,7 +1164,7 @@ export interface ITask extends EventEmitter {
    * @returns Promise<TaskResponse>
    * @example
    * ```typescript
-   * await task.accept();
+   * task.accept();
    * ```
    */
   accept(): Promise<TaskResponse>;
@@ -1189,58 +1174,48 @@ export interface ITask extends EventEmitter {
    * @returns Promise<TaskResponse>
    * @example
    * ```typescript
-   * await task.decline();
+   * task.decline();
    * ```
    */
   decline(): Promise<TaskResponse>;
 
   /**
-   * Places the current task on hold.
-   * @param mediaResourceId - Optional media resource ID to use for the hold operation. If not provided, uses the task's current mediaResourceId
+   * Places the current task on hold
    * @returns Promise<TaskResponse>
    * @example
    * ```typescript
-   * // Hold with default mediaResourceId
-   * await task.hold();
-   *
-   * // Hold with custom mediaResourceId
-   * await task.hold('custom-media-resource-id');
+   * task.hold();
    * ```
    */
-  hold(mediaResourceId?: string): Promise<TaskResponse>;
+  hold(): Promise<TaskResponse>;
 
   /**
-   * Resumes a task that was previously on hold.
-   * @param mediaResourceId - Optional media resource ID to use for the resume operation. If not provided, uses the task's current mediaResourceId from interaction media
+   * Resumes a task that was previously on hold
    * @returns Promise<TaskResponse>
    * @example
    * ```typescript
-   * // Resume with default mediaResourceId
-   * await task.resume();
-   *
-   * // Resume with custom mediaResourceId
-   * await task.resume('custom-media-resource-id');
+   * task.resume();
    * ```
    */
-  resume(mediaResourceId?: string): Promise<TaskResponse>;
+  resume(): Promise<TaskResponse>;
 
   /**
-   * Ends/terminates the current task.
+   * Ends/terminates the current task
    * @returns Promise<TaskResponse>
    * @example
    * ```typescript
-   * await task.end();
+   * task.end();
    * ```
    */
   end(): Promise<TaskResponse>;
 
   /**
-   * Initiates wrap-up process for the task with specified details.
+   * Initiates wrap-up process for the task with specified details
    * @param wrapupPayload - Wrap-up details including reason and auxiliary code
    * @returns Promise<TaskResponse>
    * @example
    * ```typescript
-   * await task.wrapup({
+   * task.wrapup({
    *   wrapUpReason: "Customer issue resolved",
    *   auxCodeId: "RESOLVED"
    * });
@@ -1249,109 +1224,25 @@ export interface ITask extends EventEmitter {
   wrapup(wrapupPayload: WrapupPayLoad): Promise<TaskResponse>;
 
   /**
-   * Pauses the recording for current task.
+   * Pauses the recording for current task
    * @returns Promise<TaskResponse>
    * @example
    * ```typescript
-   * await task.pauseRecording();
+   * task.pauseRecording();
    * ```
    */
   pauseRecording(): Promise<TaskResponse>;
 
   /**
-   * Resumes a previously paused recording.
+   * Resumes a previously paused recording
    * @param resumeRecordingPayload - Parameters for resuming the recording
    * @returns Promise<TaskResponse>
    * @example
    * ```typescript
-   * await task.resumeRecording({
+   * task.resumeRecording({
    *   autoResumed: false
    * });
    * ```
    */
   resumeRecording(resumeRecordingPayload: ResumeRecordingPayload): Promise<TaskResponse>;
-
-  /**
-   * Initiates a consultation with another agent or queue.
-   * @param consultPayload - Consultation details including destination and type
-   * @returns Promise<TaskResponse>
-   * @example
-   * ```typescript
-   * await task.consult({ to: "agentId", destinationType: "agent" });
-   * ```
-   */
-  consult(consultPayload: ConsultPayload): Promise<TaskResponse>;
-
-  /**
-   * Ends an ongoing consultation.
-   * @param consultEndPayload - Details for ending the consultation
-   * @returns Promise<TaskResponse>
-   * @example
-   * ```typescript
-   * await task.endConsult({ isConsult: true, taskId: "taskId" });
-   * ```
-   */
-  endConsult(consultEndPayload: ConsultEndPayload): Promise<TaskResponse>;
-
-  /**
-   * Transfers the task to another agent or queue.
-   * @param transferPayload - Transfer details including destination and type
-   * @returns Promise<TaskResponse>
-   * @example
-   * ```typescript
-   * await task.transfer({ to: "queueId", destinationType: "queue" });
-   * ```
-   */
-  transfer(transferPayload: TransferPayLoad): Promise<TaskResponse>;
-
-  /**
-   * Transfers the task after consultation.
-   * @param consultTransferPayload - Details for consult transfer (optional)
-   * @returns Promise<TaskResponse>
-   * @example
-   * ```typescript
-   * await task.consultTransfer({ to: "agentId", destinationType: "agent" });
-   * ```
-   */
-  consultTransfer(consultTransferPayload?: ConsultTransferPayLoad): Promise<TaskResponse>;
-
-  /**
-   * Initiates a consult conference (merge consult call with main call).
-   * @returns Promise<TaskResponse>
-   * @example
-   * ```typescript
-   * await task.consultConference();
-   * ```
-   */
-  consultConference(): Promise<TaskResponse>;
-
-  /**
-   * Exits from an ongoing conference.
-   * @returns Promise<TaskResponse>
-   * @example
-   * ```typescript
-   * await task.exitConference();
-   * ```
-   */
-  exitConference(): Promise<TaskResponse>;
-
-  /**
-   * Transfers the conference to another participant.
-   * @returns Promise<TaskResponse>
-   * @example
-   * ```typescript
-   * await task.transferConference();
-   * ```
-   */
-  transferConference(): Promise<TaskResponse>;
-
-  /**
-   * Toggles mute/unmute for the local audio stream during a WebRTC task.
-   * @returns Promise<void>
-   * @example
-   * ```typescript
-   * await task.toggleMute();
-   * ```
-   */
-  toggleMute(): Promise<void>;
 }

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

@@ -229,7 +229,7 @@ describe('Utils', () => {
       });
     });
 
-    it('should return DUPLICATE_LOCATION message and fieldName for dial number', () => {
+    it('should return DUPLICATE_LOCATION message and fieldName for DN number', () => {
       const failure = {data: {reason: 'DUPLICATE_LOCATION'}} as Failure;
       const result = Utils.getStationLoginErrorData(failure, LoginOption.AGENT_DN);
       expect(result).toEqual({
@@ -277,284 +277,53 @@ describe('Utils', () => {
     });
   });
 
-  describe('getConsultedAgentId', () => {
-    const currentAgentId = 'agent-123';
+  describe('getDestinationAgentId', () => {
+    const currentAgentId = 'agent-current-123';
 
-    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'],
-        },
+    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},
       };
 
-      const result = Utils.getConsultedAgentId(media, currentAgentId);
-      expect(result).toBe('');
+      const result = Utils.getDestinationAgentId(participants, currentAgentId);
+      expect(result).toBe('agent-1');
     });
 
-    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'],
-        },
+    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},
       };
 
-      const result = Utils.getConsultedAgentId(media, currentAgentId);
-      expect(result).toBe('');
-    });
-
-    it('should handle empty media object', () => {
-      const result = Utils.getConsultedAgentId({}, currentAgentId);
+      const result = Utils.getDestinationAgentId(participants, currentAgentId);
       expect(result).toBe('');
     });
 
-    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',
-          },
-        },
+    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},
       };
-      const consultingAgent = 'agent-123'; // Exists as key in participants
-
-      const result = Utils.getDestAgentIdForCBT(interaction, consultingAgent);
-      expect(result).toBe('');
-    });
+      expect(Utils.getDestinationAgentId(participantsDN, currentAgentId)).toBe('dn-1');
 
-    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',
-          },
-        },
+      const participantsEpDn: any = {
+        [currentAgentId]: {type: 'Agent', id: currentAgentId, isWrapUp: false},
+        epdn1: {type: 'EpDn', id: 'epdn-1', isWrapUp: false},
       };
-      const consultingAgent = '5551234567'; // Different number
-
-      const result = Utils.getDestAgentIdForCBT(interaction, consultingAgent);
-      expect(result).toBe('');
-    });
+      expect(Utils.getDestinationAgentId(participantsEpDn, currentAgentId)).toBe('epdn-1');
 
-    it('should return empty string when consultingAgent is empty', () => {
-      const interaction: any = {
-        participants: {
-          'agent-uuid-123': {
-            type: 'Agent',
-            pType: 'dn',
-            dn: '5551234567',
-          },
-        },
+      const participantsEntry: any = {
+        [currentAgentId]: {type: 'Agent', id: currentAgentId, isWrapUp: false},
+        entry1: {type: 'entryPoint', id: 'entry-1', isWrapUp: false},
       };
-
-      const result = Utils.getDestAgentIdForCBT(interaction, '');
-      expect(result).toBe('');
+      expect(Utils.getDestinationAgentId(participantsEntry, currentAgentId)).toBe('entry-1');
     });
 
-    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');
+    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('');
     });
   });
-
-  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
-    });
-  });
-
 });