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

package/test/unit/spec/services/ApiAiAssistant.ts

@@ -2,7 +2,12 @@ import ApiAIAssistant from '../../../../src/services/ApiAiAssistant';
 import MetricsManager from '../../../../src/metrics/MetricsManager';
 import LoggerProxy from '../../../../src/logger-proxy';
 import WebexRequest from '../../../../src/services/core/WebexRequest';
-import {HTTP_METHODS, RealTimeAssistanceUserActionId, WebexSDK} from '../../../../src/types';
+import {
+  HTTP_METHODS,
+  RealTimeAssistanceUserActionId,
+  WELLNESS_BREAK_USER_ACTIONS,
+  WebexSDK,
+} from '../../../../src/types';
 
 jest.mock('../../../../src/metrics/MetricsManager');
 jest.mock('../../../../src/logger-proxy');
@@ -11,6 +16,11 @@ describe('ApiAIAssistant', () => {
   let apiAIAssistant: ApiAIAssistant;
   let mockWebex: WebexSDK;
   let mockMetricsManager: jest.Mocked<MetricsManager>;
+  let wellnessContext: {
+    isWellnessBreakEnabled: boolean;
+    agentId?: string;
+    agentSessionId?: string;
+  };
 
   beforeEach(() => {
     jest.clearAllMocks();
@@ -43,7 +53,8 @@ describe('ApiAIAssistant', () => {
     } as unknown as jest.Mocked<MetricsManager>;
     (MetricsManager.getInstance as jest.Mock).mockReturnValue(mockMetricsManager);
 
-    apiAIAssistant = new ApiAIAssistant(mockWebex);
+    wellnessContext = {isWellnessBreakEnabled: false};
+    apiAIAssistant = new ApiAIAssistant(mockWebex, () => wellnessContext);
   });
 
   it('should send transcript start event successfully', async () => {
@@ -270,4 +281,125 @@ describe('ApiAIAssistant', () => {
 
     expect(errorMessage).toBe('Error while performing sendRealTimeAssistanceUserAction');
   });
+
+  describe('Agent Wellness Break actions', () => {
+    beforeEach(() => {
+      wellnessContext = {
+        isWellnessBreakEnabled: true,
+        agentId: 'test-agent-id',
+        agentSessionId: 'session-1',
+      };
+    });
+
+    it('does not expose wellness context mutation on the public assistant instance', () => {
+      expect(apiAIAssistant).not.toHaveProperty('setWellnessContext');
+    });
+
+    it('sends the exact REQUESTED body and resolves only for HTTP 202', async () => {
+      jest.spyOn(Date, 'now').mockReturnValue(1787640000000);
+      (mockWebex.request as jest.Mock).mockResolvedValue({statusCode: 202});
+
+      await expect(apiAIAssistant.requestWellnessBreak()).resolves.toBeUndefined();
+
+      expect(mockWebex.request).toHaveBeenCalledWith({
+        uri: 'https://api-ai-assistant.produs1.ciscoccservice.com/event',
+        method: HTTP_METHODS.POST,
+        addAuthHeader: true,
+        body: {
+          agentId: 'test-agent-id',
+          orgId: 'test-org-id',
+          eventType: 'CUSTOM_EVENT',
+          eventName: 'WellnessBreakAction',
+          eventDetails: {
+            data: {
+              action: 'REQUESTED',
+              agentSessionId: 'session-1',
+              actionTimeStamp: 1787640000000,
+            },
+          },
+        },
+      });
+    });
+
+    it.each([
+      WELLNESS_BREAK_USER_ACTIONS.ACCEPTED,
+      WELLNESS_BREAK_USER_ACTIONS.REJECTED,
+      WELLNESS_BREAK_USER_ACTIONS.NO_RESPONSE,
+    ] as const)(
+      'sends the %s offer action',
+      async (action) => {
+        (mockWebex.request as jest.Mock).mockResolvedValue({statusCode: 202});
+
+        await apiAIAssistant.respondToWellnessBreak({action});
+
+        expect(
+          (mockWebex.request as jest.Mock).mock.calls[0][0].body.eventDetails.data.action
+        ).toBe(action);
+      }
+    );
+
+    it('rejects disabled or incomplete internal session context before HTTP', async () => {
+      wellnessContext = {
+        isWellnessBreakEnabled: false,
+        agentId: 'test-agent-id',
+        agentSessionId: 'session-1',
+      };
+      await expect(apiAIAssistant.requestWellnessBreak()).rejects.toThrow(
+        'WELLNESS_BREAK_NOT_ENABLED'
+      );
+
+      wellnessContext = {
+        isWellnessBreakEnabled: true,
+      };
+      await expect(apiAIAssistant.requestWellnessBreak()).rejects.toThrow(
+        'WELLNESS_BREAK_AGENT_ID_REQUIRED'
+      );
+
+      wellnessContext = {
+        isWellnessBreakEnabled: true,
+        agentId: 'test-agent-id',
+      };
+      await expect(apiAIAssistant.requestWellnessBreak()).rejects.toThrow(
+        'WELLNESS_BREAK_AGENT_SESSION_REQUIRED'
+      );
+      expect(mockWebex.request).not.toHaveBeenCalled();
+    });
+
+    it('rejects a missing organization before HTTP', async () => {
+      (mockWebex.credentials.getOrgId as jest.Mock).mockReturnValue('   ');
+
+      await expect(apiAIAssistant.requestWellnessBreak()).rejects.toThrow(
+        'WELLNESS_BREAK_ORG_ID_REQUIRED'
+      );
+      expect(mockWebex.request).not.toHaveBeenCalled();
+    });
+
+    it.each([200, 204, 400, 401, 403, 404, 409, 429, 500])(
+      'rejects the non-202 HTTP status %i',
+      async (statusCode) => {
+        (mockWebex.request as jest.Mock).mockResolvedValue({statusCode});
+
+        await expect(apiAIAssistant.requestWellnessBreak()).rejects.toThrow(
+          `WELLNESS_BREAK_ACTION_UNEXPECTED_STATUS_${statusCode}`
+        );
+      }
+    );
+
+    it('rejects network failures through the structured error path', async () => {
+      (mockWebex.request as jest.Mock).mockRejectedValue(new Error('Network unavailable'));
+
+      await expect(apiAIAssistant.requestWellnessBreak()).rejects.toThrow(
+        'Error while performing requestWellnessBreak'
+      );
+    });
+
+    it('rejects unsupported offer actions before HTTP', async () => {
+      await expect(
+        apiAIAssistant.respondToWellnessBreak({
+          action: 'REQUESTED',
+        } as unknown as Parameters<ApiAIAssistant['respondToWellnessBreak']>[0])
+      ).rejects.toThrow('WELLNESS_BREAK_ACTION_INVALID');
+      expect(mockWebex.request).not.toHaveBeenCalled();
+    });
+  });
 });

package/test/unit/spec/services/WebexCrossClientService.ts

@@ -160,11 +160,53 @@ describe('WebexCrossClientService', () => {
 
     expect(trackEvent).toHaveBeenCalledWith(
       METRIC_EVENT_NAMES.WXAPP_USERSUB_PUBLISH_FAILED,
-      expect.objectContaining({enableWxBetterTogether: true}),
+      expect.objectContaining({enableWxBetterTogether: true, usersubPublished: false}),
       ['operational', 'behavioral']
     );
   });
 
+  it('reports retained usersub state when disable publish fails after successful enable', async () => {
+    await service.setManageWebexCallingInWxcc(true, {trackPublishMetrics: true});
+    trackEvent.mockClear();
+
+    webex.request = jest.fn().mockRejectedValue(new Error('disable failed'));
+
+    await expect(
+      service.setManageWebexCallingInWxcc(false, {trackPublishMetrics: true})
+    ).rejects.toThrow('disable failed');
+
+    expect(trackEvent).toHaveBeenCalledWith(
+      METRIC_EVENT_NAMES.WXAPP_USERSUB_PUBLISH_FAILED,
+      expect.objectContaining({
+        enableWxBetterTogether: false,
+        usersubPublished: true,
+      }),
+      ['operational', 'behavioral']
+    );
+    expect(service.isAnswerCallsStateActive()).toBe(true);
+  });
+
+  it('reports retained usersub state when re-enable publish fails after successful enable', async () => {
+    await service.setManageWebexCallingInWxcc(true);
+    trackEvent.mockClear();
+
+    webex.request = jest.fn().mockRejectedValue(new Error('refresh failed'));
+
+    await expect(
+      service.setManageWebexCallingInWxcc(true, {trackPublishMetrics: true})
+    ).rejects.toThrow('refresh failed');
+
+    expect(trackEvent).toHaveBeenCalledWith(
+      METRIC_EVENT_NAMES.WXAPP_USERSUB_PUBLISH_FAILED,
+      expect.objectContaining({
+        enableWxBetterTogether: true,
+        usersubPublished: true,
+      }),
+      ['operational', 'behavioral']
+    );
+    expect(service.isAnswerCallsStateActive()).toBe(true);
+  });
+
   it('tracks usersub publish success when trackPublishMetrics is enabled', async () => {
     await service.setManageWebexCallingInWxcc(true, {trackPublishMetrics: true});
 
@@ -174,7 +216,7 @@ describe('WebexCrossClientService', () => {
     ]);
     expect(trackEvent).toHaveBeenCalledWith(
       METRIC_EVENT_NAMES.WXAPP_USERSUB_PUBLISH_SUCCESS,
-      {enableWxBetterTogether: true},
+      {enableWxBetterTogether: true, usersubPublished: true},
       ['operational', 'behavioral']
     );
   });
@@ -243,7 +285,7 @@ describe('WebexCrossClientService', () => {
     expect(cancelTimedEvent).not.toHaveBeenCalled();
     expect(trackEvent).toHaveBeenCalledWith(
       METRIC_EVENT_NAMES.WXAPP_USERSUB_PUBLISH_SUCCESS,
-      {enableWxBetterTogether: false},
+      {enableWxBetterTogether: false, usersubPublished: false},
       ['operational', 'behavioral']
     );
   });

package/test/unit/spec/services/WxAppTelephonyMercurySync.ts

@@ -42,7 +42,7 @@ describe('WxAppTelephonyMercurySync', () => {
     expect(sync.isSubscribed()).toBe(true);
     expect(trackEvent).toHaveBeenCalledWith(
       METRIC_EVENT_NAMES.WXAPP_MERCURY_SUBSCRIBE_SUCCESS,
-      {},
+      {mercurySubscribed: true},
       ['operational', 'behavioral']
     );
   });

package/test/unit/spec/services/config/Util.ts

@@ -82,4 +82,48 @@ describe('parseAgentConfigs collaboration access fields', () => {
     expect(profile.accessEntryPoint).toBe('NONE');
     expect(profile.accessBuddyTeam).toBe('ALL');
   });
+
+  it('enables wellness only when organization config, reminders, and license are present', () => {
+    const profile = parseAgentConfigs({
+      ...baseProfileData,
+      orgSettingsData: {...baseProfileData.orgSettingsData, aiAssistantQuantity: 1},
+      aiFeatureFlags: {
+        data: [
+          {
+            id: 'ai-feature-1',
+            agentWellbeing: {
+              enable: true,
+              wellnessBreakReminders: 'ENABLED',
+            },
+          },
+        ],
+      },
+    });
+
+    expect(profile.isWellnessBreakEnabled).toBe(true);
+  });
+
+  it.each([
+    {quantity: 0, enable: true, reminders: 'ENABLED'},
+    {quantity: 1, enable: false, reminders: 'ENABLED'},
+    {quantity: 1, enable: true, reminders: 'DISABLED'},
+  ] as const)(
+    'disables wellness when an effective gate is missing',
+    ({quantity, enable, reminders}) => {
+      const profile = parseAgentConfigs({
+        ...baseProfileData,
+        orgSettingsData: {...baseProfileData.orgSettingsData, aiAssistantQuantity: quantity},
+        aiFeatureFlags: {
+          data: [
+            {
+              id: 'ai-feature-1',
+              agentWellbeing: {enable, wellnessBreakReminders: reminders},
+            },
+          ],
+        },
+      });
+
+      expect(profile.isWellnessBreakEnabled).toBe(false);
+    }
+  );
 });

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

@@ -705,6 +705,74 @@ describe('AgentConfigService', () => {
     });
   });
 
