@librechat/agents 3.0.56 → 3.0.61

package/src/messages/formatAgentMessages.test.ts

@@ -1141,251 +1141,4 @@ describe('formatAgentMessages', () => {
     expect(result.messages[1].name).toBe('search');
     expect(result.messages[1].content).toBe('');
   });
-
-  describe('targetAgentId filtering', () => {
-    it('should filter content parts to only include those from targetAgentId', () => {
-      const payload: TPayload = [
-        { role: 'user', content: 'Hello' },
-        {
-          role: 'assistant',
-          content: [
-            { type: ContentTypes.TEXT, text: 'Response from agent_a' },
-            { type: ContentTypes.TEXT, text: 'Response from agent_b' },
-            { type: ContentTypes.TEXT, text: 'Another from agent_a' },
-          ],
-        },
-      ];
-
-      const contentMetadataMap = new Map([
-        [0, { agentId: 'agent_a' }],
-        [1, { agentId: 'agent_b' }],
-        [2, { agentId: 'agent_a' }],
-      ]);
-
-      const result = formatAgentMessages(payload, undefined, undefined, {
-        targetAgentId: 'agent_a',
-        contentMetadataMap,
-      });
-
-      // Should have user message + filtered assistant message
-      expect(result.messages).toHaveLength(2);
-      expect(result.messages[0]).toBeInstanceOf(HumanMessage);
-      expect(result.messages[1]).toBeInstanceOf(AIMessage);
-
-      // The AIMessage should only have agent_a's content parts
-      const aiMessage = result.messages[1] as AIMessage;
-      expect(Array.isArray(aiMessage.content)).toBe(true);
-      expect(aiMessage.content as Array<{ text: string }>).toHaveLength(2);
-      expect((aiMessage.content as Array<{ text: string }>)[0].text).toBe(
-        'Response from agent_a'
-      );
-      expect((aiMessage.content as Array<{ text: string }>)[1].text).toBe(
-        'Another from agent_a'
-      );
-    });
-
-    it('should skip assistant message entirely if no content parts match targetAgentId', () => {
-      const payload: TPayload = [
-        { role: 'user', content: 'Hello' },
-        {
-          role: 'assistant',
-          content: [{ type: ContentTypes.TEXT, text: 'Response from agent_b' }],
-        },
-      ];
-
-      const contentMetadataMap = new Map([[0, { agentId: 'agent_b' }]]);
-
-      const result = formatAgentMessages(payload, undefined, undefined, {
-        targetAgentId: 'agent_a',
-        contentMetadataMap,
-      });
-
-      // Should only have the user message, assistant message skipped
-      expect(result.messages).toHaveLength(1);
-      expect(result.messages[0]).toBeInstanceOf(HumanMessage);
-    });
-
-    it('should not filter when targetAgentId is not provided', () => {
-      const payload: TPayload = [
-        {
-          role: 'assistant',
-          content: [
-            { type: ContentTypes.TEXT, text: 'Response from agent_a' },
-            { type: ContentTypes.TEXT, text: 'Response from agent_b' },
-          ],
-        },
-      ];
-
-      const contentMetadataMap = new Map([
-        [0, { agentId: 'agent_a' }],
-        [1, { agentId: 'agent_b' }],
-      ]);
-
-      // No targetAgentId provided - should include all content
-      const result = formatAgentMessages(payload, undefined, undefined, {
-        contentMetadataMap,
-      });
-
-      expect(result.messages).toHaveLength(1);
-      const aiMessage = result.messages[0] as AIMessage;
-      expect(Array.isArray(aiMessage.content)).toBe(true);
-      expect(aiMessage.content as Array<{ text: string }>).toHaveLength(2);
-    });
-
-    it('should not filter when contentMetadataMap is not provided', () => {
-      const payload: TPayload = [
-        {
-          role: 'assistant',
-          content: [
-            { type: ContentTypes.TEXT, text: 'Response 1' },
-            { type: ContentTypes.TEXT, text: 'Response 2' },
-          ],
-        },
-      ];
-
-      // targetAgentId provided but no contentMetadataMap - should include all content
-      const result = formatAgentMessages(payload, undefined, undefined, {
-        targetAgentId: 'agent_a',
-      });
-
-      expect(result.messages).toHaveLength(1);
-      const aiMessage = result.messages[0] as AIMessage;
-      expect(Array.isArray(aiMessage.content)).toBe(true);
-      expect(aiMessage.content as Array<{ text: string }>).toHaveLength(2);
-    });
-
-    it('should filter content with groupId metadata (parallel execution)', () => {
-      const payload: TPayload = [
-        { role: 'user', content: 'Analyze this' },
-        {
-          role: 'assistant',
-          content: [
-            { type: ContentTypes.TEXT, text: 'Creative analysis' },
-            { type: ContentTypes.TEXT, text: 'Practical analysis' },
-          ],
-        },
-      ];
-
-      const contentMetadataMap = new Map([
-        [0, { agentId: 'creative_analyst', groupId: 1 }],
-        [1, { agentId: 'practical_analyst', groupId: 1 }],
-      ]);
-
-      const result = formatAgentMessages(payload, undefined, undefined, {
-        targetAgentId: 'creative_analyst',
-        contentMetadataMap,
-      });
-
-      expect(result.messages).toHaveLength(2);
-      const aiMessage = result.messages[1] as AIMessage;
-      expect(Array.isArray(aiMessage.content)).toBe(true);
-      expect(aiMessage.content as Array<{ text: string }>).toHaveLength(1);
-      expect((aiMessage.content as Array<{ text: string }>)[0].text).toBe(
-        'Creative analysis'
-      );
-    });
-
-    it('should not affect non-assistant messages when filtering', () => {
-      const payload: TPayload = [
-        { role: 'user', content: 'Hello from user' },
-        { role: 'system', content: 'System message' },
-        {
-          role: 'assistant',
-          content: [{ type: ContentTypes.TEXT, text: 'From agent_a' }],
-        },
-      ];
-
-      const contentMetadataMap = new Map([[0, { agentId: 'agent_a' }]]);
-
-      const result = formatAgentMessages(payload, undefined, undefined, {
-        targetAgentId: 'agent_a',
-        contentMetadataMap,
-      });
-
-      // All three messages should be present
-      expect(result.messages).toHaveLength(3);
-      expect(result.messages[0]).toBeInstanceOf(HumanMessage);
-      expect(result.messages[1]).toBeInstanceOf(SystemMessage);
-      expect(result.messages[2]).toBeInstanceOf(AIMessage);
-    });
-
-    it('should include content parts without metadata (unattributed) when filtering by targetAgentId', () => {
-      const payload: TPayload = [
-        { role: 'user', content: 'Hello' },
-        {
-          role: 'assistant',
-          content: [
-            { type: ContentTypes.TEXT, text: 'Unattributed content' },
-            { type: ContentTypes.TEXT, text: 'Response from agent_a' },
-            { type: ContentTypes.TEXT, text: 'Response from agent_b' },
-            { type: ContentTypes.TEXT, text: 'Another unattributed' },
-          ],
-        },
-      ];
-
-      // Only indices 1 and 2 have metadata; 0 and 3 are unattributed
-      const contentMetadataMap = new Map([
-        [1, { agentId: 'agent_a' }],
-        [2, { agentId: 'agent_b' }],
-      ]);
-
-      const result = formatAgentMessages(payload, undefined, undefined, {
-        targetAgentId: 'agent_a',
-        contentMetadataMap,
-      });
-
-      // Should have user message + filtered assistant message
-      expect(result.messages).toHaveLength(2);
-      expect(result.messages[0]).toBeInstanceOf(HumanMessage);
-      expect(result.messages[1]).toBeInstanceOf(AIMessage);
-
-      // The AIMessage should have: unattributed (index 0) + agent_a (index 1) + unattributed (index 3)
-      const aiMessage = result.messages[1] as AIMessage;
-      expect(Array.isArray(aiMessage.content)).toBe(true);
-      expect(aiMessage.content as Array<{ text: string }>).toHaveLength(3);
-      expect((aiMessage.content as Array<{ text: string }>)[0].text).toBe(
-        'Unattributed content'
-      );
-      expect((aiMessage.content as Array<{ text: string }>)[1].text).toBe(
-        'Response from agent_a'
-      );
-      expect((aiMessage.content as Array<{ text: string }>)[2].text).toBe(
-        'Another unattributed'
-      );
-    });
-
-    it('should include all unattributed content even when no parts match targetAgentId', () => {
-      const payload: TPayload = [
-        {
-          role: 'assistant',
-          content: [
-            { type: ContentTypes.TEXT, text: 'Unattributed content 1' },
-            { type: ContentTypes.TEXT, text: 'Response from agent_b' },
-            { type: ContentTypes.TEXT, text: 'Unattributed content 2' },
-          ],
-        },
-      ];
-
-      // Only index 1 has metadata (agent_b)
-      const contentMetadataMap = new Map([[1, { agentId: 'agent_b' }]]);
-
-      const result = formatAgentMessages(payload, undefined, undefined, {
-        targetAgentId: 'agent_a', // Looking for agent_a, but only agent_b content exists
-        contentMetadataMap,
-      });
-
-      // Should still have the message with unattributed content
-      expect(result.messages).toHaveLength(1);
-      const aiMessage = result.messages[0] as AIMessage;
-      expect(Array.isArray(aiMessage.content)).toBe(true);
-      // Should have the 2 unattributed parts (indices 0 and 2), but NOT agent_b's content
-      expect(aiMessage.content as Array<{ text: string }>).toHaveLength(2);
-      expect((aiMessage.content as Array<{ text: string }>)[0].text).toBe(
-        'Unattributed content 1'
-      );
-      expect((aiMessage.content as Array<{ text: string }>)[1].text).toBe(
-        'Unattributed content 2'
-      );
-    });
-  });
 });

