@webex/contact-center 3.12.0-llmrefactor.13 → 3.12.0-llmrefactor.14

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

@@ -2927,7 +2927,7 @@ describe('TaskManager', () => {
       expect(hydrateHandler).toHaveBeenCalledTimes(1);
     });
 
-    it('reuses a task stored under the incoming main-call media key', () => {
+    it('reuses a task identified by the incoming main-call media key', () => {
       const mainMediaInteractionId = 'main-media-interaction-id';
       const promotedChildId = 'promoted-child-without-main-id';
       const task = installTask(
@@ -2958,6 +2958,41 @@ describe('TaskManager', () => {
       expect(hydrateHandler).toHaveBeenCalledWith(task);
     });
 
+    it('reuses a stale task through its collection key and the incoming main-call media key', () => {
+      const mainMediaInteractionId = 'collection-main-interaction-id';
+      const staleChildId = 'stale-collection-child-id';
+      const promotedChildId = 'promoted-collection-child-id';
+      const staleTaskData = createConferenceTaskData(
+        staleChildId,
+        previousOwnerId,
+        staleChildId
+      );
+      staleTaskData.interaction.media[staleChildId].mType = 'consult';
+      const task = createMockTask(staleTaskData);
+      taskManager.taskCollection = {[mainMediaInteractionId]: task};
+      (taskManager as any).setupTaskListeners(task);
+      const hydrateHandler = jest.fn();
+      taskManager.on(TASK_EVENTS.TASK_HYDRATE, hydrateHandler);
+      const ownerChangeData = createPromotedAgentOwnerChangeData(
+        promotedChildId,
+        mainMediaInteractionId
+      );
+      delete ownerChangeData.interaction.mainInteractionId;
+
+      webSocketManagerMock.emit('message', JSON.stringify({data: ownerChangeData}));
+
+      expectLastStateMachineEvent(task.sendStateMachineEvent, TaskEvent.CONTACT_OWNER_CHANGED);
+      expect(task.data.interactionId).toBe(mainMediaInteractionId);
+      expect(task.data.interaction.owner).toBe(currentAgentId);
+      expect(TaskFactory.createTask).not.toHaveBeenCalled();
+      expect(taskManager.taskCollection[mainMediaInteractionId]).toBe(task);
+      expect(taskManager.taskCollection[staleChildId]).toBeUndefined();
+      expect(taskManager.taskCollection[promotedChildId]).toBeUndefined();
+      expect(Object.values(taskManager.taskCollection)).toEqual([task]);
+      expect(task.listenerCount(TASK_EVENTS.TASK_HYDRATE)).toBe(1);
+      expect(hydrateHandler).toHaveBeenCalledTimes(1);
+    });
+
     it('prefers the exact task for ContactOwnerChanged over related child tasks', () => {
       const exactTask = installTask(createConferenceTaskData(taskId, previousOwnerId));
       const childTaskId = 'related-child-id';
@@ -2980,6 +3015,102 @@ describe('TaskManager', () => {
       expect(childTask.sendStateMachineEvent).not.toHaveBeenCalled();
     });
 
+    it('does not replace a distinct main task when an exact child task also exists', () => {
+      const childTaskId = 'exact-child-id';
+      const mainTask = installTask(createConferenceTaskData(taskId, previousOwnerId));
+      const childTask = createMockTask(
+        createConferenceTaskData(childTaskId, previousOwnerId, taskId)
+      );
+      taskManager.taskCollection[childTaskId] = childTask;
+
+      webSocketManagerMock.emit(
+        'message',
+        JSON.stringify({
+          data: {
+            ...createConferenceTaskData(childTaskId, promotedOwnerId, taskId),
+            type: CC_EVENTS.CONTACT_OWNER_CHANGED,
+          },
+        })
+      );
+
+      expect(childTask.sendStateMachineEvent).not.toHaveBeenCalled();
+      expect(mainTask.sendStateMachineEvent).not.toHaveBeenCalled();
+      expect(taskManager.taskCollection[taskId]).toBe(mainTask);
+      expect(taskManager.taskCollection[childTaskId]).toBe(childTask);
+    });
+
+    it('ignores a related owner change with conflicting explicit main interaction IDs', () => {
+      const childTaskId = 'conflicting-main-child-id';
+      const existingMainId = 'existing-main-id';
+      const incomingMainId = 'incoming-main-id';
+      const sharedParentId = 'shared-parent-id';
+      const taskData = createConferenceTaskData(
+        childTaskId,
+        previousOwnerId,
+        existingMainId
+      );
+      taskData.interaction.parentInteractionId = sharedParentId;
+      const task = installTask(taskData);
+      const ownerChangeData = createConferenceTaskData(
+        'different-child-id',
+        promotedOwnerId,
+        incomingMainId
+      );
+      ownerChangeData.interaction.parentInteractionId = sharedParentId;
+
+      webSocketManagerMock.emit(
+        'message',
+        JSON.stringify({
+          data: {...ownerChangeData, type: CC_EVENTS.CONTACT_OWNER_CHANGED},
+        })
+      );
+
+      expect(task.sendStateMachineEvent).not.toHaveBeenCalled();
+      expect(taskManager.taskCollection[childTaskId]).toBe(task);
+      expect(taskManager.taskCollection[existingMainId]).toBeUndefined();
+      expect(taskManager.taskCollection[incomingMainId]).toBeUndefined();
+      expect(TaskFactory.createTask).not.toHaveBeenCalled();
+    });
+
+    it('does not replace a distinct task already stored at the canonical main key', () => {
+      const childTaskId = 'related-active-child-id';
+      const canonicalMainId = 'occupied-canonical-main-id';
+      const candidate = createMockTask(
+        createConferenceTaskData(childTaskId, previousOwnerId, canonicalMainId)
+      );
+      const occupiedData = createConferenceTaskData(
+        'occupied-task-child-id',
+        previousOwnerId,
+        canonicalMainId
+      );
+      occupiedData.interaction.media[canonicalMainId].mType = 'consult';
+      const occupiedTask = createMockTask(occupiedData);
+      taskManager.taskCollection = {
+        [childTaskId]: candidate,
+        [canonicalMainId]: occupiedTask,
+      };
+
+      webSocketManagerMock.emit(
+        'message',
+        JSON.stringify({
+          data: {
+            ...createConferenceTaskData(
+              'incoming-related-child-id',
+              promotedOwnerId,
+              canonicalMainId
+            ),
+            type: CC_EVENTS.CONTACT_OWNER_CHANGED,
+          },
+        })
+      );
+
+      expect(candidate.sendStateMachineEvent).not.toHaveBeenCalled();
+      expect(occupiedTask.sendStateMachineEvent).not.toHaveBeenCalled();
+      expect(taskManager.taskCollection[childTaskId]).toBe(candidate);
+      expect(taskManager.taskCollection[canonicalMainId]).toBe(occupiedTask);
+      expect(TaskFactory.createTask).not.toHaveBeenCalled();
+    });
+
     it('ignores a related ContactOwnerChanged task whose current agent is consult-only', () => {
       const childTaskId = 'consult-only-child-id';
       const data = createConferenceTaskData(childTaskId, previousOwnerId, taskId);
@@ -3066,7 +3197,43 @@ describe('TaskManager', () => {
       expect(secondTask.sendStateMachineEvent).not.toHaveBeenCalled();
     });
 
-    it('does not recover a new task when multiple stale related tasks become eligible from the payload', () => {
+    it('ignores ambiguous main-call media-key matches without creating a task', () => {
+      const mainMediaInteractionId = 'ambiguous-main-media-id';
+      const createMediaRelatedTask = (interactionId: string) => {
+        const data = createConferenceTaskData(interactionId, previousOwnerId, interactionId);
+        data.interaction.media = {
+          [mainMediaInteractionId]: {
+            mediaResourceId: mainMediaInteractionId,
+            mediaType: 'telephony',
+            mType: 'mainCall',
+            participants: [currentAgentId, previousOwnerId, promotedOwnerId],
+          },
+        };
+
+        return createMockTask(data);
+      };
+      const firstTask = createMediaRelatedTask('first-media-child-id');
+      const secondTask = createMediaRelatedTask('second-media-child-id');
+      taskManager.taskCollection = {
+        'first-media-child-id': firstTask,
+        'second-media-child-id': secondTask,
+      };
+      (TaskFactory.createTask as jest.Mock).mockClear();
+      const ownerChangeData = createPromotedAgentOwnerChangeData(
+        'promoted-media-child-id',
+        mainMediaInteractionId
+      );
+      delete ownerChangeData.interaction.mainInteractionId;
+
+      webSocketManagerMock.emit('message', JSON.stringify({data: ownerChangeData}));
+
+      expect(firstTask.sendStateMachineEvent).not.toHaveBeenCalled();
+      expect(secondTask.sendStateMachineEvent).not.toHaveBeenCalled();
+      expect(TaskFactory.createTask).not.toHaveBeenCalled();
+      expect(Object.values(taskManager.taskCollection)).toEqual([firstTask, secondTask]);
+    });
+
+    it('does not recover a new task when multiple stale related tasks exist', () => {
       const createStaleRelatedTask = (interactionId: string) => {
         const data = createConferenceTaskData(interactionId, previousOwnerId, taskId);
         data.interaction.media[taskId].participants = [previousOwnerId, promotedOwnerId];
@@ -3178,7 +3345,10 @@ describe('TaskManager', () => {
         expect.objectContaining({
           type: TaskEvent.HYDRATE,
           agentId: currentAgentId,
-          taskData: expect.objectContaining({interactionId: taskId}),
+          taskData: expect.objectContaining({
+            interactionId: taskId,
+            interaction: expect.objectContaining({state: 'conference'}),
+          }),
         })
       );
       expect(recoveredTask.sendStateMachineEvent).toHaveBeenNthCalledWith(
@@ -3192,6 +3362,7 @@ describe('TaskManager', () => {
       expect(taskManager.taskCollection['promoted-child-interaction-id']).toBeUndefined();
       expect(Object.values(taskManager.taskCollection)).toEqual([recoveredTask]);
       expect(recoveredTask.data.interaction.owner).toBe(currentAgentId);
+      expect(recoveredTask.listenerCount(TASK_EVENTS.TASK_HYDRATE)).toBe(1);
       expect(hydrateHandler).toHaveBeenCalledTimes(1);
       expect(hydrateHandler).toHaveBeenCalledWith(recoveredTask);
       expect(incomingHandler).not.toHaveBeenCalled();
@@ -3217,6 +3388,21 @@ describe('TaskManager', () => {
           data.interaction.isTerminated = true;
         },
       ],
+      [
+        'the interaction is not telephony',
+        (data) => {
+          data.interaction.mediaType = 'chat';
+        },
+      ],
+      [
+        'the payload has no stable interaction identifier',
+        (data) => {
+          data.interactionId = undefined;
+          data.interaction.interactionId = undefined;
+          delete data.interaction.mainInteractionId;
+          data.interaction.media = {};
+        },
+      ],
     ])('does not create a missing task when %s', (_description, mutatePayload) => {
       clearTasksAndFactoryHistory();
       const ownerChangeData = createPromotedAgentOwnerChangeData();
@@ -3626,6 +3812,15 @@ describe('TaskManager', () => {
       expect(taskManager.taskCollection['task-alias']).toBeUndefined();
     });
 
+    it('disposes wxApp offer observability when removing a task from the collection', () => {
+      const disposeWxAppOfferObservability = jest.fn();
+      task.disposeWxAppOfferObservability = disposeWxAppOfferObservability;
+
+      (taskManager as any).removeTaskFromCollection(task);
+
+      expect(disposeWxAppOfferObservability).toHaveBeenCalledTimes(1);
+    });
+
     it('replaces an EP-DN child task with a hydrated main task on CONTACT_MERGED', () => {
       const childTaskId = 'ep-dn-child-interaction-id';
       const childTask = createMockTask({
@@ -4186,4 +4381,20 @@ describe('TaskManager', () => {
       expect(taskTwo.applyWxAppMuteStateFromSync).toHaveBeenCalledWith('call-1', true);
     });
   });
+
+  describe('refreshWxAppOfferObservabilityForAllTasks', () => {
+    it('invokes refresh on collected tasks that implement it', () => {
+      const taskOne = {refreshWxAppOfferObservability: jest.fn()};
+      const taskTwo = {};
+
+      taskManager['taskCollection'] = {
+        [taskId]: taskOne,
+        'task-2': taskTwo,
+      };
+
+      taskManager.refreshWxAppOfferObservabilityForAllTasks();
+
+      expect(taskOne.refreshWxAppOfferObservability).toHaveBeenCalledTimes(1);
+    });
+  });
 });

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

@@ -539,6 +539,39 @@ describe('Task state machine', () => {
         } as any,
       });
 
+    it('hydrates a recovered active conference from IDLE to CONFERENCING', () => {
+      const service = startMachine();
+      const taskData = createTaskData({
+        agentId: 'agent-1',
+        interactionId: 'interaction-1',
+        mediaResourceId: 'interaction-1',
+        interaction: {
+          state: 'conference',
+          interactionId: 'interaction-1',
+          mainInteractionId: 'interaction-1',
+          owner: 'agent-1',
+          participants: {
+            'agent-1': {id: 'agent-1', pType: 'Agent', hasLeft: false},
+            'agent-2': {id: 'agent-2', pType: 'Agent', hasLeft: false},
+            'customer-1': {id: 'customer-1', pType: 'Customer', hasLeft: false},
+          },
+          media: {
+            'interaction-1': {
+              mediaResourceId: 'interaction-1',
+              mType: 'mainCall',
+              participants: ['agent-1', 'agent-2', 'customer-1'],
+              isHold: false,
+            },
+          },
+        } as any,
+      });
+
+      service.send({type: TaskEvent.HYDRATE, taskData});
+
+      expect(service.getSnapshot().value).toBe(TaskState.CONFERENCING);
+      expect(service.getSnapshot().context.taskData).toEqual(taskData);
+    });
+
     it('boots from IDLE to CONSULTING on CONSULTING_ACTIVE for split-leg ordering', () => {
       const service = startMachine();
       const taskData = createTaskData({

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

@@ -1006,69 +1006,28 @@ describe('Voice Task', () => {
     });
   });
 
-  describe('wxApp offer decision logging', () => {
-    const wxAppParticipant = {
-      deviceType: 'wxApp',
-      deviceId: 'device-id-1',
-      deviceCallId: 'call-id-1',
-    };
-
-    const makeWxAppOfferTaskData = () =>
-      createBaseData({
-        agentId: 'agent-1',
-        interaction: {
-          participants: {
-            'agent-1': {id: 'agent-1', ...wxAppParticipant},
-          },
-        } as any,
-      });
-
-    it('logs evolving accept reasons through the normal wxApp accept flow', () => {
-      const logSpy = jest.spyOn(wxAppDiagnosticLogging, 'logWxAppOfferDecision');
-      const taskData = makeWxAppOfferTaskData();
-      const voice = new Voice(dummyContact, taskData, {enableWxBetterTogether: true});
-
-      voice.stateMachineService?.send({type: TaskEvent.TASK_INCOMING, taskData});
-
-      expect(logSpy).toHaveBeenCalledWith(
-        expect.objectContaining({acceptReason: 'wxApp_offer_ready'})
-      );
-
-      logSpy.mockClear();
-      voice['setWxAppAcceptInFlight'](true);
-
-      expect(logSpy).toHaveBeenCalledWith(
-        expect.objectContaining({acceptReason: 'wxApp_accept_in_flight'})
-      );
-
-      logSpy.mockClear();
-      voice['setWxAppAcceptInFlight'](false);
-      voice['setWxAppAnswerPending'](true);
-
-      expect(logSpy).toHaveBeenCalledWith(
-        expect.objectContaining({acceptReason: 'wxApp_answer_pending'})
-      );
-    });
-
-    it('logs browser_webrtc_offer when voice variant is WebRTC on a non-wxApp inbound offer', () => {
+  describe('wxApp offer observability integration', () => {
+    it('delegates OFFERED ui control updates to wxApp offer observability', () => {
       const logSpy = jest.spyOn(wxAppDiagnosticLogging, 'logWxAppOfferDecision');
       const taskData = createBaseData({
         agentId: 'agent-1',
         interaction: {
           participants: {
-            'agent-1': {id: 'agent-1', deviceType: 'phone', deviceId: 'device-id-1'},
+            'agent-1': {
+              id: 'agent-1',
+              deviceType: 'wxApp',
+              deviceId: 'device-id-1',
+              deviceCallId: 'call-id-1',
+            },
           },
         } as any,
       });
-      const voice = new Voice(dummyContact, taskData, {
-        enableWxBetterTogether: true,
-        voiceVariant: VOICE_VARIANT.WEBRTC,
-      });
+      const voice = new Voice(dummyContact, taskData, {enableWxBetterTogether: true});
 
       voice.stateMachineService?.send({type: TaskEvent.TASK_INCOMING, taskData});
 
       expect(logSpy).toHaveBeenCalledWith(
-        expect.objectContaining({acceptReason: 'browser_webrtc_offer'})
+        expect.objectContaining({acceptReason: 'wxApp_offer_ready'})
       );
     });
   });