+  describe('getWellbeingBreakIdleCode', () => {
+    it('uses the system-code query and finds the exact code across pages', async () => {
+      (mockWebexRequest.request as jest.Mock)
+        .mockResolvedValueOnce({
+          statusCode: 200,
+          body: {
+            data: [
+              {id: 'other', name: 'Other', active: true, isSystemCode: true, defaultCode: false},
+            ],
+            meta: {totalPages: 2},
+          },
+        })
+        .mockResolvedValueOnce({
+          statusCode: 200,
+          body: {
+            data: [
+              {
+                id: 'wellbeing-code',
+                name: 'WellbeingBreak',
+                active: true,
+                isSystemCode: true,
+                defaultCode: false,
+              },
+            ],
+            meta: {totalPages: 2},
+          },
+        });
+
+      await expect(agentConfigService.getWellbeingBreakIdleCode(mockOrgId)).resolves.toEqual({
+        id: 'wellbeing-code',
+        name: 'WellbeingBreak',
+        isSystem: true,
+        isDefault: false,
+      });
+      expect(mockWebexRequest.request).toHaveBeenNthCalledWith(1, {
+        service: mockWccAPIURL,
+        resource:
+          `organization/${mockOrgId}/v2/auxiliary-code?page=0&pageSize=100` +
+          '&workType=IDLE_CODE&customFilter=isSystemCode==true&desktopProfileFilter=false',
+        method: 'GET',
+      });
+      expect(mockWebexRequest.request).toHaveBeenNthCalledWith(2, {
+        service: mockWccAPIURL,
+        resource:
+          `organization/${mockOrgId}/v2/auxiliary-code?page=1&pageSize=100` +
+          '&workType=IDLE_CODE&customFilter=isSystemCode==true&desktopProfileFilter=false',
+        method: 'GET',
+      });
+    });
+
+    it('rejects when the exact system code is unavailable', async () => {
+      (mockWebexRequest.request as jest.Mock).mockResolvedValue({
+        statusCode: 200,
+        body: {
+          data: [
+            {id: 'inactive', name: 'WellbeingBreak', active: false, isSystemCode: true},
+            {id: 'lookalike', name: 'wellbeingbreak', active: true, isSystemCode: true},
+          ],
+          meta: {totalPages: 1},
+        },
+      });
+
+      await expect(agentConfigService.getWellbeingBreakIdleCode(mockOrgId)).rejects.toThrow(
+        'WELLBEING_BREAK_IDLE_CODE_NOT_FOUND'
+      );
+    });
+  });
+
   describe('getAgentConfig', () => {
     const mockTeamData = [
       {id: 'team1', name: 'Support Team'},

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({