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

package/test/unit/spec/cc.ts

@@ -139,6 +139,8 @@ describe('webex.cc', () => {
       dialer: {
         startOutdial: jest.fn(),
         acceptPreviewContact: jest.fn(),
+        skipPreviewContact: jest.fn(),
+        removePreviewContact: jest.fn(),
       },
       apiAIAssistant: {
         sendEvent: jest.fn(),
@@ -2320,4 +2322,132 @@ describe('webex.cc', () => {
       expect(getErrorDetailsSpy).toHaveBeenCalledWith(error, 'acceptPreviewContact', CC_FILE);
     });
   });
+
+  describe('skipPreviewContact', () => {
+    const previewPayload = {
+      interactionId: 'interaction-123',
+      campaignId: 'campaign-456',
+    };
+
+    it('should skip preview contact successfully', async () => {
+      const mockResponse = {trackingId: 'track-123'} as AgentContact;
+
+      const skipPreviewContactMock = jest
+        .spyOn(webex.cc.services.dialer, 'skipPreviewContact')
+        .mockResolvedValue(mockResponse);
+
+      const result = await webex.cc.skipPreviewContact(previewPayload);
+
+      expect(LoggerProxy.info).toHaveBeenCalledWith('Skipping campaign preview contact', {
+        module: CC_FILE,
+        method: 'skipPreviewContact',
+      });
+      expect(LoggerProxy.log).toHaveBeenCalledWith(
+        'Campaign preview contact skipped successfully',
+        {
+          module: CC_FILE,
+          method: 'skipPreviewContact',
+          trackingId: 'track-123',
+          interactionId: previewPayload.interactionId,
+        }
+      );
+
+      expect(skipPreviewContactMock).toHaveBeenCalledWith({data: previewPayload});
+      expect(result).toEqual(mockResponse);
+    });
+
+    it('should handle error during skipPreviewContact', async () => {
+      getErrorDetailsSpy.mockRestore();
+      getErrorDetailsSpy = jest.spyOn(Utils, 'getErrorDetails');
+
+      const error = {
+        details: {
+          trackingId: '1234',
+          data: {
+            reason: 'Error while performing skipPreviewContact',
+          },
+        },
+      };
+
+      jest.spyOn(webex.cc.services.dialer, 'skipPreviewContact').mockRejectedValue(error);
+
+      await expect(webex.cc.skipPreviewContact(previewPayload)).rejects.toThrow(
+        error.details.data.reason
+      );
+
+      expect(LoggerProxy.info).toHaveBeenCalledWith('Skipping campaign preview contact', {
+        module: CC_FILE,
+        method: 'skipPreviewContact',
+      });
+      expect(LoggerProxy.error).toHaveBeenCalledWith(
+        `skipPreviewContact failed with reason: ${error.details.data.reason}`,
+        {module: CC_FILE, method: 'skipPreviewContact', trackingId: error.details.trackingId}
+      );
+      expect(getErrorDetailsSpy).toHaveBeenCalledWith(error, 'skipPreviewContact', CC_FILE);
+    });
+  });
+
+  describe('removePreviewContact', () => {
+    const previewPayload = {
+      interactionId: 'interaction-123',
+      campaignId: 'campaign-456',
+    };
+
+    it('should remove preview contact successfully', async () => {
+      const mockResponse = {trackingId: 'track-123'} as AgentContact;
+
+      const removePreviewContactMock = jest
+        .spyOn(webex.cc.services.dialer, 'removePreviewContact')
+        .mockResolvedValue(mockResponse);
+
+      const result = await webex.cc.removePreviewContact(previewPayload);
+
+      expect(LoggerProxy.info).toHaveBeenCalledWith('Removing campaign preview contact', {
+        module: CC_FILE,
+        method: 'removePreviewContact',
+      });
+      expect(LoggerProxy.log).toHaveBeenCalledWith(
+        'Campaign preview contact removed successfully',
+        {
+          module: CC_FILE,
+          method: 'removePreviewContact',
+          trackingId: 'track-123',
+          interactionId: previewPayload.interactionId,
+        }
+      );
+
+      expect(removePreviewContactMock).toHaveBeenCalledWith({data: previewPayload});
+      expect(result).toEqual(mockResponse);
+    });
+
+    it('should handle error during removePreviewContact', async () => {
+      getErrorDetailsSpy.mockRestore();
+      getErrorDetailsSpy = jest.spyOn(Utils, 'getErrorDetails');
+
+      const error = {
+        details: {
+          trackingId: '1234',
+          data: {
+            reason: 'Error while performing removePreviewContact',
+          },
+        },
+      };
+
+      jest.spyOn(webex.cc.services.dialer, 'removePreviewContact').mockRejectedValue(error);
+
+      await expect(webex.cc.removePreviewContact(previewPayload)).rejects.toThrow(
+        error.details.data.reason
+      );
+
+      expect(LoggerProxy.info).toHaveBeenCalledWith('Removing campaign preview contact', {
+        module: CC_FILE,
+        method: 'removePreviewContact',
+      });
+      expect(LoggerProxy.error).toHaveBeenCalledWith(
+        `removePreviewContact failed with reason: ${error.details.data.reason}`,
+        {module: CC_FILE, method: 'removePreviewContact', trackingId: error.details.trackingId}
+      );
+      expect(getErrorDetailsSpy).toHaveBeenCalledWith(error, 'removePreviewContact', CC_FILE);
+    });
+  });
 });

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

