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

package/dist/services/task/TaskManager.js

@@ -690,6 +690,7 @@ class TaskManager extends _events.default {
     const interactionId = message.data.interactionId;
     const reservationInteractionId = message.data.reservationInteractionId;
     let task = this.taskCollection[interactionId];
+    let ownerChangeResolvedByRelatedInteraction = false;
 
     // When a campaign preview contact is accepted, the assigned event may arrive
     // with a new interactionId while the task is stored under the original
@@ -703,7 +704,35 @@ class TaskManager extends _events.default {
       }
     }
     if (!task && eventType === _types2.CC_EVENTS.CONTACT_OWNER_CHANGED) {
-      task = this.findTaskForContactOwnerChange(message.data);
+      const incomingShowsCurrentAgentPromotion = Boolean(this.agentId && message.data.interaction?.owner === this.agentId && TaskManager.isParticipantActiveOnMainInteraction(message.data, this.agentId));
+      task = this.findUniqueTaskByRelatedInteraction(message.data, candidate => {
+        const currentAgentId = this.agentId || candidate.data?.agentId;
+        return Boolean(currentAgentId && (TaskManager.isParticipantActiveOnMainInteraction(candidate.data, currentAgentId) || incomingShowsCurrentAgentPromotion));
+      }, {
+        includeCollectionKeys: true,
+        includeMainCallMediaKeys: true
+      });
+      ownerChangeResolvedByRelatedInteraction = Boolean(task);
+    }
+    let ownerChangeMainInteractionId;
+    if (task && eventType === _types2.CC_EVENTS.CONTACT_OWNER_CHANGED) {
+      const taskMainInteractionId = task.data?.interaction?.mainInteractionId;
+      const payloadMainInteractionId = message.data.interaction?.mainInteractionId;
+      const hasConflictingMainInteractionIds = Boolean(taskMainInteractionId && payloadMainInteractionId && taskMainInteractionId !== payloadMainInteractionId);
+      // A promoted child task can retain stale embedded IDs. Prefer the
+      // authoritative incoming main-call identity before local snapshot IDs.
+      const stableMainInteractionId = payloadMainInteractionId || TaskManager.getMainCallMediaId(message.data.interaction) || TaskManager.getMainCallMediaId(task.data?.interaction) || taskMainInteractionId || message.data.interaction?.interactionId || task.data?.interaction?.interactionId || task.data?.interactionId;
+      const taskAtStableKey = stableMainInteractionId ? this.taskCollection[stableMainInteractionId] : undefined;
+      if (!stableMainInteractionId || hasConflictingMainInteractionIds || taskAtStableKey && taskAtStableKey !== task) {
+        _loggerProxy.default.warn('Unable to safely correlate owner change to the main interaction task', {
+          module: _constants.TASK_MANAGER_FILE,
+          method: 'prepareEventContext',
+          interactionId: payloadMainInteractionId || taskMainInteractionId || message.data.interactionId
+        });
+        task = undefined;
+      } else if (ownerChangeResolvedByRelatedInteraction) {
+        ownerChangeMainInteractionId = stableMainInteractionId;
+      }
     }
     if (!task && MAIN_INTERACTION_CORRELATED_EVENTS.has(eventType)) {
       task = this.findUniqueTaskByRelatedInteraction(message.data);
@@ -722,8 +751,11 @@ class TaskManager extends _events.default {
       ...message.data,
       wrapUpRequired: computeWrapUpRequired()
     } : message.data;
-    if (task && eventType === _types2.CC_EVENTS.CONTACT_OWNER_CHANGED) {
-      adjustedPayload = TaskManager.preserveMainTaskIdentity(task, adjustedPayload);
+    if (task && ownerChangeMainInteractionId) {
+      adjustedPayload = {
+        ...adjustedPayload,
+        interactionId: ownerChangeMainInteractionId
+      };
     }
     if (task && eventType === _types2.CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE) {
       adjustedPayload = TaskManager.preserveConfirmedOwner(task, adjustedPayload);
@@ -744,47 +776,12 @@ class TaskManager extends _events.default {
       stateMachineEvent
     };
   }
-
-  /**
-   * ContactOwnerChanged can identify the promoted agent's child interaction while
-   * the surviving task is stored under the main interaction. Accept one related
-   * task when its existing snapshot or the authoritative incoming promotion proves
-   * current-agent main-call membership, while excluding non-promoted and ambiguous matches.
-   */
-  findTaskForContactOwnerChange(payload) {
-    const relatedCandidates = this.findRelatedTasks(payload, {
-      includeCollectionKeys: true,
-      includeMainCallMediaKeys: true
-    });
-    const incomingShowsCurrentAgentPromotion = this.isCurrentAgentPromotedOnIncomingMainCall(payload);
-    const eligibleCandidates = relatedCandidates.filter(candidate => this.isCurrentAgentActiveOnMainInteraction(candidate.data) || incomingShowsCurrentAgentPromotion);
-    if (eligibleCandidates.length === 1) {
-      return eligibleCandidates[0];
-    }
-    if (eligibleCandidates.length > 1) {
-      _loggerProxy.default.warn('Unable to correlate task event to a unique main interaction task', {
-        module: _constants.TASK_MANAGER_FILE,
-        method: 'findTaskForContactOwnerChange',
-        interactionId: payload.interaction?.mainInteractionId || payload.interaction?.parentInteractionId || payload.interaction?.callProcessingDetails?.parentInteractionId || payload.interactionId
-      });
-      return undefined;
-    }
-    return undefined;
-  }
-  isCurrentAgentActiveOnMainInteraction(taskData) {
-    const currentAgentId = this.agentId || taskData?.agentId;
-    if (!currentAgentId) return false;
-    return TaskManager.isParticipantActiveOnMainInteraction(taskData, currentAgentId);
-  }
   static isParticipantActiveOnMainInteraction(taskData, participantId) {
     const interaction = taskData?.interaction;
     const participant = interaction?.participants?.[participantId];
     if (!participant || participant.hasLeft === true) return false;
     return Object.values(interaction?.media ?? {}).some(media => media?.mType === _constants3.MEDIA_TYPE_MAIN_CALL && media.participants?.includes(participantId));
   }
-  isCurrentAgentPromotedOnIncomingMainCall(payload) {
-    return Boolean(this.agentId && payload.interaction?.owner === this.agentId && TaskManager.isParticipantActiveOnMainInteraction(payload, this.agentId));
-  }
   static getMainCallMediaId(interaction) {
     return Object.entries(interaction?.media ?? {}).find(([, media]) => media?.mType === _constants3.MEDIA_TYPE_MAIN_CALL)?.[0];
   }
@@ -797,22 +794,6 @@ class TaskManager extends _events.default {
     return Boolean(this.agentId && stableInteractionId && interaction?.mediaType === _types.MEDIA_CHANNEL.TELEPHONY && interaction.isTerminated !== true && interaction.owner === this.agentId && TaskManager.isParticipantActiveOnMainInteraction(payload, this.agentId));
   }
 
-  /** Keep a related owner-change event from re-keying the surviving main task to a child ID. */
-  static preserveMainTaskIdentity(task, payload) {
-    const currentMainInteractionId = task.data?.interaction?.mainInteractionId;
-    const payloadMainInteractionId = payload.interaction?.mainInteractionId;
-    const currentMainMediaId = TaskManager.getMainCallMediaId(task.data?.interaction);
-    const payloadMainMediaId = TaskManager.getMainCallMediaId(payload.interaction);
-    const stableInteractionId = currentMainInteractionId || payloadMainInteractionId || currentMainMediaId || payloadMainMediaId || payload.interaction?.interactionId || task.data?.interaction?.interactionId || task.data?.interactionId;
-    if (!stableInteractionId || stableInteractionId === payload.interactionId) {
-      return payload;
-    }
-    return {
-      ...payload,
-      interactionId: stableInteractionId
-    };
-  }
-
   /**
    * ParticipantLeftConference may arrive after an owner update while still carrying
    * the departed owner. Keep the confirmed owner only when the new roster proves that
@@ -845,8 +826,8 @@ class TaskManager extends _events.default {
    * keys are handled before this fallback. Multiple aliases of the same task are
    * treated as one candidate; genuinely ambiguous matches are intentionally ignored.
    */
-  findUniqueTaskByRelatedInteraction(payload, candidateFilter = () => true) {
-    const candidates = this.findRelatedTasks(payload).filter(candidateFilter);
+  findUniqueTaskByRelatedInteraction(payload, candidateFilter = () => true, options = {}) {
+    const candidates = this.findRelatedTasks(payload, options).filter(candidateFilter);
     if (candidates.length === 1) {
       return candidates[0];
     }
@@ -864,12 +845,12 @@ class TaskManager extends _events.default {
       includeCollectionKeys = false,
       includeMainCallMediaKeys = false
     } = options;
-    const payloadInteractionIds = new Set([payload.interactionId, payload.interaction?.interactionId, payload.interaction?.mainInteractionId, payload.interaction?.parentInteractionId, payload.interaction?.callProcessingDetails?.parentInteractionId, ...(includeMainCallMediaKeys ? [TaskManager.getMainCallMediaId(payload.interaction)] : [])].filter(interactionId => Boolean(interactionId)));
+    const payloadInteractionIds = new Set([payload.interactionId, payload.interaction?.interactionId, payload.interaction?.mainInteractionId, payload.interaction?.parentInteractionId, payload.interaction?.callProcessingDetails?.parentInteractionId, ...(includeMainCallMediaKeys ? [TaskManager.getMainCallMediaId(payload.interaction)] : [])].filter(relatedInteractionId => Boolean(relatedInteractionId)));
     if (payloadInteractionIds.size === 0) return [];
     return [...new Set(Object.entries(this.taskCollection).filter(([taskId, candidate]) => {
       const taskInteraction = candidate?.data?.interaction;
       const candidateInteractionIds = [...(includeCollectionKeys ? [taskId] : []), candidate?.data?.interactionId, taskInteraction?.interactionId, taskInteraction?.mainInteractionId, taskInteraction?.parentInteractionId, taskInteraction?.callProcessingDetails?.parentInteractionId, ...(includeMainCallMediaKeys ? [TaskManager.getMainCallMediaId(taskInteraction)] : [])];
-      return candidateInteractionIds.some(interactionId => Boolean(interactionId) && payloadInteractionIds.has(interactionId));
+      return candidateInteractionIds.some(relatedInteractionId => Boolean(relatedInteractionId) && payloadInteractionIds.has(relatedInteractionId));
     }).map(([, candidate]) => candidate))];
   }
 
@@ -1180,6 +1161,7 @@ class TaskManager extends _events.default {
     });
   }
   removeTaskFromCollection(task) {
+    task.disposeWxAppOfferObservability?.();
     if (typeof task.cancelAutoWrapupTimer === 'function') {
       task.cancelAutoWrapupTimer();
     }
@@ -1353,6 +1335,16 @@ class TaskManager extends _events.default {
       TaskManager.syncWxAppMuteFromCallDetailsForTask(task);
     });
   }
+
+  /**
+   * Re-run OFFERED wxApp offer diagnostics for collected voice tasks.
+   * Used after usersub publish so pre-publish offers can schedule mismatch grace.
+   */
+  refreshWxAppOfferObservabilityForAllTasks() {
+    Object.values(this.taskCollection).forEach(task => {
+      task.refreshWxAppOfferObservability?.();
+    });
+  }
   static getTaskManager(apiAIAssistant, contact, webCallingService, webSocketManager, rtdWebSocketManager) {
     if (!TaskManager.taskManager) {
       TaskManager.taskManager = new TaskManager(apiAIAssistant, contact, webCallingService, webSocketManager, rtdWebSocketManager);