Merge root message entities in Activity

packages/api/src/activities/activity.spec.ts

@@ -139,6 +139,62 @@ describe('Activity', () => {
     });
   });
 
+  describe('addEntity/addEntities', () => {
+    it('should merge multiple root message entities into one', () => {
+      const activity = new Activity({ type: 'test' })
+        .addEntity({
+          type: 'https://schema.org/Message',
+          '@type': 'Message',
+          '@context': 'https://schema.org',
+          '@id': '',
+          additionalType: ['AIGeneratedContent'],
+          citation: [
+            {
+              '@type': 'Claim',
+              position: 0,
+              appearance: {
+                '@type': 'DigitalDocument',
+                name: 'old doc',
+                abstract: 'old abstract',
+              },
+            },
+          ],
+        })
+        .addEntities(
+          {
+            type: 'mention',
+            text: '<at>test-bot</at>',
+            mentioned: bot,
+          },
+          {
+            type: 'https://schema.org/Message',
+            '@type': 'Message',
+            '@context': 'https://schema.org',
+            '@id': '',
+            citation: [
+              {
+                '@type': 'Claim',
+                position: 0,
+                appearance: {
+                  '@type': 'DigitalDocument',
+                  name: 'doc',
+                  abstract: 'doc abstract',
+                },
+              },
+            ],
+          }
+        );
+
+      expect(activity.entities).toHaveLength(2);
+      const [messageEntity, mentionEntity] = activity.entities as any[];
+      expect(messageEntity.type).toBe('https://schema.org/Message');
+      expect(messageEntity.additionalType).toEqual(['AIGeneratedContent']);
+      expect(messageEntity.citation).toHaveLength(1);
+      expect(messageEntity.citation[0].appearance.abstract).toBe('doc abstract');
+      expect(mentionEntity.type).toBe('mention');
+    });
+  });
+
   describe('withChannelData feedback normalization', () => {
     it('should upgrade legacy feedbackLoopEnabled:true to feedbackLoop default', () => {
       const activity = new Activity({ type: 'test' }).withChannelData({ feedbackLoopEnabled: true });

packages/api/src/activities/activity.ts

@@ -335,6 +335,11 @@ export class Activity<T extends string = string> implements IActivity<T> {
    * Add an entity.
    */
   addEntity(value: Entity) {
+    if (this.isRootLevelMessageEntity(value)) {
+      this.mergeRootLevelMessageEntity(this.ensureSingleRootLevelMessageEntity(), value);
+      return this;
+    }
+
     if (!this.entities) {
       this.entities = [];
     }
@@ -347,11 +352,10 @@ export class Activity<T extends string = string> implements IActivity<T> {
    * Add multiple entities
    */
   addEntities(...value: Entity[]) {
-    if (!this.entities) {
-      this.entities = [];
+    for (const entity of value) {
+      this.addEntity(entity);
     }
 
-    this.entities.push(...value);
     return this;
   }
 
@@ -467,20 +471,53 @@ export class Activity<T extends string = string> implements IActivity<T> {
    * There should only be one root level message entity.
    */
   private ensureSingleRootLevelMessageEntity(): MessageEntity {
-    let mesageEntity = this.entities?.find(
-      (e) => e.type === 'https://schema.org/Message' && e['@type'] === 'Message'
+    let messageEntity = this.entities?.find(
+      (e) => this.isRootLevelMessageEntity(e)
     ) as MessageEntity | undefined;
 
-    if (!mesageEntity) {
-      mesageEntity = {
+    if (!messageEntity) {
+      messageEntity = {
         type: 'https://schema.org/Message',
         '@type': 'Message',
         '@context': 'https://schema.org',
         '@id': '',
       };
-      this.addEntity(mesageEntity);
+      if (!this.entities) {
+        this.entities = [];
+      }
+      this.entities.push(messageEntity);
+    }
+
+    return messageEntity;
+  }
+
+  private isRootLevelMessageEntity(entity: Entity): entity is MessageEntity {
+    return entity.type === 'https://schema.org/Message' && entity['@type'] === 'Message';
+  }
+
+  private mergeRootLevelMessageEntity(target: MessageEntity, source: MessageEntity): MessageEntity {
+    const merged: MessageEntity = {
+      ...target,
+      ...source,
+    };
+
+    if (target.additionalType || source.additionalType) {
+      merged.additionalType = [
+        ...new Set([...(target.additionalType || []), ...(source.additionalType || [])]),
+      ];
+    }
+
+    if (target.citation || source.citation) {
+      const dedupedCitations = new Map<number, NonNullable<typeof target.citation>[number]>();
+
+      for (const citation of [...(target.citation || []), ...(source.citation || [])]) {
+        dedupedCitations.set(citation.position, citation);
+      }
+
+      merged.citation = Array.from(dedupedCitations.values());
     }
 
-    return mesageEntity;
+    Object.assign(target, merged);
+    return target;
   }
 }