@@ -263,7 +263,7 @@ describe('AgentConfigService', () => {
 
       expect(mockWebexRequest.request).toHaveBeenCalledWith({
         service: mockWccAPIURL,
-        resource: `organization/${mockOrgId}/v2/auxiliary-code?page=${page}&pageSize=${pageSize}&filter=id=in=(${filter})&attributes=${attributes}`,
+        resource: `organization/${mockOrgId}/v2/auxiliary-code?page=${page}&pageSize=${pageSize}&filter=id=in=(${filter})&attributes=${attributes}&desktopProfileFilter=true`,
         method: 'GET',
       });
       expect(result).toEqual(mockResponse.body);

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

@@ -84,7 +84,12 @@ describe('TaskManager', () => {
     onSpy = jest.spyOn(webCallingService, 'on');
     offSpy = jest.spyOn(webCallingService, 'off');
 
-    taskManager = new TaskManager(mockApiAIAssistant, contactMock, webCallingService, webSocketManagerMock);
+    taskManager = new TaskManager(
+      mockApiAIAssistant,
+      contactMock,
+      webCallingService,
+      webSocketManagerMock
+    );
     const taskMock = {
       emit: jest.fn(),
       accept: jest.fn(),
@@ -1146,7 +1151,7 @@ describe('TaskManager', () => {
       taskManager.setAgentId(agentId);
     });
 
-    it('should set wrapUpRequired to true when agent is in agentsPendingWrapUp array', () => {
+    it('should set wrapUpRequired to true when agent is in agentsPendingWrapUp array for non-campaign tasks', () => {
       const task = taskManager.getTask(taskId);
       task.updateTaskData = jest.fn().mockImplementation((newData) => {
         task.data = {
@@ -1306,7 +1311,7 @@ describe('TaskManager', () => {
       );
     });
 
-    it('should set wrapUpRequired correctly when agent is the only one in agentsPendingWrapUp', () => {
+    it('should set wrapUpRequired to true when agent is the only one in agentsPendingWrapUp for non-campaign tasks', () => {
       const task = taskManager.getTask(taskId);
       task.updateTaskData = jest.fn().mockImplementation((newData) => {
         task.data = {
@@ -1338,7 +1343,7 @@ describe('TaskManager', () => {
       );
     });
 
-    it('should work correctly for different interaction states when agent is in agentsPendingWrapUp', () => {
+    it('should set wrapUpRequired to true for different interaction states when agent is in agentsPendingWrapUp for non-campaign tasks', () => {
       const task = taskManager.getTask(taskId);
       task.updateTaskData = jest.fn().mockImplementation((newData) => {
         task.data = {
@@ -1368,7 +1373,6 @@ describe('TaskManager', () => {
 
       webSocketManagerMock.emit('message', JSON.stringify(payloadConnected));
 
-      // First call should set wrapUpRequired to true
       expect(task.updateTaskData).toHaveBeenNthCalledWith(
         1,
         expect.objectContaining({
@@ -1391,7 +1395,6 @@ describe('TaskManager', () => {
 
       webSocketManagerMock.emit('message', JSON.stringify(payloadHeld));
 
-      // Second call should also set wrapUpRequired to true
       expect(task.updateTaskData).toHaveBeenNthCalledWith(
         2,
         expect.objectContaining({
@@ -1399,6 +1402,43 @@ describe('TaskManager', () => {
         })
       );
     });
+
+    it('should set wrapUpRequired to false for campaign preview tasks even when agent is in agentsPendingWrapUp', () => {
+      const task = taskManager.getTask(taskId);
+      // Set up task as a campaign preview task via outboundType
+      task.data.interaction = {
+        ...task.data.interaction,
+        outboundType: 'STANDARD_PREVIEW_CAMPAIGN',
+      };
+      task.updateTaskData = jest.fn().mockImplementation((newData) => {
+        task.data = {
+          ...task.data,
+          ...newData,
+        };
+        return task;
+      });
+      task.unregisterWebCallListeners = jest.fn();
+
+      const payload = {
+        data: {
+          type: CC_EVENTS.CONTACT_ENDED,
+          interactionId: taskId,
+          interaction: {
+            state: 'connected',
+            mediaType: 'telephony',
+          },
+          agentsPendingWrapUp: [agentId],
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+      expect(task.updateTaskData).toHaveBeenCalledWith(
+        expect.objectContaining({
+          wrapUpRequired: false,
+        })
+      );
+    });
   });
 
   it('should remove OUTDIAL task from taskCollection on AGENT_CONTACT_ASSIGN_FAILED when NOT terminated (user-declined)', () => {
@@ -3294,7 +3334,7 @@ describe('TaskManager', () => {
       );
     });
 
-    it('should update task data but NOT remove task when CampaignContactUpdated is received', () => {
+    it('should emit TASK_CAMPAIGN_CONTACT_UPDATED and NOT remove task when CampaignContactUpdated is received', () => {
       const campaignInteractionId = 'campaign-interaction-123';
 
       // First create a campaign preview task
@@ -3344,8 +3384,199 @@ describe('TaskManager', () => {
       // Task should still exist in collection (not removed — non-terminal event)
       expect(taskManager['taskCollection'][campaignInteractionId]).toBeDefined();
 
+      // TASK_CAMPAIGN_CONTACT_UPDATED should have been emitted
+      expect(taskEmitSpy).toHaveBeenCalledWith(
+        TASK_EVENTS.TASK_CAMPAIGN_CONTACT_UPDATED,
+        expect.objectContaining({
+          data: expect.objectContaining({
+            interactionId: campaignInteractionId,
+          }),
+        })
+      );
+
       // TASK_END should NOT have been emitted
       expect(taskEmitSpy).not.toHaveBeenCalledWith(TASK_EVENTS.TASK_END, expect.anything());
     });
+
+    it('should emit TASK_CAMPAIGN_PREVIEW_ACCEPT_FAILED when CampaignPreviewAcceptFailed is received', () => {
+      const campaignInteractionId = 'campaign-interaction-123';
+
+      // First create a campaign preview task
+      const reservationPayload = {
+        data: {
+          type: CC_EVENTS.AGENT_OFFER_CAMPAIGN_RESERVATION,
+          interactionId: campaignInteractionId,
+          agentId: taskDataMock.agentId,
+          orgId: taskDataMock.orgId,
+          trackingId: 'campaign-tracking-456',
+          interaction: {
+            mediaType: 'telephony',
+            callProcessingDetails: {
+              campaignId: 'campaign-789',
+            },
+          },
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(reservationPayload));
+
+      const task = taskManager['taskCollection'][campaignInteractionId];
+      expect(task).toBeDefined();
+
+      const taskEmitSpy = jest.spyOn(task, 'emit');
+
+      const failPayload = {
+        data: {
+          type: CC_EVENTS.CAMPAIGN_PREVIEW_ACCEPT_FAILED,
+          interactionId: campaignInteractionId,
+          campaignId: 'campaign-789',
+          reason: 'INTERNAL_ERROR',
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(failPayload));
+
+      expect(taskEmitSpy).toHaveBeenCalledWith(
+        TASK_EVENTS.TASK_CAMPAIGN_PREVIEW_ACCEPT_FAILED,
+        expect.objectContaining({
+          data: expect.objectContaining({interactionId: campaignInteractionId}),
+        })
+      );
+      // Task should still exist (failure is non-terminal)
+      expect(taskManager['taskCollection'][campaignInteractionId]).toBeDefined();
+
+      // Failure payload (reason, campaignId) should be merged into task.data
+      expect(task.data.reason).toBe('INTERNAL_ERROR');
+
+      // Original reservation data must be preserved
+      expect(task.data.interaction).toBeDefined();
+      expect(task.data.interaction.callProcessingDetails.campaignId).toBe('campaign-789');
+    });
+
+    it('should emit TASK_CAMPAIGN_PREVIEW_SKIP_FAILED when CampaignPreviewSkipFailed is received', () => {
+      const campaignInteractionId = 'campaign-interaction-123';
+
+      const reservationPayload = {
+        data: {
+          type: CC_EVENTS.AGENT_OFFER_CAMPAIGN_RESERVATION,
+          interactionId: campaignInteractionId,
+          agentId: taskDataMock.agentId,
+          orgId: taskDataMock.orgId,
+          trackingId: 'campaign-tracking-456',
+          interaction: {
+            mediaType: 'telephony',
+            callProcessingDetails: {
+              campaignId: 'campaign-789',
+            },
+          },
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(reservationPayload));
+
+      const task = taskManager['taskCollection'][campaignInteractionId];
+      expect(task).toBeDefined();
+
+      const taskEmitSpy = jest.spyOn(task, 'emit');
+
+      const failPayload = {
+        data: {
+          type: CC_EVENTS.CAMPAIGN_PREVIEW_SKIP_FAILED,
+          interactionId: campaignInteractionId,
+          campaignId: 'campaign-789',
+          reason: 'INTERNAL_ERROR',
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(failPayload));
+
+      expect(taskEmitSpy).toHaveBeenCalledWith(
+        TASK_EVENTS.TASK_CAMPAIGN_PREVIEW_SKIP_FAILED,
+        expect.objectContaining({
+          data: expect.objectContaining({interactionId: campaignInteractionId}),
+        })
+      );
+      expect(taskManager['taskCollection'][campaignInteractionId]).toBeDefined();
+
+      // Failure payload (reason) should be merged into task.data
+      expect(task.data.reason).toBe('INTERNAL_ERROR');
+
+      // Original reservation data must be preserved
+      expect(task.data.interaction).toBeDefined();
+      expect(task.data.interaction.callProcessingDetails.campaignId).toBe('campaign-789');
+    });
+
+    it('should emit TASK_CAMPAIGN_PREVIEW_REMOVE_FAILED when CampaignPreviewRemoveFailed is received', () => {
+      const campaignInteractionId = 'campaign-interaction-123';
+
+      const reservationPayload = {
+        data: {
+          type: CC_EVENTS.AGENT_OFFER_CAMPAIGN_RESERVATION,
+          interactionId: campaignInteractionId,
+          agentId: taskDataMock.agentId,
+          orgId: taskDataMock.orgId,
+          trackingId: 'campaign-tracking-456',
+          interaction: {
+            mediaType: 'telephony',
+            callProcessingDetails: {
+              campaignId: 'campaign-789',
+            },
+          },
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(reservationPayload));
+
+      const task = taskManager['taskCollection'][campaignInteractionId];
+      expect(task).toBeDefined();
+
+      const taskEmitSpy = jest.spyOn(task, 'emit');
+
+      const failPayload = {
+        data: {
+          type: CC_EVENTS.CAMPAIGN_PREVIEW_REMOVE_FAILED,
+          interactionId: campaignInteractionId,
+          campaignId: 'campaign-789',
+          reason: 'INTERNAL_ERROR',
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(failPayload));
+
+      expect(taskEmitSpy).toHaveBeenCalledWith(
+        TASK_EVENTS.TASK_CAMPAIGN_PREVIEW_REMOVE_FAILED,
+        expect.objectContaining({
+          data: expect.objectContaining({interactionId: campaignInteractionId}),
+        })
+      );
+      expect(taskManager['taskCollection'][campaignInteractionId]).toBeDefined();
+
+      // Failure payload (reason) should be merged into task.data
+      expect(task.data.reason).toBe('INTERNAL_ERROR');
+
+      // Original reservation data must be preserved
+      expect(task.data.interaction).toBeDefined();
+      expect(task.data.interaction.callProcessingDetails.campaignId).toBe('campaign-789');
+    });
+
+    it('should not emit campaign preview failure events when task does not exist', () => {
+      const nonExistentId = 'non-existent-interaction';
+
+      const failPayload = {
+        data: {
+          type: CC_EVENTS.CAMPAIGN_PREVIEW_SKIP_FAILED,
+          interactionId: nonExistentId,
+          campaignId: 'campaign-789',
+          reason: 'INTERNAL_ERROR',
+        },
+      };
+
+      // Should not throw when task is not found
+      expect(() => {
+        webSocketManagerMock.emit('message', JSON.stringify(failPayload));
+      }).not.toThrow();
+
+      expect(taskManager['taskCollection'][nonExistentId]).toBeUndefined();
+    });
   });
 });

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

@@ -239,5 +239,195 @@ describe('AQM routing dialer', () => {
         ).rejects.toThrow('Request Timeout');
       });
     });
+
+    describe('skipPreviewContact', () => {
+      it('should construct the correct URL with campaignId and interactionId', () => {
+        const dialer = aqmDialer(fakeAqm as any);
+        const config = dialer.skipPreviewContact({data: previewPayload}) as any;
+
+        expect(config.url).toBe(
+          `/v1/dialer/campaign/${previewPayload.campaignId}/preview-task/${previewPayload.interactionId}/skip`
+        );
+      });
+
+      it('should URL-encode campaignId when it contains reserved characters', () => {
+        const dialer = aqmDialer(fakeAqm as any);
+        const payloadWithSpecialChars = {
+          interactionId: 'interaction-456',
+          campaignId: 'My Campaign/Test #1',
+        };
+        const config = dialer.skipPreviewContact({data: payloadWithSpecialChars}) as any;
+
+        expect(config.url).toBe(
+          `/v1/dialer/campaign/${encodeURIComponent(
+            payloadWithSpecialChars.campaignId
+          )}/preview-task/${payloadWithSpecialChars.interactionId}/skip`
+        );
+        expect(config.url).toContain('My%20Campaign%2FTest%20%231');
+      });
+
+      it('should call the skipPreviewContact api', () => {
+        const fakeAqm = {
+          req: () =>
+            jest.fn().mockResolvedValue(() => {
+              Promise.resolve({data: 'skip preview success'});
+            }),
+          evt: jest.fn(),
+        };
+
+        const dialer = aqmDialer(fakeAqm as any);
+
+        dialer
+          .skipPreviewContact({data: previewPayload})
+          .then((response) => {
+            expect(response.data).toBe('skip preview success');
+          })
+          .catch(() => {
+            expect(true).toBe(true);
+          });
+
+        expect(dialer.skipPreviewContact).toHaveBeenCalled();
+      });
+
+      it('should handle network errors', () => {
+        const fakeAqm = {
+          req: () => jest.fn().mockRejectedValue(new Error('Network Error')),
+          evt: jest.fn(),
+        };
+
+        const dialer = aqmDialer(fakeAqm as any);
+
+        return expect(
+          dialer.skipPreviewContact({
+            data: previewPayload,
+          })
+        ).rejects.toThrow('Network Error');
+      });
+
+      it('should handle server errors', () => {
+        const fakeAqm = {
+          req: () => jest.fn().mockRejectedValue(new Error('Server Error')),
+          evt: jest.fn(),
+        };
+
+        const dialer = aqmDialer(fakeAqm as any);
+
+        return expect(
+          dialer.skipPreviewContact({
+            data: previewPayload,
+          })
+        ).rejects.toThrow('Server Error');
+      });
+
+      it('should handle timeout scenarios', () => {
+        const fakeAqm = {
+          req: () => jest.fn().mockRejectedValue(new Error('Request Timeout')),
+          evt: jest.fn(),
+        };
+
+        const dialer = aqmDialer(fakeAqm as any);
+
+        return expect(
+          dialer.skipPreviewContact({
+            data: previewPayload,
+          })
+        ).rejects.toThrow('Request Timeout');
+      });
+    });
+
+    describe('removePreviewContact', () => {
+      it('should construct the correct URL with campaignId and interactionId', () => {
+        const dialer = aqmDialer(fakeAqm as any);
+        const config = dialer.removePreviewContact({data: previewPayload}) as any;
+
+        expect(config.url).toBe(
+          `/v1/dialer/campaign/${previewPayload.campaignId}/preview-task/${previewPayload.interactionId}/remove`
+        );
+      });
+
+      it('should URL-encode campaignId when it contains reserved characters', () => {
+        const dialer = aqmDialer(fakeAqm as any);
+        const payloadWithSpecialChars = {
+          interactionId: 'interaction-456',
+          campaignId: 'My Campaign/Test #1',
+        };
+        const config = dialer.removePreviewContact({data: payloadWithSpecialChars}) as any;
+
+        expect(config.url).toBe(
+          `/v1/dialer/campaign/${encodeURIComponent(
+            payloadWithSpecialChars.campaignId
+          )}/preview-task/${payloadWithSpecialChars.interactionId}/remove`
+        );
+        expect(config.url).toContain('My%20Campaign%2FTest%20%231');
+      });
+
+      it('should call the removePreviewContact api', () => {
+        const fakeAqm = {
+          req: () =>
+            jest.fn().mockResolvedValue(() => {
+              Promise.resolve({data: 'remove preview success'});
+            }),
+          evt: jest.fn(),
+        };
+
+        const dialer = aqmDialer(fakeAqm as any);
+
+        dialer
+          .removePreviewContact({data: previewPayload})
+          .then((response) => {
+            expect(response.data).toBe('remove preview success');
+          })
+          .catch(() => {
+            expect(true).toBe(true);
+          });
+
+        expect(dialer.removePreviewContact).toHaveBeenCalled();
+      });
+
+      it('should handle network errors', () => {
+        const fakeAqm = {
+          req: () => jest.fn().mockRejectedValue(new Error('Network Error')),
+          evt: jest.fn(),
+        };
+
+        const dialer = aqmDialer(fakeAqm as any);
+
+        return expect(
+          dialer.removePreviewContact({
+            data: previewPayload,
+          })
+        ).rejects.toThrow('Network Error');
+      });
+
+      it('should handle server errors', () => {
+        const fakeAqm = {
+          req: () => jest.fn().mockRejectedValue(new Error('Server Error')),
+          evt: jest.fn(),
+        };
+
+        const dialer = aqmDialer(fakeAqm as any);
+
+        return expect(
+          dialer.removePreviewContact({
+            data: previewPayload,
+          })
+        ).rejects.toThrow('Server Error');
+      });
+
+      it('should handle timeout scenarios', () => {
+        const fakeAqm = {
+          req: () => jest.fn().mockRejectedValue(new Error('Request Timeout')),
+          evt: jest.fn(),
+        };
+
+        const dialer = aqmDialer(fakeAqm as any);
+
+        return expect(
+          dialer.removePreviewContact({
+            data: previewPayload,
+          })
+        ).rejects.toThrow('Request Timeout');
+      });
+    });
   });
 });

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

@@ -691,6 +691,27 @@ describe('Task', () => {
     );
   });
 
+  it('should hold using mediaResourceId from interaction.media after recording event wipes top-level mediaResourceId', async () => {
+    // Set a DIFFERENT top-level mediaResourceId so we can distinguish the two sources
+    const staleTopLevelId = 'stale-top-level-media-resource-id';
+    const correctMediaId = task.data.interaction.media[task.data.interaction.mainInteractionId].mediaResourceId;
+    task.data.mediaResourceId = staleTopLevelId;
+
+    // Simulate recording event wiping top-level mediaResourceId (as reconcileData does)
+    delete task.data.mediaResourceId;
+
+    const expectedResponse: TaskResponse = {data: {interactionId: taskId}} as AgentContact;
+    contactMock.hold.mockResolvedValue(expectedResponse);
+
+    await task.hold();
+
+    // hold() should read from interaction.media, not the (now deleted) top-level field
+    expect(contactMock.hold).toHaveBeenCalledWith({
+      interactionId: taskId,
+      data: {mediaResourceId: correctMediaId},
+    });
+  });
+
   it('should handle errors in hold method', async () => {
     const error = {details: (global as any).makeFailure('Hold Failed')};
     contactMock.hold.mockImplementation(() => {