package/src/stream.ts

@@ -583,6 +583,17 @@ export function createContentAggregator(): t.ContentAggregatorResult {
         tool_call: newToolCall,
       };
     }
+
+    // Apply agentId (for MultiAgentGraph) and groupId (for parallel execution) to content parts
+    // - agentId present → MultiAgentGraph (show agent labels)
+    // - groupId present → parallel execution (render columns)
+    const meta = contentMetaMap.get(index);
+    if (meta?.agentId != null) {
+      (contentParts[index] as t.MessageContentComplex).agentId = meta.agentId;
+    }
+    if (meta?.groupId != null) {
+      (contentParts[index] as t.MessageContentComplex).groupId = meta.groupId;
+    }
   };
 
   const aggregateContent = ({
@@ -727,10 +738,5 @@ export function createContentAggregator(): t.ContentAggregatorResult {
     }
   };
 
-  return {
-    contentParts,
-    aggregateContent,
-    stepMap,
-    contentMetadataMap: contentMetaMap,
-  };
+  return { contentParts, aggregateContent, stepMap };
 }

package/src/types/stream.ts

@@ -343,6 +343,10 @@ export type MessageContentComplex = (
     })
 ) & {
   tool_call_ids?: string[];
+  // Optional agentId for parallel execution attribution
+  agentId?: string;
+  // Optional groupId for parallel group attribution
+  groupId?: number;
 };
 
 export interface TMessage {
@@ -406,20 +410,8 @@ export type ContentAggregator = ({
         result: ToolEndEvent;
       };
 }) => void;
-/**
- * Metadata for content parts in multi-agent runs.
- * - agentId: present for all MultiAgentGraph runs (enables agent labels in UI)
- * - groupId: present only for parallel execution (enables column rendering)
- */
-export type ContentMetadata = {
-  agentId?: string;
-  groupId?: number;
-};
-
 export type ContentAggregatorResult = {
   stepMap: Map<string, RunStep | undefined>;
   contentParts: Array<MessageContentComplex | undefined>;
-  /** Map of content index to metadata (agentId, groupId). Only populated for MultiAgentGraph runs. */
-  contentMetadataMap: Map<number, ContentMetadata>;
   aggregateContent: ContentAggregator;
 };