@webex/contact-center 3.12.0-webex-services-ready.4 → 3.13.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/.sdd/manifest.json +24 -13
- package/ai-docs/ARCHITECTURE.md +1 -1
- package/ai-docs/CONTRACTS.md +19 -3
- package/ai-docs/SECURITY.md +1 -1
- package/ai-docs/SERVICE_STATE.md +4 -0
- package/ai-docs/contact-center-spec.md +50 -6
- package/ai-docs/features/consult-transfer-list-policy/spec/feature-spec.md +362 -0
- package/ai-docs/features/contact-owner-change-refactor.md +78 -0
- package/dist/cc.js +757 -22
- package/dist/cc.js.map +1 -1
- package/dist/config.js +7 -0
- package/dist/config.js.map +1 -1
- package/dist/constants.js +23 -2
- package/dist/constants.js.map +1 -1
- package/dist/index.js +34 -12
- package/dist/index.js.map +1 -1
- package/dist/metrics/MetricsManager.js +16 -0
- package/dist/metrics/MetricsManager.js.map +1 -1
- package/dist/metrics/behavioral-events.js +110 -0
- package/dist/metrics/behavioral-events.js.map +1 -1
- package/dist/metrics/constants.js +33 -0
- package/dist/metrics/constants.js.map +1 -1
- package/dist/services/AddressBook.js +18 -15
- package/dist/services/AddressBook.js.map +1 -1
- package/dist/services/AnswerCallOnWebexService.js +202 -0
- package/dist/services/AnswerCallOnWebexService.js.map +1 -0
- package/dist/services/ApiAiAssistant.js +221 -11
- package/dist/services/ApiAiAssistant.js.map +1 -1
- package/dist/services/EntryPoint.js +46 -68
- package/dist/services/EntryPoint.js.map +1 -1
- package/dist/services/Queue.js +27 -22
- package/dist/services/Queue.js.map +1 -1
- package/dist/services/WebCallingService.js +10 -2
- package/dist/services/WebCallingService.js.map +1 -1
- package/dist/services/WebexCrossClientService.js +225 -0
- package/dist/services/WebexCrossClientService.js.map +1 -0
- package/dist/services/WxAppTelephonyMercurySync.js +111 -0
- package/dist/services/WxAppTelephonyMercurySync.js.map +1 -0
- package/dist/services/config/Util.js +46 -46
- package/dist/services/config/Util.js.map +1 -1
- package/dist/services/config/constants.js +34 -77
- package/dist/services/config/constants.js.map +1 -1
- package/dist/services/config/index.js +100 -226
- package/dist/services/config/index.js.map +1 -1
- package/dist/services/config/types.js +51 -18
- package/dist/services/config/types.js.map +1 -1
- package/dist/services/constants.js +11 -1
- package/dist/services/constants.js.map +1 -1
- package/dist/services/core/Err.js.map +1 -1
- package/dist/services/core/Utils.js +25 -1
- package/dist/services/core/Utils.js.map +1 -1
- package/dist/services/core/WebexRequest.js +6 -2
- package/dist/services/core/WebexRequest.js.map +1 -1
- package/dist/services/core/aqm-reqs.js +17 -11
- package/dist/services/core/aqm-reqs.js.map +1 -1
- package/dist/services/core/constants.js +9 -1
- package/dist/services/core/constants.js.map +1 -1
- package/dist/services/core/types.js.map +1 -1
- package/dist/services/core/websocket/WebSocketManager.js +17 -1
- package/dist/services/core/websocket/WebSocketManager.js.map +1 -1
- package/dist/services/task/Task.js +275 -8
- package/dist/services/task/Task.js.map +1 -1
- package/dist/services/task/TaskFactory.js +11 -6
- package/dist/services/task/TaskFactory.js.map +1 -1
- package/dist/services/task/TaskManager.js +590 -42
- package/dist/services/task/TaskManager.js.map +1 -1
- package/dist/services/task/TaskUtils.js +11 -1
- package/dist/services/task/TaskUtils.js.map +1 -1
- package/dist/services/task/WebexCallingUtils.js +70 -0
- package/dist/services/task/WebexCallingUtils.js.map +1 -0
- package/dist/services/task/constants.js +14 -2
- package/dist/services/task/constants.js.map +1 -1
- package/dist/services/task/contact.js +29 -0
- package/dist/services/task/contact.js.map +1 -1
- package/dist/services/task/digital/Digital.js +4 -3
- package/dist/services/task/digital/Digital.js.map +1 -1
- package/dist/services/task/state-machine/TaskStateMachine.js +162 -53
- package/dist/services/task/state-machine/TaskStateMachine.js.map +1 -1
- package/dist/services/task/state-machine/actions.js +6 -1
- package/dist/services/task/state-machine/actions.js.map +1 -1
- package/dist/services/task/state-machine/guards.js +7 -10
- package/dist/services/task/state-machine/guards.js.map +1 -1
- package/dist/services/task/state-machine/types.js.map +1 -1
- package/dist/services/task/state-machine/uiControlsComputer.js +118 -18
- package/dist/services/task/state-machine/uiControlsComputer.js.map +1 -1
- package/dist/services/task/types.js +47 -1
- package/dist/services/task/types.js.map +1 -1
- package/dist/services/task/voice/Voice.js +477 -17
- package/dist/services/task/voice/Voice.js.map +1 -1
- package/dist/services/task/voice/WebRTC.js +6 -3
- package/dist/services/task/voice/WebRTC.js.map +1 -1
- package/dist/services/task/voice/wxAppOfferObservability.js +145 -0
- package/dist/services/task/voice/wxAppOfferObservability.js.map +1 -0
- package/dist/services/task/voice/wxAppVoiceMethods.js +395 -0
- package/dist/services/task/voice/wxAppVoiceMethods.js.map +1 -0
- package/dist/services/wxAppDiagnosticLogging.js +159 -0
- package/dist/services/wxAppDiagnosticLogging.js.map +1 -0
- package/dist/services/wxAppTelephonyUtils.js +19 -0
- package/dist/services/wxAppTelephonyUtils.js.map +1 -0
- package/dist/types/cc.d.ts +102 -8
- package/dist/types/config.d.ts +7 -0
- package/dist/types/constants.d.ts +21 -0
- package/dist/types/index.d.ts +34 -15
- package/dist/types/metrics/MetricsManager.d.ts +6 -0
- package/dist/types/metrics/constants.d.ts +31 -0
- package/dist/types/services/AddressBook.d.ts +2 -1
- package/dist/types/services/AnswerCallOnWebexService.d.ts +38 -0
- package/dist/types/services/ApiAiAssistant.d.ts +48 -4
- package/dist/types/services/EntryPoint.d.ts +7 -5
- package/dist/types/services/Queue.d.ts +5 -3
- package/dist/types/services/WebexCrossClientService.d.ts +32 -0
- package/dist/types/services/WxAppTelephonyMercurySync.d.ts +28 -0
- package/dist/types/services/config/Util.d.ts +4 -8
- package/dist/types/services/config/constants.d.ts +28 -76
- package/dist/types/services/config/index.d.ts +16 -64
- package/dist/types/services/config/types.d.ts +146 -173
- package/dist/types/services/constants.d.ts +9 -0
- package/dist/types/services/core/Err.d.ts +2 -0
- package/dist/types/services/core/Utils.d.ts +10 -0
- package/dist/types/services/core/WebexRequest.d.ts +1 -0
- package/dist/types/services/core/constants.d.ts +7 -0
- package/dist/types/services/core/types.d.ts +2 -0
- package/dist/types/services/task/Task.d.ts +34 -5
- package/dist/types/services/task/TaskFactory.d.ts +4 -2
- package/dist/types/services/task/TaskUtils.d.ts +6 -0
- package/dist/types/services/task/WebexCallingUtils.d.ts +11 -0
- package/dist/types/services/task/constants.d.ts +12 -0
- package/dist/types/services/task/contact.d.ts +4 -0
- package/dist/types/services/task/digital/Digital.d.ts +4 -3
- package/dist/types/services/task/state-machine/TaskStateMachine.d.ts +304 -56
- package/dist/types/services/task/state-machine/guards.d.ts +6 -5
- package/dist/types/services/task/state-machine/types.d.ts +9 -1
- package/dist/types/services/task/types.d.ts +192 -5
- package/dist/types/services/task/voice/Voice.d.ts +68 -11
- package/dist/types/services/task/voice/WebRTC.d.ts +5 -4
- package/dist/types/services/task/voice/wxAppOfferObservability.d.ts +39 -0
- package/dist/types/services/task/voice/wxAppVoiceMethods.d.ts +68 -0
- package/dist/types/services/wxAppDiagnosticLogging.d.ts +63 -0
- package/dist/types/services/wxAppTelephonyUtils.d.ts +5 -0
- package/dist/types/types.d.ts +80 -13
- package/dist/types/utils/PageCache.d.ts +20 -3
- package/dist/types.js +54 -8
- package/dist/types.js.map +1 -1
- package/dist/utils/PageCache.js +19 -5
- package/dist/utils/PageCache.js.map +1 -1
- package/dist/webex.js +9 -1
- package/dist/webex.js.map +1 -1
- package/package.json +10 -9
- package/src/cc.ts +969 -38
- package/src/config.ts +7 -0
- package/src/constants.ts +24 -0
- package/src/index.ts +39 -10
- package/src/metrics/MetricsManager.ts +16 -0
- package/src/metrics/ai-docs/metrics-spec.md +138 -21
- package/src/metrics/behavioral-events.ts +112 -0
- package/src/metrics/constants.ts +36 -0
- package/src/services/AddressBook.ts +17 -6
- package/src/services/AnswerCallOnWebexService.ts +239 -0
- package/src/services/ApiAiAssistant.ts +297 -13
- package/src/services/EntryPoint.ts +59 -60
- package/src/services/Queue.ts +29 -12
- package/src/services/WebCallingService.ts +16 -2
- package/src/services/WebexCrossClientService.ts +298 -0
- package/src/services/WxAppTelephonyMercurySync.ts +142 -0
- package/src/services/agent/ai-docs/AGENTS.md +1 -1
- package/src/services/agent/ai-docs/agent-spec.md +1 -0
- package/src/services/ai-docs/AGENTS.md +10 -10
- package/src/services/ai-docs/services-spec.md +25 -5
- package/src/services/config/Util.ts +52 -82
- package/src/services/config/ai-docs/AGENTS.md +35 -40
- package/src/services/config/ai-docs/ARCHITECTURE.md +90 -103
- package/src/services/config/ai-docs/config-spec.md +132 -132
- package/src/services/config/constants.ts +39 -85
- package/src/services/config/index.ts +116 -277
- package/src/services/config/types.ts +140 -195
- package/src/services/constants.ts +10 -0
- package/src/services/core/Err.ts +1 -0
- package/src/services/core/Utils.ts +28 -0
- package/src/services/core/WebexRequest.ts +3 -1
- package/src/services/core/ai-docs/core-spec.md +25 -11
- package/src/services/core/aqm-reqs.ts +18 -12
- package/src/services/core/constants.ts +8 -0
- package/src/services/core/types.ts +33 -1
- package/src/services/core/websocket/WebSocketManager.ts +26 -2
- package/src/services/task/Task.ts +386 -12
- package/src/services/task/TaskFactory.ts +33 -6
- package/src/services/task/TaskManager.ts +857 -41
- package/src/services/task/TaskUtils.ts +13 -0
- package/src/services/task/WebexCallingUtils.ts +136 -0
- package/src/services/task/ai-docs/ARCHITECTURE.md +1 -0
- package/src/services/task/ai-docs/task-spec.md +190 -8
- package/src/services/task/constants.ts +13 -0
- package/src/services/task/contact.ts +30 -0
- package/src/services/task/digital/Digital.ts +11 -4
- package/src/services/task/state-machine/TaskStateMachine.ts +235 -81
- package/src/services/task/state-machine/actions.ts +5 -2
- package/src/services/task/state-machine/ai-docs/AGENTS.md +6 -4
- package/src/services/task/state-machine/ai-docs/ARCHITECTURE.md +35 -16
- package/src/services/task/state-machine/ai-docs/task-state-machine-spec.md +103 -33
- package/src/services/task/state-machine/guards.ts +7 -10
- package/src/services/task/state-machine/types.ts +16 -1
- package/src/services/task/state-machine/uiControlsComputer.ts +206 -32
- package/src/services/task/types.ts +269 -4
- package/src/services/task/voice/Voice.ts +625 -17
- package/src/services/task/voice/WebRTC.ts +11 -4
- package/src/services/task/voice/wxAppOfferObservability.ts +204 -0
- package/src/services/task/voice/wxAppVoiceMethods.ts +575 -0
- package/src/services/wxAppDiagnosticLogging.ts +286 -0
- package/src/services/wxAppTelephonyUtils.ts +14 -0
- package/src/types.ts +108 -13
- package/src/utils/AGENTS.md +21 -10
- package/src/utils/PageCache.ts +38 -5
- package/src/utils/ai-docs/utils-spec.md +21 -11
- package/src/webex.js +8 -0
- package/test/unit/fixtures/aiSummaryTestUtils.ts +40 -0
- package/test/unit/spec/cc.ts +3408 -152
- package/test/unit/spec/index.ts +885 -0
- package/test/unit/spec/metrics/MetricsManager.ts +25 -0
- package/test/unit/spec/metrics/behavioral-events.ts +60 -0
- package/test/unit/spec/services/AddressBook.ts +37 -6
- package/test/unit/spec/services/AnswerCallOnWebexService.ts +264 -0
- package/test/unit/spec/services/ApiAiAssistant.ts +269 -8
- package/test/unit/spec/services/EntryPoint.ts +87 -40
- package/test/unit/spec/services/Queue.ts +123 -12
- package/test/unit/spec/services/WebCallingService.ts +38 -0
- package/test/unit/spec/services/WebexCrossClientService.ts +509 -0
- package/test/unit/spec/services/WxAppTelephonyMercurySync.ts +136 -0
- package/test/unit/spec/services/config/Util.ts +501 -0
- package/test/unit/spec/services/config/index.ts +313 -543
- package/test/unit/spec/services/core/Utils.ts +22 -0
- package/test/unit/spec/services/core/WebexRequest.ts +8 -7
- package/test/unit/spec/services/core/aqm-reqs.ts +142 -1
- package/test/unit/spec/services/core/websocket/WebSocketManager.ts +64 -14
- package/test/unit/spec/services/task/Task.ts +2257 -11
- package/test/unit/spec/services/task/TaskFactory.ts +56 -2
- package/test/unit/spec/services/task/TaskManager.ts +5559 -1493
- package/test/unit/spec/services/task/TaskUtils.ts +72 -0
- package/test/unit/spec/services/task/WebexCallingUtils.ts +153 -0
- package/test/unit/spec/services/task/contact.ts +33 -0
- package/test/unit/spec/services/task/state-machine/TaskStateMachine.ts +1501 -92
- package/test/unit/spec/services/task/state-machine/guards.ts +210 -8
- package/test/unit/spec/services/task/state-machine/uiControlsComputer.ts +445 -7
- package/test/unit/spec/services/task/voice/Voice.ts +1710 -4
- package/test/unit/spec/services/task/voice/wxAppOfferObservability.ts +361 -0
- package/test/unit/spec/services/task/voice/wxAppVoiceMethods.ts +719 -0
- package/test/unit/spec/services/wxAppDiagnosticLogging.ts +179 -0
- package/test/unit/spec/wellnessSampleUtils.ts +288 -0
- package/typedoc.md +1 -1
- package/umd/contact-center.min.js +2 -2
- package/umd/contact-center.min.js.map +1 -1
|
@@ -13,10 +13,12 @@ import {
|
|
|
13
13
|
WebSocketMessage,
|
|
14
14
|
TaskEventActions,
|
|
15
15
|
EventContext,
|
|
16
|
+
AISummaryFeatureEnablement,
|
|
17
|
+
AISummary,
|
|
16
18
|
} from './types';
|
|
17
19
|
import {TASK_MANAGER_FILE} from '../../constants';
|
|
18
20
|
import {METHODS, TRANSCRIPT_EVENT_MAP} from './constants';
|
|
19
|
-
import {CC_EVENTS, WrapupData} from '../config/types';
|
|
21
|
+
import {CC_EVENTS, CC_TASK_EVENTS, WrapupData} from '../config/types';
|
|
20
22
|
import {ConfigFlags, LoginOption, AIAssistantEventType, AIAssistantEventName} from '../../types';
|
|
21
23
|
import LoggerProxy from '../../logger-proxy';
|
|
22
24
|
import {
|
|
@@ -27,15 +29,38 @@ import {
|
|
|
27
29
|
shouldAutoAnswerTask,
|
|
28
30
|
} from './TaskUtils';
|
|
29
31
|
import TaskFactory from './TaskFactory';
|
|
32
|
+
import AnswerCallOnWebexService from '../AnswerCallOnWebexService';
|
|
33
|
+
import {getWebexCallingDeviceDetailsForAgent} from './WebexCallingUtils';
|
|
30
34
|
import WebRTC from './voice/WebRTC';
|
|
31
|
-
import {TaskEvent, type TaskEventPayload} from './state-machine';
|
|
35
|
+
import {TaskEvent, TaskState, type TaskEventPayload} from './state-machine';
|
|
36
|
+
import {MEDIA_TYPE_MAIN_CALL} from './state-machine/constants';
|
|
32
37
|
import {normalizeTaskData} from './taskDataNormalizer';
|
|
33
38
|
import {ApiAIAssistant} from '../ApiAiAssistant';
|
|
34
39
|
|
|
35
40
|
const CC_EVENT_SET = new Set<CC_EVENTS>(Object.values(CC_EVENTS) as CC_EVENTS[]);
|
|
36
41
|
|
|
42
|
+
const MAIN_INTERACTION_CORRELATED_EVENTS = new Set<CC_EVENTS>([
|
|
43
|
+
CC_EVENTS.AGENT_CONSULT_ENDED,
|
|
44
|
+
CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE,
|
|
45
|
+
]);
|
|
46
|
+
|
|
37
47
|
const isCcEvent = (value: string): value is CC_EVENTS => CC_EVENT_SET.has(value as CC_EVENTS);
|
|
38
48
|
|
|
49
|
+
const WRAP_UP_STAMP_EVENTS = new Set<CC_EVENTS>([
|
|
50
|
+
CC_EVENTS.AGENT_WRAPUP,
|
|
51
|
+
CC_EVENTS.AGENT_CONSULT_CONFERENCE_ENDED,
|
|
52
|
+
CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE,
|
|
53
|
+
CC_EVENTS.AGENT_CONFERENCE_TRANSFERRED,
|
|
54
|
+
]);
|
|
55
|
+
|
|
56
|
+
const PARTICIPANT_LEAVE_WRAP_STATES = new Set<TaskState>([
|
|
57
|
+
TaskState.HELD,
|
|
58
|
+
TaskState.RESUME_INITIATING,
|
|
59
|
+
TaskState.CONSULTING,
|
|
60
|
+
TaskState.CONSULT_INITIATING,
|
|
61
|
+
TaskState.CONFERENCING,
|
|
62
|
+
]);
|
|
63
|
+
|
|
39
64
|
/** @internal */
|
|
40
65
|
export default class TaskManager extends EventEmitter {
|
|
41
66
|
private call: ICall;
|
|
@@ -54,8 +79,15 @@ export default class TaskManager extends EventEmitter {
|
|
|
54
79
|
private configFlags?: ConfigFlags;
|
|
55
80
|
private wrapupData: WrapupData;
|
|
56
81
|
private agentId: string;
|
|
82
|
+
private agentName: string;
|
|
57
83
|
private webRtcEnabled: boolean;
|
|
84
|
+
private answerCallOnWebexService?: AnswerCallOnWebexService;
|
|
58
85
|
private apiAIAssistant?: ApiAIAssistant;
|
|
86
|
+
private receivingSummaryBuffer = new Map<string, AISummary>();
|
|
87
|
+
|
|
88
|
+
// RTD feature frames can arrive before AQM creates the task.
|
|
89
|
+
private pendingFeatureEnablement = new Map<string, AISummaryFeatureEnablement>();
|
|
90
|
+
|
|
59
91
|
/**
|
|
60
92
|
* @param contact - Routing Contact layer. Talks to AQMReq layer to convert events to promises
|
|
61
93
|
* @param webCallingService - Webrtc Service Layer
|
|
@@ -76,7 +108,6 @@ export default class TaskManager extends EventEmitter {
|
|
|
76
108
|
this.rtdWebSocketManager = rtdWebSocketManager;
|
|
77
109
|
this.taskCollection = {};
|
|
78
110
|
this.webRtcEnabled = false;
|
|
79
|
-
|
|
80
111
|
this.registerTaskListeners();
|
|
81
112
|
this.registerIncomingCallEvent();
|
|
82
113
|
}
|
|
@@ -85,6 +116,56 @@ export default class TaskManager extends EventEmitter {
|
|
|
85
116
|
try {
|
|
86
117
|
const payload = JSON.parse(event);
|
|
87
118
|
|
|
119
|
+
switch (payload?.type) {
|
|
120
|
+
case CC_TASK_EVENTS.FEATURE_ENABLEMENT: {
|
|
121
|
+
const enablement: AISummaryFeatureEnablement = payload?.data?.data;
|
|
122
|
+
if (!enablement?.interactionId) return;
|
|
123
|
+
|
|
124
|
+
const task = this.taskCollection[enablement.interactionId];
|
|
125
|
+
if (task) {
|
|
126
|
+
this.pendingFeatureEnablement.delete(enablement.interactionId);
|
|
127
|
+
task.setFeatureEnablement?.(enablement);
|
|
128
|
+
task.emit(TASK_EVENTS.TASK_FEATURE_ENABLEMENT, enablement);
|
|
129
|
+
} else {
|
|
130
|
+
this.pendingFeatureEnablement.set(enablement.interactionId, enablement);
|
|
131
|
+
}
|
|
132
|
+
|
|
133
|
+
return;
|
|
134
|
+
}
|
|
135
|
+
case CC_TASK_EVENTS.POST_CALL_SUMMARY:
|
|
136
|
+
case CC_TASK_EVENTS.MID_CALL_SUMMARY: {
|
|
137
|
+
if (!payload?.data?.data?.conversationId) return;
|
|
138
|
+
|
|
139
|
+
this.apiAIAssistant?.resolveFromRtdEvent(
|
|
140
|
+
payload.type,
|
|
141
|
+
payload.data.data.conversationId,
|
|
142
|
+
payload.data.data
|
|
143
|
+
);
|
|
144
|
+
|
|
145
|
+
return;
|
|
146
|
+
}
|
|
147
|
+
case CC_TASK_EVENTS.MID_CALL_SUMMARY_RESPONSE_SUBSEQUENT_AGENT: {
|
|
148
|
+
if (!payload?.data?.data?.conversationId) return;
|
|
149
|
+
|
|
150
|
+
const summary: AISummary = payload.data.data;
|
|
151
|
+
const {conversationId} = summary;
|
|
152
|
+
const task = this.taskCollection[conversationId];
|
|
153
|
+
const taskState = task?.state?.value;
|
|
154
|
+
|
|
155
|
+
// Emit only once the task is answered; until then it waits for the answer event.
|
|
156
|
+
if (task && taskState !== TaskState.IDLE && taskState !== TaskState.OFFERED) {
|
|
157
|
+
this.receivingSummaryBuffer.delete(conversationId);
|
|
158
|
+
task.emit(TASK_EVENTS.TASK_MID_CALL_SUMMARY_RECEIVED, summary);
|
|
159
|
+
} else {
|
|
160
|
+
this.receivingSummaryBuffer.set(conversationId, summary);
|
|
161
|
+
}
|
|
162
|
+
|
|
163
|
+
return;
|
|
164
|
+
}
|
|
165
|
+
default:
|
|
166
|
+
break;
|
|
167
|
+
}
|
|
168
|
+
|
|
88
169
|
const interactionId = payload?.data?.data?.conversationId;
|
|
89
170
|
if (!interactionId) return;
|
|
90
171
|
|
|
@@ -104,6 +185,8 @@ export default class TaskManager extends EventEmitter {
|
|
|
104
185
|
case CC_EVENTS.SUGGESTED_RESPONSE:
|
|
105
186
|
task.emit(payload.type, payload.data);
|
|
106
187
|
break;
|
|
188
|
+
default:
|
|
189
|
+
break;
|
|
107
190
|
}
|
|
108
191
|
} catch (error) {
|
|
109
192
|
LoggerProxy.error('Failed to parse RTD WebSocket message', {
|
|
@@ -121,6 +204,13 @@ export default class TaskManager extends EventEmitter {
|
|
|
121
204
|
this.configFlags = configFlags;
|
|
122
205
|
}
|
|
123
206
|
|
|
207
|
+
public clearAISummaryState(): void {
|
|
208
|
+
this.apiAIAssistant?.clearAllRtdRequests();
|
|
209
|
+
Object.values(this.taskCollection).forEach((task) => task.clearFeatureEnablement?.());
|
|
210
|
+
this.receivingSummaryBuffer.clear();
|
|
211
|
+
this.pendingFeatureEnablement.clear();
|
|
212
|
+
}
|
|
213
|
+
|
|
124
214
|
/**
|
|
125
215
|
* Set wrapup configuration data
|
|
126
216
|
*/
|
|
@@ -135,6 +225,10 @@ export default class TaskManager extends EventEmitter {
|
|
|
135
225
|
this.agentId = agentId;
|
|
136
226
|
}
|
|
137
227
|
|
|
228
|
+
public setAgentName(agentName: string) {
|
|
229
|
+
this.agentName = agentName;
|
|
230
|
+
}
|
|
231
|
+
|
|
138
232
|
/**
|
|
139
233
|
* Gets the current agent ID
|
|
140
234
|
* @returns {string} The agent ID set for this task manager instance
|
|
@@ -148,6 +242,10 @@ export default class TaskManager extends EventEmitter {
|
|
|
148
242
|
this.webRtcEnabled = webRtcEnabled;
|
|
149
243
|
}
|
|
150
244
|
|
|
245
|
+
public setAnswerCallOnWebexService(answerCallOnWebexService: AnswerCallOnWebexService) {
|
|
246
|
+
this.answerCallOnWebexService = answerCallOnWebexService;
|
|
247
|
+
}
|
|
248
|
+
|
|
151
249
|
private handleIncomingWebCall = (call: ICall) => {
|
|
152
250
|
const currentTask = Object.values(this.taskCollection).find(
|
|
153
251
|
(task) =>
|
|
@@ -182,17 +280,189 @@ export default class TaskManager extends EventEmitter {
|
|
|
182
280
|
this.webCallingService.off(LINE_EVENTS.INCOMING_CALL, this.handleIncomingWebCall);
|
|
183
281
|
}
|
|
184
282
|
|
|
283
|
+
/**
|
|
284
|
+
* True when this agent left on the current payload.
|
|
285
|
+
* A named other participantId is never self-leave (even if the participants
|
|
286
|
+
* map is partial). Missing-map fallback is EP-DN only: participantId absent
|
|
287
|
+
* and self omitted now, with previous-task evidence when a prior map exists.
|
|
288
|
+
*/
|
|
289
|
+
private static didSelfLeaveConference(
|
|
290
|
+
payload: WebSocketPayload,
|
|
291
|
+
agentId?: string,
|
|
292
|
+
task?: ITask
|
|
293
|
+
): boolean {
|
|
294
|
+
if (!agentId) {
|
|
295
|
+
return false;
|
|
296
|
+
}
|
|
297
|
+
if (payload.participantId === agentId) {
|
|
298
|
+
return true;
|
|
299
|
+
}
|
|
300
|
+
if (payload.participantId && payload.participantId !== agentId) {
|
|
301
|
+
return false;
|
|
302
|
+
}
|
|
303
|
+
|
|
304
|
+
const participants = payload.interaction?.participants;
|
|
305
|
+
if (!participants || agentId in participants) {
|
|
306
|
+
return false;
|
|
307
|
+
}
|
|
308
|
+
|
|
309
|
+
const previousParticipants = task?.data?.interaction?.participants;
|
|
310
|
+
if (previousParticipants && !(agentId in previousParticipants)) {
|
|
311
|
+
return false;
|
|
312
|
+
}
|
|
313
|
+
|
|
314
|
+
return true;
|
|
315
|
+
}
|
|
316
|
+
|
|
317
|
+
/**
|
|
318
|
+
* Consulted non-owner: Voice exitConference / shouldWrapUpForThisAgent stays
|
|
319
|
+
* false unless an explicit wrap-up signal includes this agent.
|
|
320
|
+
*/
|
|
321
|
+
private static isConsultedNonOwner(
|
|
322
|
+
payload: WebSocketPayload,
|
|
323
|
+
agentId?: string,
|
|
324
|
+
task?: ITask
|
|
325
|
+
): boolean {
|
|
326
|
+
const isConsulted = payload.isConsulted ?? task?.data?.isConsulted;
|
|
327
|
+
if (isConsulted !== true) {
|
|
328
|
+
return false;
|
|
329
|
+
}
|
|
330
|
+
const owner = payload.interaction?.owner ?? task?.data?.interaction?.owner;
|
|
331
|
+
|
|
332
|
+
return Boolean(agentId && owner && owner !== agentId);
|
|
333
|
+
}
|
|
334
|
+
|
|
335
|
+
private static hasNonemptyPendingWrapUp(payload: WebSocketPayload): boolean {
|
|
336
|
+
return Array.isArray(payload.agentsPendingWrapUp) && payload.agentsPendingWrapUp.length > 0;
|
|
337
|
+
}
|
|
338
|
+
|
|
339
|
+
/**
|
|
340
|
+
* Transfer initiator fallback: widgets set transferConferenceRequested on the
|
|
341
|
+
* actor; desktop success payloads may include consultingAgentId. Only used
|
|
342
|
+
* when agentsPendingWrapUp is empty or absent.
|
|
343
|
+
*/
|
|
344
|
+
private static isSelfConferenceTransferInitiator(
|
|
345
|
+
payload: WebSocketPayload,
|
|
346
|
+
agentId?: string,
|
|
347
|
+
task?: ITask
|
|
348
|
+
): boolean {
|
|
349
|
+
const snapshotContext = task?.stateMachineService?.getSnapshot?.()?.context as
|
|
350
|
+
| {transferConferenceRequested?: boolean}
|
|
351
|
+
| undefined;
|
|
352
|
+
if (snapshotContext?.transferConferenceRequested === true) {
|
|
353
|
+
return true;
|
|
354
|
+
}
|
|
355
|
+
|
|
356
|
+
return Boolean(agentId && payload.consultingAgentId === agentId);
|
|
357
|
+
}
|
|
358
|
+
|
|
359
|
+
/**
|
|
360
|
+
* Explicit wrap-up signals only (no owner / isConsulted fallback).
|
|
361
|
+
* Used for events that remaining conference agents also receive.
|
|
362
|
+
* nonempty agentsPendingWrapUp is authoritative, then wrapUpRequired / isWrapUp.
|
|
363
|
+
*/
|
|
364
|
+
private static wrapUpRequiredFromExplicitSignals(
|
|
365
|
+
payload: WebSocketPayload,
|
|
366
|
+
agentId?: string
|
|
367
|
+
): boolean {
|
|
368
|
+
const pending = payload.agentsPendingWrapUp;
|
|
369
|
+
if (Array.isArray(pending) && pending.length > 0) {
|
|
370
|
+
return Boolean(agentId && pending.includes(agentId));
|
|
371
|
+
}
|
|
372
|
+
|
|
373
|
+
if (payload.wrapUpRequired === true) {
|
|
374
|
+
return true;
|
|
375
|
+
}
|
|
376
|
+
if (!agentId) {
|
|
377
|
+
return false;
|
|
378
|
+
}
|
|
379
|
+
|
|
380
|
+
return payload.interaction?.participants?.[agentId]?.isWrapUp === true;
|
|
381
|
+
}
|
|
382
|
+
|
|
383
|
+
/**
|
|
384
|
+
* Stamp wrapUpRequired once at ingress (prepareEventContext) so updateTaskData
|
|
385
|
+
* and the mapper see the same flag. Remaining agents stay false.
|
|
386
|
+
*/
|
|
387
|
+
private static stampWrapUpRequiredForEvent(
|
|
388
|
+
eventType: CC_EVENTS,
|
|
389
|
+
payload: WebSocketPayload,
|
|
390
|
+
agentId?: string,
|
|
391
|
+
task?: ITask
|
|
392
|
+
): WebSocketPayload {
|
|
393
|
+
if (!WRAP_UP_STAMP_EVENTS.has(eventType)) {
|
|
394
|
+
return payload;
|
|
395
|
+
}
|
|
396
|
+
|
|
397
|
+
if (eventType === CC_EVENTS.AGENT_WRAPUP) {
|
|
398
|
+
return {...payload, wrapUpRequired: true};
|
|
399
|
+
}
|
|
400
|
+
|
|
401
|
+
if (eventType === CC_EVENTS.AGENT_CONSULT_CONFERENCE_ENDED) {
|
|
402
|
+
return {
|
|
403
|
+
...payload,
|
|
404
|
+
wrapUpRequired: TaskManager.wrapUpRequiredFromExplicitSignals(payload, agentId),
|
|
405
|
+
};
|
|
406
|
+
}
|
|
407
|
+
|
|
408
|
+
if (eventType === CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE) {
|
|
409
|
+
const actorState = task?.stateMachineService?.getSnapshot?.()?.value;
|
|
410
|
+
if (actorState && !PARTICIPANT_LEAVE_WRAP_STATES.has(actorState as TaskState)) {
|
|
411
|
+
return payload;
|
|
412
|
+
}
|
|
413
|
+
|
|
414
|
+
const left = TaskManager.didSelfLeaveConference(payload, agentId, task);
|
|
415
|
+
if (!left) {
|
|
416
|
+
return {
|
|
417
|
+
...payload,
|
|
418
|
+
wrapUpRequired: TaskManager.wrapUpRequiredFromExplicitSignals(payload, agentId),
|
|
419
|
+
};
|
|
420
|
+
}
|
|
421
|
+
if (TaskManager.hasNonemptyPendingWrapUp(payload)) {
|
|
422
|
+
return {
|
|
423
|
+
...payload,
|
|
424
|
+
wrapUpRequired: Boolean(agentId && payload.agentsPendingWrapUp?.includes(agentId)),
|
|
425
|
+
};
|
|
426
|
+
}
|
|
427
|
+
|
|
428
|
+
return {
|
|
429
|
+
...payload,
|
|
430
|
+
wrapUpRequired:
|
|
431
|
+
TaskManager.wrapUpRequiredFromExplicitSignals(payload, agentId) ||
|
|
432
|
+
!TaskManager.isConsultedNonOwner(payload, agentId, task),
|
|
433
|
+
};
|
|
434
|
+
}
|
|
435
|
+
|
|
436
|
+
// AGENT_CONFERENCE_TRANSFERRED — pending list wins; initiator only if empty/absent
|
|
437
|
+
if (TaskManager.hasNonemptyPendingWrapUp(payload)) {
|
|
438
|
+
return {
|
|
439
|
+
...payload,
|
|
440
|
+
wrapUpRequired: TaskManager.wrapUpRequiredFromExplicitSignals(payload, agentId),
|
|
441
|
+
};
|
|
442
|
+
}
|
|
443
|
+
|
|
444
|
+
return {
|
|
445
|
+
...payload,
|
|
446
|
+
wrapUpRequired:
|
|
447
|
+
TaskManager.wrapUpRequiredFromExplicitSignals(payload, agentId) ||
|
|
448
|
+
TaskManager.isSelfConferenceTransferInitiator(payload, agentId, task),
|
|
449
|
+
};
|
|
450
|
+
}
|
|
451
|
+
|
|
185
452
|
/**
|
|
186
453
|
* Map WebSocket CC_EVENTS to state machine TaskEvent
|
|
187
454
|
* @param ccEvent - The CC_EVENT type from WebSocket
|
|
188
455
|
* @param payload - The event payload
|
|
189
456
|
* @param agentId - Optional agent ID for state detection (needed for HYDRATE)
|
|
457
|
+
* @param task - Optional task instance for state-aware CONTACT_ENDED mapping
|
|
190
458
|
* @returns TaskEventPayload for state machine or null if no mapping
|
|
191
459
|
*/
|
|
192
460
|
private static mapEventToTaskStateMachineEvent(
|
|
193
461
|
ccEvent: CC_EVENTS,
|
|
194
462
|
payload: WebSocketPayload,
|
|
195
|
-
agentId?: string
|
|
463
|
+
agentId?: string,
|
|
464
|
+
task?: ITask,
|
|
465
|
+
enableWxBetterTogether?: boolean
|
|
196
466
|
): TaskEventPayload | null {
|
|
197
467
|
const mediaResourceId =
|
|
198
468
|
payload.mediaResourceId ||
|
|
@@ -226,6 +496,15 @@ export default class TaskManager extends EventEmitter {
|
|
|
226
496
|
return {type: TaskEvent.HYDRATE, taskData: payload, agentId};
|
|
227
497
|
|
|
228
498
|
case CC_EVENTS.CONTACT_UPDATED:
|
|
499
|
+
if (
|
|
500
|
+
task &&
|
|
501
|
+
typeof payload.interaction?.owner === 'string' &&
|
|
502
|
+
payload.interaction.owner.trim().length > 0 &&
|
|
503
|
+
payload.interaction.owner !== task.data?.interaction?.owner
|
|
504
|
+
) {
|
|
505
|
+
return {type: TaskEvent.CONTACT_OWNER_CHANGED, taskData: payload};
|
|
506
|
+
}
|
|
507
|
+
|
|
229
508
|
return {type: TaskEvent.CONTACT_UPDATED, taskData: payload};
|
|
230
509
|
case CC_EVENTS.CONTACT_OWNER_CHANGED:
|
|
231
510
|
return {type: TaskEvent.CONTACT_OWNER_CHANGED, taskData: payload};
|
|
@@ -299,16 +578,39 @@ export default class TaskManager extends EventEmitter {
|
|
|
299
578
|
case CC_EVENTS.AGENT_CONFERENCE_TRANSFER_FAILED:
|
|
300
579
|
return {type: TaskEvent.TRANSFER_FAILED, taskData: payload};
|
|
301
580
|
|
|
302
|
-
case CC_EVENTS.CONTACT_ENDED:
|
|
581
|
+
case CC_EVENTS.CONTACT_ENDED: {
|
|
582
|
+
const wrapUpRequired = isCampaignPreviewTask(payload)
|
|
583
|
+
? false
|
|
584
|
+
: payload.agentsPendingWrapUp?.includes(agentId || '') || false;
|
|
585
|
+
|
|
586
|
+
// Post-accept wxApp outdial agent-end delivers ContactEnded instead of
|
|
587
|
+
// AgentOutboundFailed. Normalize to OUTBOUND_FAILED so state machine
|
|
588
|
+
// enters WRAPPING_UP and emits TASK_OUTDIAL_FAILED (AGENT_ENDS).
|
|
589
|
+
// Pre-accept cancelTask decline stays CONTACT_ENDED → TERMINATED (no wrapup).
|
|
590
|
+
if (
|
|
591
|
+
TaskManager.isAgentTerminatedOutdialWrapup(
|
|
592
|
+
payload,
|
|
593
|
+
wrapUpRequired,
|
|
594
|
+
task,
|
|
595
|
+
agentId,
|
|
596
|
+
enableWxBetterTogether
|
|
597
|
+
)
|
|
598
|
+
) {
|
|
599
|
+
return {
|
|
600
|
+
type: TaskEvent.OUTBOUND_FAILED,
|
|
601
|
+
reason: 'AGENT_ENDS',
|
|
602
|
+
taskData: {...payload, wrapUpRequired: true},
|
|
603
|
+
};
|
|
604
|
+
}
|
|
605
|
+
|
|
303
606
|
return {
|
|
304
607
|
type: TaskEvent.CONTACT_ENDED,
|
|
305
608
|
taskData: {
|
|
306
609
|
...payload,
|
|
307
|
-
wrapUpRequired
|
|
308
|
-
? false
|
|
309
|
-
: payload.agentsPendingWrapUp?.includes(agentId || '') || false,
|
|
610
|
+
wrapUpRequired,
|
|
310
611
|
},
|
|
311
612
|
};
|
|
613
|
+
}
|
|
312
614
|
|
|
313
615
|
case CC_EVENTS.AGENT_INVITE_FAILED:
|
|
314
616
|
return {type: TaskEvent.INVITE_FAILED, reason: payload.reason};
|
|
@@ -319,8 +621,23 @@ export default class TaskManager extends EventEmitter {
|
|
|
319
621
|
case CC_EVENTS.AGENT_CONTACT_OFFER_RONA:
|
|
320
622
|
return {type: TaskEvent.RONA, taskData: payload, reason: payload.reason};
|
|
321
623
|
|
|
322
|
-
case CC_EVENTS.AGENT_OUTBOUND_FAILED:
|
|
323
|
-
|
|
624
|
+
case CC_EVENTS.AGENT_OUTBOUND_FAILED: {
|
|
625
|
+
const isAgentTerminatedOutdial =
|
|
626
|
+
payload.interaction?.outboundType === 'OUTDIAL' &&
|
|
627
|
+
(payload.terminatingParty === 'Agent' || payload.reason === 'AGENT_ENDS');
|
|
628
|
+
|
|
629
|
+
const suppressOutdialFailedPopup =
|
|
630
|
+
isAgentTerminatedOutdial &&
|
|
631
|
+
!TaskManager.isWxAppManagedOutdialTask(agentId, payload, task, enableWxBetterTogether);
|
|
632
|
+
|
|
633
|
+
return {
|
|
634
|
+
type: TaskEvent.OUTBOUND_FAILED,
|
|
635
|
+
taskData: suppressOutdialFailedPopup
|
|
636
|
+
? {...payload, suppressOutdialFailedPopup: true}
|
|
637
|
+
: payload,
|
|
638
|
+
reason: payload.reason,
|
|
639
|
+
};
|
|
640
|
+
}
|
|
324
641
|
|
|
325
642
|
case CC_EVENTS.CAMPAIGN_PREVIEW_ACCEPT_FAILED:
|
|
326
643
|
return {type: TaskEvent.CAMPAIGN_PREVIEW_ACCEPT_FAILED, taskData: payload};
|
|
@@ -371,6 +688,68 @@ export default class TaskManager extends EventEmitter {
|
|
|
371
688
|
}
|
|
372
689
|
}
|
|
373
690
|
|
|
691
|
+
/**
|
|
692
|
+
* True when the current agent's task is a wxApp-managed outdial (thick-client telephony).
|
|
693
|
+
*/
|
|
694
|
+
private static isWxAppManagedOutdialTask(
|
|
695
|
+
agentId: string | undefined,
|
|
696
|
+
payload: WebSocketPayload,
|
|
697
|
+
task: ITask | undefined,
|
|
698
|
+
enableWxBetterTogether?: boolean
|
|
699
|
+
): boolean {
|
|
700
|
+
const wxAppEnabled =
|
|
701
|
+
(task as {uiControlConfig?: {enableWxBetterTogether?: boolean}})?.uiControlConfig
|
|
702
|
+
?.enableWxBetterTogether ??
|
|
703
|
+
enableWxBetterTogether ??
|
|
704
|
+
false;
|
|
705
|
+
|
|
706
|
+
if (!wxAppEnabled) {
|
|
707
|
+
return false;
|
|
708
|
+
}
|
|
709
|
+
|
|
710
|
+
const effectiveAgentId = agentId ?? task?.data?.agentId;
|
|
711
|
+
const participants = payload.interaction?.participants ?? task?.data?.interaction?.participants;
|
|
712
|
+
const details = getWebexCallingDeviceDetailsForAgent(effectiveAgentId, participants);
|
|
713
|
+
|
|
714
|
+
return details?.deviceType === 'wxApp';
|
|
715
|
+
}
|
|
716
|
+
|
|
717
|
+
/**
|
|
718
|
+
* True when ContactEnded represents an agent-terminated wxApp outdial that should
|
|
719
|
+
* enter wrapup with an outdial-failed popup (legacy AgentOutboundFailed parity).
|
|
720
|
+
*/
|
|
721
|
+
private static isAgentTerminatedOutdialWrapup(
|
|
722
|
+
payload: WebSocketPayload,
|
|
723
|
+
wrapUpRequired: boolean,
|
|
724
|
+
task?: ITask,
|
|
725
|
+
agentId?: string,
|
|
726
|
+
enableWxBetterTogether?: boolean
|
|
727
|
+
): boolean {
|
|
728
|
+
const isOutdial = payload.interaction?.outboundType === 'OUTDIAL';
|
|
729
|
+
const agentTerminated = payload.terminatingParty === 'Agent';
|
|
730
|
+
|
|
731
|
+
if (!isOutdial || !agentTerminated) {
|
|
732
|
+
return false;
|
|
733
|
+
}
|
|
734
|
+
|
|
735
|
+
if (!TaskManager.isWxAppManagedOutdialTask(agentId, payload, task, enableWxBetterTogether)) {
|
|
736
|
+
return false;
|
|
737
|
+
}
|
|
738
|
+
|
|
739
|
+
const wxAppAnswerPending =
|
|
740
|
+
(task as {uiControlConfig?: {wxAppAnswerPending?: boolean}})?.uiControlConfig
|
|
741
|
+
?.wxAppAnswerPending ?? false;
|
|
742
|
+
|
|
743
|
+
// Pre-accept decline: decline() clears wxAppAnswerPending; backend may still send state wrapUp.
|
|
744
|
+
if (!wxAppAnswerPending && !wrapUpRequired) {
|
|
745
|
+
return false;
|
|
746
|
+
}
|
|
747
|
+
|
|
748
|
+
const interactionWrapUp = payload.interaction?.state === 'wrapUp';
|
|
749
|
+
|
|
750
|
+
return wrapUpRequired || interactionWrapUp || wxAppAnswerPending;
|
|
751
|
+
}
|
|
752
|
+
|
|
374
753
|
/**
|
|
375
754
|
* Register WebSocket message listeners for task events
|
|
376
755
|
*
|
|
@@ -414,6 +793,15 @@ export default class TaskManager extends EventEmitter {
|
|
|
414
793
|
task.sendStateMachineEvent(stateMachineEvent);
|
|
415
794
|
}
|
|
416
795
|
|
|
796
|
+
// A receiving summary held while the task rang is emitted right after the answer
|
|
797
|
+
// event above (AgentContactAssigned / AgentConsulting) has been emitted.
|
|
798
|
+
const bufferedSummary = this.receivingSummaryBuffer.get(task.data.interactionId);
|
|
799
|
+
const taskState = task.state?.value;
|
|
800
|
+
if (bufferedSummary && taskState !== TaskState.IDLE && taskState !== TaskState.OFFERED) {
|
|
801
|
+
this.receivingSummaryBuffer.delete(task.data.interactionId);
|
|
802
|
+
task.emit(TASK_EVENTS.TASK_MID_CALL_SUMMARY_RECEIVED, bufferedSummary);
|
|
803
|
+
}
|
|
804
|
+
|
|
417
805
|
// Emit TASK_POST_CALL_ACTIVITY for ParticipantPostCallActivity events so
|
|
418
806
|
// consumers (Widgets) can detect the interaction state change to post_call.
|
|
419
807
|
if (eventContext.eventType === CC_EVENTS.PARTICIPANT_POST_CALL_ACTIVITY) {
|
|
@@ -469,6 +857,7 @@ export default class TaskManager extends EventEmitter {
|
|
|
469
857
|
const interactionId = message.data.interactionId;
|
|
470
858
|
const reservationInteractionId = message.data.reservationInteractionId;
|
|
471
859
|
let task = this.taskCollection[interactionId];
|
|
860
|
+
let ownerChangeResolvedByRelatedInteraction = false;
|
|
472
861
|
|
|
473
862
|
// When a campaign preview contact is accepted, the assigned event may arrive
|
|
474
863
|
// with a new interactionId while the task is stored under the original
|
|
@@ -479,9 +868,77 @@ export default class TaskManager extends EventEmitter {
|
|
|
479
868
|
// Re-key the task under the new interaction ID and remove the old entry
|
|
480
869
|
delete this.taskCollection[reservationInteractionId];
|
|
481
870
|
this.taskCollection[interactionId] = task;
|
|
871
|
+
this.pendingFeatureEnablement.delete(reservationInteractionId);
|
|
482
872
|
}
|
|
483
873
|
}
|
|
484
874
|
|
|
875
|
+
if (!task && eventType === CC_EVENTS.CONTACT_OWNER_CHANGED) {
|
|
876
|
+
const incomingShowsCurrentAgentPromotion = Boolean(
|
|
877
|
+
this.agentId &&
|
|
878
|
+
message.data.interaction?.owner === this.agentId &&
|
|
879
|
+
TaskManager.isParticipantActiveOnMainInteraction(message.data, this.agentId)
|
|
880
|
+
);
|
|
881
|
+
|
|
882
|
+
task = this.findUniqueTaskByRelatedInteraction(
|
|
883
|
+
message.data,
|
|
884
|
+
(candidate) => {
|
|
885
|
+
const currentAgentId = this.agentId || candidate.data?.agentId;
|
|
886
|
+
|
|
887
|
+
return Boolean(
|
|
888
|
+
currentAgentId &&
|
|
889
|
+
(TaskManager.isParticipantActiveOnMainInteraction(candidate.data, currentAgentId) ||
|
|
890
|
+
incomingShowsCurrentAgentPromotion)
|
|
891
|
+
);
|
|
892
|
+
},
|
|
893
|
+
{includeCollectionKeys: true, includeMainCallMediaKeys: true}
|
|
894
|
+
);
|
|
895
|
+
ownerChangeResolvedByRelatedInteraction = Boolean(task);
|
|
896
|
+
}
|
|
897
|
+
|
|
898
|
+
let ownerChangeMainInteractionId: string | undefined;
|
|
899
|
+
if (task && eventType === CC_EVENTS.CONTACT_OWNER_CHANGED) {
|
|
900
|
+
const taskMainInteractionId = task.data?.interaction?.mainInteractionId;
|
|
901
|
+
const payloadMainInteractionId = message.data.interaction?.mainInteractionId;
|
|
902
|
+
const hasConflictingMainInteractionIds = Boolean(
|
|
903
|
+
taskMainInteractionId &&
|
|
904
|
+
payloadMainInteractionId &&
|
|
905
|
+
taskMainInteractionId !== payloadMainInteractionId
|
|
906
|
+
);
|
|
907
|
+
// A promoted child task can retain stale embedded IDs. Prefer the
|
|
908
|
+
// authoritative incoming main-call identity before local snapshot IDs.
|
|
909
|
+
const stableMainInteractionId =
|
|
910
|
+
payloadMainInteractionId ||
|
|
911
|
+
TaskManager.getMainCallMediaId(message.data.interaction) ||
|
|
912
|
+
TaskManager.getMainCallMediaId(task.data?.interaction) ||
|
|
913
|
+
taskMainInteractionId ||
|
|
914
|
+
message.data.interaction?.interactionId ||
|
|
915
|
+
task.data?.interaction?.interactionId ||
|
|
916
|
+
task.data?.interactionId;
|
|
917
|
+
const taskAtStableKey = stableMainInteractionId
|
|
918
|
+
? this.taskCollection[stableMainInteractionId]
|
|
919
|
+
: undefined;
|
|
920
|
+
|
|
921
|
+
if (
|
|
922
|
+
!stableMainInteractionId ||
|
|
923
|
+
hasConflictingMainInteractionIds ||
|
|
924
|
+
(taskAtStableKey && taskAtStableKey !== task)
|
|
925
|
+
) {
|
|
926
|
+
LoggerProxy.warn('Unable to safely correlate owner change to the main interaction task', {
|
|
927
|
+
module: TASK_MANAGER_FILE,
|
|
928
|
+
method: 'prepareEventContext',
|
|
929
|
+
interactionId:
|
|
930
|
+
payloadMainInteractionId || taskMainInteractionId || message.data.interactionId,
|
|
931
|
+
});
|
|
932
|
+
task = undefined;
|
|
933
|
+
} else if (ownerChangeResolvedByRelatedInteraction) {
|
|
934
|
+
ownerChangeMainInteractionId = stableMainInteractionId;
|
|
935
|
+
}
|
|
936
|
+
}
|
|
937
|
+
|
|
938
|
+
if (!task && MAIN_INTERACTION_CORRELATED_EVENTS.has(eventType)) {
|
|
939
|
+
task = this.findUniqueTaskByRelatedInteraction(message.data);
|
|
940
|
+
}
|
|
941
|
+
|
|
485
942
|
const wasConsultedTask = Boolean(task?.data?.isConsulted);
|
|
486
943
|
const computeWrapUpRequired = () => {
|
|
487
944
|
if (message.data.wrapUpRequired !== undefined) {
|
|
@@ -494,7 +951,7 @@ export default class TaskManager extends EventEmitter {
|
|
|
494
951
|
return !wasConsultedTask;
|
|
495
952
|
};
|
|
496
953
|
|
|
497
|
-
|
|
954
|
+
let adjustedPayload: WebSocketPayload =
|
|
498
955
|
eventType === CC_EVENTS.AGENT_CONSULT_TRANSFERRED ||
|
|
499
956
|
eventType === CC_EVENTS.AGENT_BLIND_TRANSFERRED ||
|
|
500
957
|
eventType === CC_EVENTS.AGENT_VTEAM_TRANSFERRED
|
|
@@ -504,10 +961,32 @@ export default class TaskManager extends EventEmitter {
|
|
|
504
961
|
}
|
|
505
962
|
: message.data;
|
|
506
963
|
|
|
964
|
+
if (task && ownerChangeMainInteractionId) {
|
|
965
|
+
adjustedPayload = {
|
|
966
|
+
...adjustedPayload,
|
|
967
|
+
interactionId: ownerChangeMainInteractionId,
|
|
968
|
+
};
|
|
969
|
+
}
|
|
970
|
+
|
|
971
|
+
if (task && eventType === CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE) {
|
|
972
|
+
adjustedPayload = TaskManager.preserveConfirmedOwner(task, adjustedPayload);
|
|
973
|
+
}
|
|
974
|
+
|
|
975
|
+
if (WRAP_UP_STAMP_EVENTS.has(eventType)) {
|
|
976
|
+
adjustedPayload = TaskManager.stampWrapUpRequiredForEvent(
|
|
977
|
+
eventType,
|
|
978
|
+
adjustedPayload,
|
|
979
|
+
this.agentId,
|
|
980
|
+
task
|
|
981
|
+
);
|
|
982
|
+
}
|
|
983
|
+
|
|
507
984
|
const stateMachineEvent = TaskManager.mapEventToTaskStateMachineEvent(
|
|
508
985
|
eventType,
|
|
509
986
|
adjustedPayload,
|
|
510
|
-
this.agentId
|
|
987
|
+
this.agentId,
|
|
988
|
+
task,
|
|
989
|
+
this.configFlags?.enableWxBetterTogether
|
|
511
990
|
);
|
|
512
991
|
|
|
513
992
|
LoggerProxy.info(`Handling task event ${eventType}`, {
|
|
@@ -524,6 +1003,160 @@ export default class TaskManager extends EventEmitter {
|
|
|
524
1003
|
};
|
|
525
1004
|
}
|
|
526
1005
|
|
|
1006
|
+
private static isParticipantActiveOnMainInteraction(
|
|
1007
|
+
taskData: TaskData | WebSocketPayload | undefined,
|
|
1008
|
+
participantId: string
|
|
1009
|
+
): boolean {
|
|
1010
|
+
const interaction = taskData?.interaction;
|
|
1011
|
+
const participant = interaction?.participants?.[participantId];
|
|
1012
|
+
if (!participant || participant.hasLeft === true) return false;
|
|
1013
|
+
|
|
1014
|
+
return Object.values(interaction?.media ?? {}).some(
|
|
1015
|
+
(media) =>
|
|
1016
|
+
media?.mType === MEDIA_TYPE_MAIN_CALL && media.participants?.includes(participantId)
|
|
1017
|
+
);
|
|
1018
|
+
}
|
|
1019
|
+
|
|
1020
|
+
private static getMainCallMediaId(
|
|
1021
|
+
interaction: TaskData['interaction'] | undefined
|
|
1022
|
+
): string | undefined {
|
|
1023
|
+
return Object.entries(interaction?.media ?? {}).find(
|
|
1024
|
+
([, media]) => media?.mType === MEDIA_TYPE_MAIN_CALL
|
|
1025
|
+
)?.[0];
|
|
1026
|
+
}
|
|
1027
|
+
|
|
1028
|
+
private static getStableMainInteractionId(payload: WebSocketPayload): string | undefined {
|
|
1029
|
+
return (
|
|
1030
|
+
payload.interaction?.mainInteractionId ||
|
|
1031
|
+
TaskManager.getMainCallMediaId(payload.interaction) ||
|
|
1032
|
+
payload.interaction?.interactionId ||
|
|
1033
|
+
payload.interactionId
|
|
1034
|
+
);
|
|
1035
|
+
}
|
|
1036
|
+
|
|
1037
|
+
private canRecoverTaskFromContactOwnerChanged(payload: WebSocketPayload): boolean {
|
|
1038
|
+
const interaction = payload.interaction;
|
|
1039
|
+
const stableInteractionId = TaskManager.getStableMainInteractionId(payload);
|
|
1040
|
+
|
|
1041
|
+
return Boolean(
|
|
1042
|
+
this.agentId &&
|
|
1043
|
+
stableInteractionId &&
|
|
1044
|
+
interaction?.mediaType === MEDIA_CHANNEL.TELEPHONY &&
|
|
1045
|
+
interaction.isTerminated !== true &&
|
|
1046
|
+
interaction.owner === this.agentId &&
|
|
1047
|
+
TaskManager.isParticipantActiveOnMainInteraction(payload, this.agentId)
|
|
1048
|
+
);
|
|
1049
|
+
}
|
|
1050
|
+
|
|
1051
|
+
/**
|
|
1052
|
+
* ParticipantLeftConference may arrive after an owner update while still carrying
|
|
1053
|
+
* the departed owner. Keep the confirmed owner only when the new roster proves that
|
|
1054
|
+
* owner is active on mainCall and identifies the incoming owner as departed.
|
|
1055
|
+
*/
|
|
1056
|
+
private static preserveConfirmedOwner(task: ITask, payload: WebSocketPayload): WebSocketPayload {
|
|
1057
|
+
const confirmedOwner = task.data?.interaction?.owner;
|
|
1058
|
+
const incomingOwner = payload.interaction?.owner;
|
|
1059
|
+
if (!confirmedOwner || !incomingOwner || confirmedOwner === incomingOwner) {
|
|
1060
|
+
return payload;
|
|
1061
|
+
}
|
|
1062
|
+
|
|
1063
|
+
const confirmedOwnerIsActive = TaskManager.isParticipantActiveOnMainInteraction(
|
|
1064
|
+
payload,
|
|
1065
|
+
confirmedOwner
|
|
1066
|
+
);
|
|
1067
|
+
const incomingOwnerIsExplicitlyDeparted =
|
|
1068
|
+
payload.participantId === incomingOwner ||
|
|
1069
|
+
payload.interaction?.participants?.[incomingOwner]?.hasLeft === true;
|
|
1070
|
+
|
|
1071
|
+
if (!confirmedOwnerIsActive || !incomingOwnerIsExplicitlyDeparted) {
|
|
1072
|
+
return payload;
|
|
1073
|
+
}
|
|
1074
|
+
|
|
1075
|
+
return {
|
|
1076
|
+
...payload,
|
|
1077
|
+
owner: confirmedOwner,
|
|
1078
|
+
interaction: {...payload.interaction, owner: confirmedOwner},
|
|
1079
|
+
};
|
|
1080
|
+
}
|
|
1081
|
+
|
|
1082
|
+
/**
|
|
1083
|
+
* Resolve lifecycle events that are emitted for the main interaction while the
|
|
1084
|
+
* local task can still be indexed by a child consult interaction. Exact task
|
|
1085
|
+
* keys are handled before this fallback. Multiple aliases of the same task are
|
|
1086
|
+
* treated as one candidate; genuinely ambiguous matches are intentionally ignored.
|
|
1087
|
+
*/
|
|
1088
|
+
private findUniqueTaskByRelatedInteraction(
|
|
1089
|
+
payload: WebSocketPayload,
|
|
1090
|
+
candidateFilter: (task: ITask) => boolean = () => true,
|
|
1091
|
+
options: {includeCollectionKeys?: boolean; includeMainCallMediaKeys?: boolean} = {}
|
|
1092
|
+
): ITask | undefined {
|
|
1093
|
+
const candidates = this.findRelatedTasks(payload, options).filter(candidateFilter);
|
|
1094
|
+
|
|
1095
|
+
if (candidates.length === 1) {
|
|
1096
|
+
return candidates[0];
|
|
1097
|
+
}
|
|
1098
|
+
|
|
1099
|
+
if (candidates.length > 1) {
|
|
1100
|
+
LoggerProxy.warn('Unable to correlate task event to a unique main interaction task', {
|
|
1101
|
+
module: TASK_MANAGER_FILE,
|
|
1102
|
+
method: 'findUniqueTaskByRelatedInteraction',
|
|
1103
|
+
interactionId:
|
|
1104
|
+
payload.interaction?.mainInteractionId ||
|
|
1105
|
+
payload.interaction?.parentInteractionId ||
|
|
1106
|
+
payload.interaction?.callProcessingDetails?.parentInteractionId ||
|
|
1107
|
+
payload.interactionId,
|
|
1108
|
+
});
|
|
1109
|
+
}
|
|
1110
|
+
|
|
1111
|
+
return undefined;
|
|
1112
|
+
}
|
|
1113
|
+
|
|
1114
|
+
private findRelatedTasks(
|
|
1115
|
+
payload: WebSocketPayload,
|
|
1116
|
+
options: {includeCollectionKeys?: boolean; includeMainCallMediaKeys?: boolean} = {}
|
|
1117
|
+
): ITask[] {
|
|
1118
|
+
const {includeCollectionKeys = false, includeMainCallMediaKeys = false} = options;
|
|
1119
|
+
const payloadInteractionIds = new Set(
|
|
1120
|
+
[
|
|
1121
|
+
payload.interactionId,
|
|
1122
|
+
payload.interaction?.interactionId,
|
|
1123
|
+
payload.interaction?.mainInteractionId,
|
|
1124
|
+
payload.interaction?.parentInteractionId,
|
|
1125
|
+
payload.interaction?.callProcessingDetails?.parentInteractionId,
|
|
1126
|
+
...(includeMainCallMediaKeys ? [TaskManager.getMainCallMediaId(payload.interaction)] : []),
|
|
1127
|
+
].filter((relatedInteractionId): relatedInteractionId is string =>
|
|
1128
|
+
Boolean(relatedInteractionId)
|
|
1129
|
+
)
|
|
1130
|
+
);
|
|
1131
|
+
if (payloadInteractionIds.size === 0) return [];
|
|
1132
|
+
|
|
1133
|
+
return [
|
|
1134
|
+
...new Set(
|
|
1135
|
+
Object.entries(this.taskCollection)
|
|
1136
|
+
.filter(([taskId, candidate]) => {
|
|
1137
|
+
const taskInteraction = candidate?.data?.interaction;
|
|
1138
|
+
const candidateInteractionIds = [
|
|
1139
|
+
...(includeCollectionKeys ? [taskId] : []),
|
|
1140
|
+
candidate?.data?.interactionId,
|
|
1141
|
+
taskInteraction?.interactionId,
|
|
1142
|
+
taskInteraction?.mainInteractionId,
|
|
1143
|
+
taskInteraction?.parentInteractionId,
|
|
1144
|
+
taskInteraction?.callProcessingDetails?.parentInteractionId,
|
|
1145
|
+
...(includeMainCallMediaKeys
|
|
1146
|
+
? [TaskManager.getMainCallMediaId(taskInteraction)]
|
|
1147
|
+
: []),
|
|
1148
|
+
];
|
|
1149
|
+
|
|
1150
|
+
return candidateInteractionIds.some(
|
|
1151
|
+
(relatedInteractionId) =>
|
|
1152
|
+
Boolean(relatedInteractionId) && payloadInteractionIds.has(relatedInteractionId)
|
|
1153
|
+
);
|
|
1154
|
+
})
|
|
1155
|
+
.map(([, candidate]) => candidate)
|
|
1156
|
+
),
|
|
1157
|
+
];
|
|
1158
|
+
}
|
|
1159
|
+
|
|
527
1160
|
/**
|
|
528
1161
|
* Handle task lifecycle events and determine required actions
|
|
529
1162
|
*
|
|
@@ -549,6 +1182,9 @@ export default class TaskManager extends EventEmitter {
|
|
|
549
1182
|
case CC_EVENTS.CONTACT_MERGED:
|
|
550
1183
|
return this.handleContactMergedEvent(context);
|
|
551
1184
|
|
|
1185
|
+
case CC_EVENTS.CONTACT_OWNER_CHANGED:
|
|
1186
|
+
return this.handleContactOwnerChanged(context);
|
|
1187
|
+
|
|
552
1188
|
case CC_EVENTS.AGENT_OFFER_CAMPAIGN_RESERVATION:
|
|
553
1189
|
return this.handleCampaignPreviewReservation(context);
|
|
554
1190
|
|
|
@@ -560,6 +1196,76 @@ export default class TaskManager extends EventEmitter {
|
|
|
560
1196
|
}
|
|
561
1197
|
}
|
|
562
1198
|
|
|
1199
|
+
/**
|
|
1200
|
+
* Recover the promoted agent's active voice task when local task state was lost.
|
|
1201
|
+
* Existing related tasks are never replaced: an unresolved or ambiguous relation
|
|
1202
|
+
* is safer to ignore than to create a duplicate task.
|
|
1203
|
+
*/
|
|
1204
|
+
private handleContactOwnerChanged(context: EventContext): TaskEventActions {
|
|
1205
|
+
if (context.task) {
|
|
1206
|
+
return {task: context.task};
|
|
1207
|
+
}
|
|
1208
|
+
|
|
1209
|
+
const {payload} = context;
|
|
1210
|
+
if (
|
|
1211
|
+
this.findRelatedTasks(payload, {
|
|
1212
|
+
includeCollectionKeys: true,
|
|
1213
|
+
includeMainCallMediaKeys: true,
|
|
1214
|
+
}).length > 0 ||
|
|
1215
|
+
!this.canRecoverTaskFromContactOwnerChanged(payload)
|
|
1216
|
+
) {
|
|
1217
|
+
return {};
|
|
1218
|
+
}
|
|
1219
|
+
|
|
1220
|
+
const stableInteractionId = TaskManager.getStableMainInteractionId(payload);
|
|
1221
|
+
if (!stableInteractionId || this.taskCollection[stableInteractionId]) {
|
|
1222
|
+
return {};
|
|
1223
|
+
}
|
|
1224
|
+
|
|
1225
|
+
const normalizedPayload: WebSocketPayload =
|
|
1226
|
+
payload.interactionId === stableInteractionId
|
|
1227
|
+
? payload
|
|
1228
|
+
: {...payload, interactionId: stableInteractionId};
|
|
1229
|
+
const taskData: TaskData = {
|
|
1230
|
+
...normalizedPayload,
|
|
1231
|
+
owner: normalizedPayload.interaction.owner,
|
|
1232
|
+
wrapUpRequired: normalizedPayload.interaction.participants?.[this.agentId]?.isWrapUp || false,
|
|
1233
|
+
isConferenceInProgress: getIsConferenceInProgress(normalizedPayload),
|
|
1234
|
+
isConsulted: false,
|
|
1235
|
+
isAutoAnswering: false,
|
|
1236
|
+
};
|
|
1237
|
+
const task = TaskFactory.createTask(
|
|
1238
|
+
this.contact,
|
|
1239
|
+
this.webCallingService,
|
|
1240
|
+
taskData,
|
|
1241
|
+
this.configFlags,
|
|
1242
|
+
this.wrapupData,
|
|
1243
|
+
this.agentId,
|
|
1244
|
+
this.agentName,
|
|
1245
|
+
this.answerCallOnWebexService,
|
|
1246
|
+
this.apiAIAssistant
|
|
1247
|
+
);
|
|
1248
|
+
|
|
1249
|
+
this.taskCollection[stableInteractionId] = task;
|
|
1250
|
+
|
|
1251
|
+
// Restore the actor before installing listeners so the internal hydrate does
|
|
1252
|
+
// not leak as a second public hydrate or as an incoming-task notification.
|
|
1253
|
+
task.sendStateMachineEvent({
|
|
1254
|
+
type: TaskEvent.HYDRATE,
|
|
1255
|
+
taskData,
|
|
1256
|
+
agentId: this.agentId,
|
|
1257
|
+
} as TaskEventPayload);
|
|
1258
|
+
|
|
1259
|
+
this.setupTaskListeners(task);
|
|
1260
|
+
context.payload = taskData;
|
|
1261
|
+
context.stateMachineEvent = {
|
|
1262
|
+
type: TaskEvent.CONTACT_OWNER_CHANGED,
|
|
1263
|
+
taskData,
|
|
1264
|
+
};
|
|
1265
|
+
|
|
1266
|
+
return {task};
|
|
1267
|
+
}
|
|
1268
|
+
|
|
563
1269
|
private handleCampaignContactUpdated(context: EventContext) {
|
|
564
1270
|
const {payload} = context;
|
|
565
1271
|
let {task} = context;
|
|
@@ -647,7 +1353,10 @@ export default class TaskManager extends EventEmitter {
|
|
|
647
1353
|
},
|
|
648
1354
|
this.configFlags,
|
|
649
1355
|
this.wrapupData,
|
|
650
|
-
this.agentId
|
|
1356
|
+
this.agentId,
|
|
1357
|
+
this.agentName,
|
|
1358
|
+
this.answerCallOnWebexService,
|
|
1359
|
+
this.apiAIAssistant
|
|
651
1360
|
);
|
|
652
1361
|
this.setupTaskListeners(task);
|
|
653
1362
|
this.taskCollection[payload.interactionId] = task;
|
|
@@ -685,7 +1394,10 @@ export default class TaskManager extends EventEmitter {
|
|
|
685
1394
|
taskData,
|
|
686
1395
|
this.configFlags,
|
|
687
1396
|
this.wrapupData,
|
|
688
|
-
this.agentId
|
|
1397
|
+
this.agentId,
|
|
1398
|
+
this.agentName,
|
|
1399
|
+
this.answerCallOnWebexService,
|
|
1400
|
+
this.apiAIAssistant
|
|
689
1401
|
);
|
|
690
1402
|
|
|
691
1403
|
this.setupTaskListeners(task);
|
|
@@ -725,7 +1437,10 @@ export default class TaskManager extends EventEmitter {
|
|
|
725
1437
|
taskData,
|
|
726
1438
|
this.configFlags,
|
|
727
1439
|
this.wrapupData,
|
|
728
|
-
this.agentId
|
|
1440
|
+
this.agentId,
|
|
1441
|
+
this.agentName,
|
|
1442
|
+
this.answerCallOnWebexService,
|
|
1443
|
+
this.apiAIAssistant
|
|
729
1444
|
);
|
|
730
1445
|
this.setupTaskListeners(task);
|
|
731
1446
|
this.taskCollection[payload.interactionId] = task;
|
|
@@ -753,7 +1468,19 @@ export default class TaskManager extends EventEmitter {
|
|
|
753
1468
|
: taskData;
|
|
754
1469
|
|
|
755
1470
|
task.updateTaskData(updateTaskData);
|
|
1471
|
+
|
|
1472
|
+
// A main-interaction lifecycle event can re-key a child consult task. Remove
|
|
1473
|
+
// any aliases first so consumers never observe duplicate task entries.
|
|
1474
|
+
Object.entries(this.taskCollection).forEach(([taskId, candidate]) => {
|
|
1475
|
+
if (candidate === task && taskId !== taskData.interactionId) {
|
|
1476
|
+
delete this.taskCollection[taskId];
|
|
1477
|
+
}
|
|
1478
|
+
});
|
|
756
1479
|
this.taskCollection[taskData.interactionId] = task;
|
|
1480
|
+
const enablement = this.pendingFeatureEnablement.get(task.data.interactionId);
|
|
1481
|
+
if (enablement) {
|
|
1482
|
+
task.setFeatureEnablement?.(enablement);
|
|
1483
|
+
}
|
|
757
1484
|
|
|
758
1485
|
return task;
|
|
759
1486
|
}
|
|
@@ -763,31 +1490,46 @@ export default class TaskManager extends EventEmitter {
|
|
|
763
1490
|
* This replaces the previous callback injection pattern
|
|
764
1491
|
*/
|
|
765
1492
|
private setupTaskListeners(task: ITask): void {
|
|
766
|
-
//
|
|
767
|
-
|
|
768
|
-
|
|
769
|
-
|
|
770
|
-
|
|
771
|
-
interactionId: t.data?.interactionId,
|
|
772
|
-
});
|
|
773
|
-
|
|
774
|
-
this.emit(TASK_EVENTS.TASK_INCOMING, t);
|
|
775
|
-
});
|
|
1493
|
+
// Apply flags before publication; retain the frame until consumers can attach listeners.
|
|
1494
|
+
const enablement = this.pendingFeatureEnablement.get(task.data.interactionId);
|
|
1495
|
+
if (enablement) {
|
|
1496
|
+
task.setFeatureEnablement?.(enablement);
|
|
1497
|
+
}
|
|
776
1498
|
|
|
777
|
-
|
|
778
|
-
|
|
779
|
-
|
|
780
|
-
|
|
781
|
-
|
|
782
|
-
|
|
1499
|
+
[
|
|
1500
|
+
TASK_EVENTS.TASK_INCOMING,
|
|
1501
|
+
TASK_EVENTS.TASK_CAMPAIGN_PREVIEW_RESERVATION,
|
|
1502
|
+
TASK_EVENTS.TASK_HYDRATE,
|
|
1503
|
+
TASK_EVENTS.TASK_ASSIGNED,
|
|
1504
|
+
].forEach((eventName) => {
|
|
1505
|
+
task.on(eventName, (t: ITask) => {
|
|
1506
|
+
if (
|
|
1507
|
+
eventName === TASK_EVENTS.TASK_INCOMING ||
|
|
1508
|
+
eventName === TASK_EVENTS.TASK_CAMPAIGN_PREVIEW_RESERVATION
|
|
1509
|
+
) {
|
|
1510
|
+
LoggerProxy.log(
|
|
1511
|
+
eventName === TASK_EVENTS.TASK_INCOMING
|
|
1512
|
+
? 'Task incoming event received'
|
|
1513
|
+
: 'Campaign preview reservation event received',
|
|
1514
|
+
{
|
|
1515
|
+
module: TASK_MANAGER_FILE,
|
|
1516
|
+
method: METHODS.REGISTER_TASK_LISTENERS,
|
|
1517
|
+
interactionId: t.data?.interactionId,
|
|
1518
|
+
}
|
|
1519
|
+
);
|
|
1520
|
+
}
|
|
783
1521
|
|
|
784
|
-
|
|
785
|
-
|
|
1522
|
+
// Assignment is already emitted on the task; the other events publish it to consumers.
|
|
1523
|
+
if (eventName !== TASK_EVENTS.TASK_ASSIGNED) {
|
|
1524
|
+
this.emit(eventName, t);
|
|
1525
|
+
}
|
|
786
1526
|
|
|
787
|
-
|
|
788
|
-
|
|
789
|
-
|
|
790
|
-
|
|
1527
|
+
const pendingEnablement = this.pendingFeatureEnablement.get(task.data.interactionId);
|
|
1528
|
+
if (pendingEnablement) {
|
|
1529
|
+
this.pendingFeatureEnablement.delete(task.data.interactionId);
|
|
1530
|
+
task.emit(TASK_EVENTS.TASK_FEATURE_ENABLEMENT, pendingEnablement);
|
|
1531
|
+
}
|
|
1532
|
+
});
|
|
791
1533
|
});
|
|
792
1534
|
|
|
793
1535
|
task.on(TASK_EVENTS.TASK_MULTI_LOGIN_HYDRATE, (t: ITask) => {
|
|
@@ -798,8 +1540,10 @@ export default class TaskManager extends EventEmitter {
|
|
|
798
1540
|
task.on(TASK_EVENTS.TASK_CLEANUP, (t: ITask, options?: {removeFromCollection?: boolean}) => {
|
|
799
1541
|
this.handleTaskCleanup(t);
|
|
800
1542
|
if (options?.removeFromCollection) {
|
|
801
|
-
const
|
|
802
|
-
|
|
1543
|
+
const taskIsStillCollected = Object.values(this.taskCollection).some(
|
|
1544
|
+
(candidate) => candidate === t
|
|
1545
|
+
);
|
|
1546
|
+
if (taskIsStillCollected) {
|
|
803
1547
|
this.removeTaskFromCollection(t);
|
|
804
1548
|
}
|
|
805
1549
|
}
|
|
@@ -807,11 +1551,21 @@ export default class TaskManager extends EventEmitter {
|
|
|
807
1551
|
}
|
|
808
1552
|
|
|
809
1553
|
private removeTaskFromCollection(task: ITask) {
|
|
1554
|
+
task.clearFeatureEnablement?.();
|
|
1555
|
+
task.disposeWxAppOfferObservability?.();
|
|
810
1556
|
if (typeof task.cancelAutoWrapupTimer === 'function') {
|
|
811
1557
|
task.cancelAutoWrapupTimer();
|
|
812
1558
|
}
|
|
813
1559
|
if (task?.data?.interactionId) {
|
|
814
|
-
|
|
1560
|
+
this.pendingFeatureEnablement.delete(task.data.interactionId);
|
|
1561
|
+
// An offer that ends unanswered (RONA, declined, consult cancelled) is removed here,
|
|
1562
|
+
// so its held receiving summary is dropped instead of being emitted.
|
|
1563
|
+
this.receivingSummaryBuffer.delete(task.data.interactionId);
|
|
1564
|
+
Object.entries(this.taskCollection).forEach(([taskId, candidate]) => {
|
|
1565
|
+
if (candidate === task) {
|
|
1566
|
+
delete this.taskCollection[taskId];
|
|
1567
|
+
}
|
|
1568
|
+
});
|
|
815
1569
|
LoggerProxy.info(`Task removed from collection`, {
|
|
816
1570
|
module: TASK_MANAGER_FILE,
|
|
817
1571
|
method: METHODS.REMOVE_TASK_FROM_COLLECTION,
|
|
@@ -864,7 +1618,10 @@ export default class TaskManager extends EventEmitter {
|
|
|
864
1618
|
taskData,
|
|
865
1619
|
this.configFlags,
|
|
866
1620
|
this.wrapupData,
|
|
867
|
-
this.agentId
|
|
1621
|
+
this.agentId,
|
|
1622
|
+
this.agentName,
|
|
1623
|
+
this.answerCallOnWebexService,
|
|
1624
|
+
this.apiAIAssistant
|
|
868
1625
|
);
|
|
869
1626
|
this.taskCollection[payload.interactionId] = task;
|
|
870
1627
|
|
|
@@ -884,6 +1641,11 @@ export default class TaskManager extends EventEmitter {
|
|
|
884
1641
|
|
|
885
1642
|
if (task) {
|
|
886
1643
|
this.emit(TASK_EVENTS.TASK_MERGED, task);
|
|
1644
|
+
const enablement = this.pendingFeatureEnablement.get(task.data.interactionId);
|
|
1645
|
+
if (enablement) {
|
|
1646
|
+
this.pendingFeatureEnablement.delete(task.data.interactionId);
|
|
1647
|
+
task.emit(TASK_EVENTS.TASK_FEATURE_ENABLEMENT, enablement);
|
|
1648
|
+
}
|
|
887
1649
|
}
|
|
888
1650
|
|
|
889
1651
|
return {task};
|
|
@@ -956,6 +1718,60 @@ export default class TaskManager extends EventEmitter {
|
|
|
956
1718
|
return {...this.taskCollection};
|
|
957
1719
|
}
|
|
958
1720
|
|
|
1721
|
+
/**
|
|
1722
|
+
* Propagate runtime enableWxBetterTogether changes to config flags and active tasks.
|
|
1723
|
+
*/
|
|
1724
|
+
public applyEnableWxBetterTogether(enabled: boolean): void {
|
|
1725
|
+
if (this.configFlags) {
|
|
1726
|
+
this.configFlags = {...this.configFlags, enableWxBetterTogether: enabled};
|
|
1727
|
+
}
|
|
1728
|
+
|
|
1729
|
+
Object.values(this.taskCollection).forEach((task) => {
|
|
1730
|
+
task.setEnableWxBetterTogether(enabled);
|
|
1731
|
+
if (enabled) {
|
|
1732
|
+
TaskManager.syncWxAppMuteFromCallDetailsForTask(task);
|
|
1733
|
+
}
|
|
1734
|
+
});
|
|
1735
|
+
}
|
|
1736
|
+
|
|
1737
|
+
/**
|
|
1738
|
+
* Propagate wxApp mute state from Mercury sync to active voice tasks.
|
|
1739
|
+
*/
|
|
1740
|
+
public applyWxAppMuteStateFromSync(callId: string, muted: boolean): void {
|
|
1741
|
+
Object.values(this.taskCollection).forEach((task) => {
|
|
1742
|
+
task.applyWxAppMuteStateFromSync(callId, muted);
|
|
1743
|
+
});
|
|
1744
|
+
}
|
|
1745
|
+
|
|
1746
|
+
/**
|
|
1747
|
+
* Re-seeds wxApp mute state from GET telephony/calls/{callId} for one task.
|
|
1748
|
+
*/
|
|
1749
|
+
public static syncWxAppMuteFromCallDetailsForTask(task: ITask): void {
|
|
1750
|
+
const sync = task.syncWxAppMuteFromCallDetails?.bind(task);
|
|
1751
|
+
if (typeof sync === 'function') {
|
|
1752
|
+
sync().catch(() => undefined);
|
|
1753
|
+
}
|
|
1754
|
+
}
|
|
1755
|
+
|
|
1756
|
+
/**
|
|
1757
|
+
* Re-seeds wxApp mute for all engaged voice tasks (reload / runtime enable backfill).
|
|
1758
|
+
*/
|
|
1759
|
+
public syncWxAppMuteFromCallDetailsForAllTasks(): void {
|
|
1760
|
+
Object.values(this.taskCollection).forEach((task) => {
|
|
1761
|
+
TaskManager.syncWxAppMuteFromCallDetailsForTask(task);
|
|
1762
|
+
});
|
|
1763
|
+
}
|
|
1764
|
+
|
|
1765
|
+
/**
|
|
1766
|
+
* Re-run OFFERED wxApp offer diagnostics for collected voice tasks.
|
|
1767
|
+
* Used after usersub publish so pre-publish offers can schedule mismatch grace.
|
|
1768
|
+
*/
|
|
1769
|
+
public refreshWxAppOfferObservabilityForAllTasks(): void {
|
|
1770
|
+
Object.values(this.taskCollection).forEach((task) => {
|
|
1771
|
+
task.refreshWxAppOfferObservability?.();
|
|
1772
|
+
});
|
|
1773
|
+
}
|
|
1774
|
+
|
|
959
1775
|
public static getTaskManager(
|
|
960
1776
|
apiAIAssistant: ApiAIAssistant,
|
|
961
1777
|
contact: ReturnType<typeof routingContact>,
|