@lobehub/lobehub 2.0.0-next.304 → 2.0.0-next.306

package/packages/context-engine/src/processors/__tests__/GroupMessageFlatten.test.ts

@@ -489,6 +489,109 @@ describe('GroupMessageFlattenProcessor', () => {
     });
   });
 
+  describe('Supervisor Messages', () => {
+    it('should flatten supervisor message with children', async () => {
+      const processor = new GroupMessageFlattenProcessor();
+
+      const input: any[] = [
+        {
+          id: 'msg-supervisor-1',
+          role: 'supervisor',
+          content: '',
+          createdAt: '2025-10-27T10:00:00.000Z',
+          updatedAt: '2025-10-27T10:00:10.000Z',
+          meta: { title: 'Supervisor Agent' },
+          children: [
+            {
+              id: 'msg-1',
+              content: 'Let me coordinate the agents',
+              tools: [
+                {
+                  id: 'tool-1',
+                  type: 'builtin',
+                  apiName: 'broadcast',
+                  arguments: '{"message":"Hello agents"}',
+                  identifier: 'lobe-group-management',
+                  result: {
+                    id: 'msg-tool-1',
+                    content: 'Broadcast sent',
+                    error: null,
+                    state: {},
+                  },
+                },
+              ],
+              usage: { totalTokens: 100 },
+            },
+          ],
+        },
+      ];
+
+      const context = createContext(input);
+      const result = await processor.process(context);
+
+      // Should create 2 messages: 1 assistant + 1 tool
+      expect(result.messages).toHaveLength(2);
+
+      // Check assistant message (supervisor gets flattened to assistant)
+      const assistantMsg = result.messages[0];
+      expect(assistantMsg.role).toBe('assistant');
+      expect(assistantMsg.id).toBe('msg-1');
+      expect(assistantMsg.content).toBe('Let me coordinate the agents');
+      expect(assistantMsg.tools).toHaveLength(1);
+
+      // Check tool message
+      const toolMsg = result.messages[1];
+      expect(toolMsg.role).toBe('tool');
+      expect(toolMsg.id).toBe('msg-tool-1');
+      expect(toolMsg.content).toBe('Broadcast sent');
+    });
+
+    it('should flatten supervisor message with content only (no tools)', async () => {
+      const processor = new GroupMessageFlattenProcessor();
+
+      const input: any[] = [
+        {
+          id: 'msg-supervisor-1',
+          role: 'supervisor',
+          content: '',
+          children: [
+            {
+              id: 'msg-1',
+              content: 'Anthropic cowork',
+            },
+          ],
+        },
+      ];
+
+      const context = createContext(input);
+      const result = await processor.process(context);
+
+      // Should create 1 assistant message
+      expect(result.messages).toHaveLength(1);
+      expect(result.messages[0].role).toBe('assistant');
+      expect(result.messages[0].content).toBe('Anthropic cowork');
+    });
+
+    it('should handle supervisor message with empty children', async () => {
+      const processor = new GroupMessageFlattenProcessor();
+
+      const input: any[] = [
+        {
+          id: 'msg-supervisor-1',
+          role: 'supervisor',
+          content: '',
+          children: [],
+        },
+      ];
+
+      const context = createContext(input);
+      const result = await processor.process(context);
+
+      // Empty children means no messages created
+      expect(result.messages).toHaveLength(0);
+    });
+  });
+
   describe('Real-world Test Case', () => {
     it('should flatten the provided real-world group message', async () => {
       const processor = new GroupMessageFlattenProcessor();

package/packages/context-engine/src/providers/GroupAgentBuilderContextInjector.ts

@@ -1,6 +1,6 @@
 import debug from 'debug';
 
-import { BaseProvider } from '../base/BaseProvider';
+import { BaseFirstUserContentProvider } from '../base/BaseFirstUserContentProvider';
 import type { PipelineContext, ProcessorOptions } from '../types';
 
 const log = debug('context-engine:provider:GroupAgentBuilderContextInjector');
@@ -262,8 +262,10 @@ ${parts.join('\n')}
 /**
  * Group Agent Builder Context Injector
  * Responsible for injecting current group context when Group Agent Builder tool is enabled
+ *
+ * Extends BaseFirstUserContentProvider to consolidate with other first-user-message injectors
  */
-export class GroupAgentBuilderContextInjector extends BaseProvider {
+export class GroupAgentBuilderContextInjector extends BaseFirstUserContentProvider {
   readonly name = 'GroupAgentBuilderContextInjector';
 
   constructor(
@@ -273,19 +275,17 @@ export class GroupAgentBuilderContextInjector extends BaseProvider {
     super(options);
   }
 
-  protected async doProcess(context: PipelineContext): Promise<PipelineContext> {
-    const clonedContext = this.cloneContext(context);
-
+  protected buildContent(): string | null {
     // Skip if Group Agent Builder is not enabled
     if (!this.config.enabled) {
       log('Group Agent Builder not enabled, skipping injection');
-      return this.markAsExecuted(clonedContext);
+      return null;
     }
 
     // Skip if no group context
     if (!this.config.groupContext) {
       log('No group context provided, skipping injection');
-      return this.markAsExecuted(clonedContext);
+      return null;
     }
 
     // Format group context
@@ -295,34 +295,21 @@ export class GroupAgentBuilderContextInjector extends BaseProvider {
     // Skip if no content to inject
     if (!formattedContent) {
       log('No content to inject after formatting');
-      return this.markAsExecuted(clonedContext);
-    }
-
-    // Find the first user message index
-    const firstUserIndex = clonedContext.messages.findIndex((msg) => msg.role === 'user');
-
-    if (firstUserIndex === -1) {
-      log('No user messages found, skipping injection');
-      return this.markAsExecuted(clonedContext);
+      return null;
     }
 
-    // Insert a new user message with group context before the first user message
-    const groupContextMessage = {
-      content: formattedContent,
-      createdAt: Date.now(),
-      id: `group-agent-builder-context-${Date.now()}`,
-      meta: { injectType: 'group-agent-builder-context', systemInjection: true },
-      role: 'user' as const,
-      updatedAt: Date.now(),
-    };
-
-    clonedContext.messages.splice(firstUserIndex, 0, groupContextMessage);
+    log('Group Agent Builder context prepared for injection');
+    return formattedContent;
+  }
 
-    // Update metadata
-    clonedContext.metadata.groupAgentBuilderContextInjected = true;
+  protected async doProcess(context: PipelineContext): Promise<PipelineContext> {
+    const result = await super.doProcess(context);
 
-    log('Group Agent Builder context injected as new user message');
+    // Update metadata if content was injected
+    if (this.config.enabled && this.config.groupContext) {
+      result.metadata.groupAgentBuilderContextInjected = true;
+    }
 
-    return this.markAsExecuted(clonedContext);
+    return result;
   }
 }

package/packages/context-engine/src/providers/__tests__/GroupAgentBuilderContextInjector.test.ts

@@ -0,0 +1,307 @@
+import { describe, expect, it } from 'vitest';
+
+import type { PipelineContext } from '../../types';
+import { GroupAgentBuilderContextInjector } from '../GroupAgentBuilderContextInjector';
+import { UserMemoryInjector } from '../UserMemoryInjector';
+
+describe('GroupAgentBuilderContextInjector', () => {
+  const createContext = (messages: any[]): PipelineContext => ({
+    initialState: { messages: [] },
+    isAborted: false,
+    messages,
+    metadata: {},
+  });
+
+  describe('Basic Injection', () => {
+    it('should inject group context before first user message', async () => {
+      const injector = new GroupAgentBuilderContextInjector({
+        enabled: true,
+        groupContext: {
+          groupId: 'grp_123',
+          groupTitle: 'Test Group',
+          members: [
+            { id: 'agt_1', title: 'Agent 1', isSupervisor: true },
+            { id: 'agt_2', title: 'Agent 2', isSupervisor: false },
+          ],
+        },
+      });
+
+      const context = createContext([
+        { role: 'system', content: 'You are a helpful assistant' },
+        { role: 'user', content: 'Hello' },
+      ]);
+
+      const result = await injector.process(context);
+
+      // Should have 3 messages now (system + injected user + original user)
+      expect(result.messages).toHaveLength(3);
+      expect(result.messages[0].role).toBe('system');
+      expect(result.messages[1].role).toBe('user');
+      expect(result.messages[1].content).toContain('<current_group_context>');
+      expect(result.messages[1].content).toContain('grp_123');
+      expect(result.messages[1].content).toContain('Test Group');
+      expect(result.messages[2].role).toBe('user');
+      expect(result.messages[2].content).toBe('Hello');
+    });
+
+    it('should skip injection when not enabled', async () => {
+      const injector = new GroupAgentBuilderContextInjector({
+        enabled: false,
+        groupContext: {
+          groupId: 'grp_123',
+        },
+      });
+
+      const context = createContext([
+        { role: 'system', content: 'You are a helpful assistant' },
+        { role: 'user', content: 'Hello' },
+      ]);
+
+      const result = await injector.process(context);
+
+      expect(result.messages).toHaveLength(2);
+    });
+
+    it('should skip injection when no group context provided', async () => {
+      const injector = new GroupAgentBuilderContextInjector({
+        enabled: true,
+      });
+
+      const context = createContext([
+        { role: 'system', content: 'You are a helpful assistant' },
+        { role: 'user', content: 'Hello' },
+      ]);
+
+      const result = await injector.process(context);
+
+      expect(result.messages).toHaveLength(2);
+    });
+  });
+
+  describe('Content Consolidation with UserMemoryInjector', () => {
+    it('should consolidate content into single user message when both injectors are used', async () => {
+      // First injector: UserMemoryInjector
+      const memoryInjector = new UserMemoryInjector({
+        memories: {
+          identities: [{ description: 'User is a developer', id: 'id_1' }],
+        },
+      });
+
+      // Second injector: GroupAgentBuilderContextInjector
+      const groupInjector = new GroupAgentBuilderContextInjector({
+        enabled: true,
+        groupContext: {
+          groupId: 'grp_123',
+          groupTitle: 'Dev Team',
+        },
+      });
+
+      const context = createContext([
+        { role: 'system', content: 'You are a helpful assistant' },
+        { role: 'user', content: 'Hello' },
+        { role: 'assistant', content: 'Hi there!' },
+      ]);
+
+      // Process through both injectors in order
+      const afterMemory = await memoryInjector.process(context);
+      const afterGroup = await groupInjector.process(afterMemory);
+
+      // Should have 4 messages: system + SINGLE injected user + original user + assistant
+      expect(afterGroup.messages).toHaveLength(4);
+
+      // Check message order
+      expect(afterGroup.messages[0].role).toBe('system');
+      expect(afterGroup.messages[1].role).toBe('user'); // Consolidated injection
+      expect(afterGroup.messages[2].role).toBe('user'); // Original user message
+      expect(afterGroup.messages[3].role).toBe('assistant');
+
+      // The consolidated message should contain BOTH user memory AND group context
+      const injectedMessage = afterGroup.messages[1];
+      expect(injectedMessage.content).toContain('<user_memory>'); // From UserMemoryInjector
+      expect(injectedMessage.content).toContain('<current_group_context>'); // From GroupAgentBuilderContextInjector
+      expect(injectedMessage.content).toContain('User is a developer');
+      expect(injectedMessage.content).toContain('grp_123');
+      expect(injectedMessage.content).toContain('Dev Team');
+    });
+
+    it('should work correctly when only GroupAgentBuilderContextInjector is used', async () => {
+      const groupInjector = new GroupAgentBuilderContextInjector({
+        enabled: true,
+        groupContext: {
+          groupId: 'grp_123',
+          groupTitle: 'Test Group',
+        },
+      });
+
+      const context = createContext([
+        { role: 'system', content: 'You are a helpful assistant' },
+        { role: 'user', content: 'Hello' },
+      ]);
+
+      const result = await groupInjector.process(context);
+
+      expect(result.messages).toHaveLength(3);
+      expect(result.messages[1].content).toContain('<current_group_context>');
+    });
+
+    it('should work correctly when only UserMemoryInjector is used', async () => {
+      const memoryInjector = new UserMemoryInjector({
+        memories: {
+          identities: [{ description: 'User is a developer', id: 'id_1' }],
+        },
+      });
+
+      const context = createContext([
+        { role: 'system', content: 'You are a helpful assistant' },
+        { role: 'user', content: 'Hello' },
+      ]);
+
+      const result = await memoryInjector.process(context);
+
+      expect(result.messages).toHaveLength(3);
+      expect(result.messages[1].content).toContain('<user_memory>');
+    });
+
+    it('should NOT create duplicate user messages when injectors run in sequence', async () => {
+      const memoryInjector = new UserMemoryInjector({
+        memories: {
+          identities: [{ description: 'Identity 1', id: 'id_1' }],
+          contexts: [{ title: 'Context 1', id: 'ctx_1' }],
+        },
+      });
+
+      const groupInjector = new GroupAgentBuilderContextInjector({
+        enabled: true,
+        groupContext: {
+          groupId: 'grp_123',
+          groupTitle: 'Team Alpha',
+          members: [
+            { id: 'agt_1', title: 'Alice', isSupervisor: true },
+            { id: 'agt_2', title: 'Bob', isSupervisor: false },
+          ],
+          config: {
+            systemPrompt: 'Collaborate effectively',
+          },
+        },
+      });
+
+      const context = createContext([
+        { role: 'system', content: 'System prompt' },
+        { role: 'user', content: 'First user message' },
+        { role: 'assistant', content: 'First response' },
+        { role: 'user', content: 'Second user message' },
+      ]);
+
+      // Process through both injectors
+      const afterMemory = await memoryInjector.process(context);
+      const afterGroup = await groupInjector.process(afterMemory);
+
+      // Count user messages
+      const userMessages = afterGroup.messages.filter((m) => m.role === 'user');
+
+      // Should have 3 user messages: 1 consolidated injection + 2 original
+      expect(userMessages).toHaveLength(3);
+
+      // The first user message should be the consolidated injection
+      expect(userMessages[0].content).toContain('<user_memory>');
+      expect(userMessages[0].content).toContain('<current_group_context>');
+
+      // Original messages should remain unchanged
+      expect(userMessages[1].content).toBe('First user message');
+      expect(userMessages[2].content).toBe('Second user message');
+    });
+
+    it('should preserve order: first injector content comes first in the consolidated message', async () => {
+      // UserMemoryInjector runs first
+      const memoryInjector = new UserMemoryInjector({
+        memories: {
+          identities: [{ description: 'Dev identity', id: 'id_1' }],
+        },
+      });
+
+      // GroupAgentBuilderContextInjector runs second
+      const groupInjector = new GroupAgentBuilderContextInjector({
+        enabled: true,
+        groupContext: {
+          groupId: 'grp_order_test',
+          groupTitle: 'Order Test Group',
+        },
+      });
+
+      const context = createContext([{ role: 'user', content: 'Hello' }]);
+
+      // Process in order: memory first, then group
+      const afterMemory = await memoryInjector.process(context);
+      const afterGroup = await groupInjector.process(afterMemory);
+
+      const injectedContent = afterGroup.messages[0].content as string;
+
+      // user_memory should appear BEFORE current_group_context
+      const memoryIndex = injectedContent.indexOf('<user_memory>');
+      const groupIndex = injectedContent.indexOf('<current_group_context>');
+
+      expect(memoryIndex).toBeLessThan(groupIndex);
+    });
+  });
+
+  describe('Group Context Formatting', () => {
+    it('should format members correctly', async () => {
+      const injector = new GroupAgentBuilderContextInjector({
+        enabled: true,
+        groupContext: {
+          members: [
+            {
+              id: 'agt_1',
+              title: 'Supervisor Agent',
+              description: 'Manages the team',
+              isSupervisor: true,
+            },
+            {
+              id: 'agt_2',
+              title: 'Worker Agent',
+              description: 'Does the work',
+              isSupervisor: false,
+            },
+          ],
+        },
+      });
+
+      const context = createContext([{ role: 'user', content: 'Hello' }]);
+
+      const result = await injector.process(context);
+
+      const injectedContent = result.messages[0].content;
+      expect(injectedContent).toContain('<group_members count="2">');
+      expect(injectedContent).toContain('role="supervisor"');
+      expect(injectedContent).toContain('role="participant"');
+      expect(injectedContent).toContain('Supervisor Agent');
+      expect(injectedContent).toContain('Worker Agent');
+    });
+
+    it('should format config correctly', async () => {
+      const injector = new GroupAgentBuilderContextInjector({
+        enabled: true,
+        groupContext: {
+          config: {
+            scene: 'collaborative',
+            enableSupervisor: true,
+            systemPrompt: 'Work together as a team',
+            openingMessage: 'Welcome to the team!',
+            openingQuestions: ['How can I help?', 'What would you like to do?'],
+          },
+        },
+      });
+
+      const context = createContext([{ role: 'user', content: 'Hello' }]);
+
+      const result = await injector.process(context);
+
+      const injectedContent = result.messages[0].content;
+      expect(injectedContent).toContain('<group_config>');
+      expect(injectedContent).toContain('<scene>collaborative</scene>');
+      expect(injectedContent).toContain('<enableSupervisor>true</enableSupervisor>');
+      expect(injectedContent).toContain('<openingMessage>Welcome to the team!</openingMessage>');
+      expect(injectedContent).toContain('<openingQuestions count="2">');
+    });
+  });
+});

package/packages/prompts/src/prompts/userMemory/__snapshots__/index.test.ts.snap

@@ -120,15 +120,9 @@ exports[`promptUserMemory > identities only > should format identities grouped b
 "<user_memory>
 <instruction>The following are memories about this user retrieved from previous conversations. Use this information to personalize your responses and maintain continuity.</instruction>
 <identities count="3">
-  <personal count="1">
-    <identity role="Father">User is a father of two children</identity>
-  </personal>
-  <professional count="1">
-    <identity role="Software Engineer">User is a senior software engineer</identity>
-  </professional>
-  <demographic count="1">
-    <identity>User is based in Shanghai</identity>
-  </demographic>
+  <identity type="personal" role="Father" id="id-1">User is a father of two children</identity>
+  <identity type="professional" role="Software Engineer" id="id-2">User is a senior software engineer</identity>
+  <identity type="demographic" id="id-3">User is based in Shanghai</identity>
 </identities>
 </user_memory>"
 `;
@@ -137,10 +131,8 @@ exports[`promptUserMemory > identities only > should format single type identiti
 "<user_memory>
 <instruction>The following are memories about this user retrieved from previous conversations. Use this information to personalize your responses and maintain continuity.</instruction>
 <identities count="2">
-  <demographic count="2">
-    <identity>User is 35 years old</identity>
-    <identity>User speaks Mandarin and English</identity>
-  </demographic>
+  <identity type="demographic" id="id-1">User is 35 years old</identity>
+  <identity type="demographic" id="id-2">User speaks Mandarin and English</identity>
 </identities>
 </user_memory>"
 `;
@@ -149,10 +141,8 @@ exports[`promptUserMemory > identities only > should format single type identiti
 "<user_memory>
 <instruction>The following are memories about this user retrieved from previous conversations. Use this information to personalize your responses and maintain continuity.</instruction>
 <identities count="2">
-  <personal count="2">
-    <identity>User is married</identity>
-    <identity>User has a pet dog</identity>
-  </personal>
+  <identity type="personal" id="id-1">User is married</identity>
+  <identity type="personal" id="id-2">User has a pet dog</identity>
 </identities>
 </user_memory>"
 `;
@@ -161,9 +151,7 @@ exports[`promptUserMemory > identities only > should format single type identiti
 "<user_memory>
 <instruction>The following are memories about this user retrieved from previous conversations. Use this information to personalize your responses and maintain continuity.</instruction>
 <identities count="1">
-  <professional count="1">
-    <identity role="CTO">User works at a tech startup</identity>
-  </professional>
+  <identity type="professional" role="CTO" id="id-1">User works at a tech startup</identity>
 </identities>
 </user_memory>"
 `;
@@ -172,9 +160,7 @@ exports[`promptUserMemory > identities only > should handle identity with null v
 "<user_memory>
 <instruction>The following are memories about this user retrieved from previous conversations. Use this information to personalize your responses and maintain continuity.</instruction>
 <identities count="1">
-  <personal count="1">
-    <identity></identity>
-  </personal>
+  <identity type="personal" id="id-1"></identity>
 </identities>
 </user_memory>"
 `;
@@ -183,9 +169,7 @@ exports[`promptUserMemory > identities only > should handle identity without rol
 "<user_memory>
 <instruction>The following are memories about this user retrieved from previous conversations. Use this information to personalize your responses and maintain continuity.</instruction>
 <identities count="1">
-  <personal count="1">
-    <identity>User enjoys hiking</identity>
-  </personal>
+  <identity type="personal" id="id-1">User enjoys hiking</identity>
 </identities>
 </user_memory>"
 `;
@@ -194,9 +178,7 @@ exports[`promptUserMemory > mixed memory types > should format all memory types
 "<user_memory>
 <instruction>The following are memories about this user retrieved from previous conversations. Use this information to personalize your responses and maintain continuity.</instruction>
 <identities count="1">
-  <professional count="1">
-    <identity role="Tech Lead">User is a tech lead at a startup</identity>
-  </professional>
+  <identity type="professional" role="Tech Lead" id="id-1">User is a tech lead at a startup</identity>
 </identities>
 <contexts count="1">
   <context id="ctx-1" title="Experience Level">Senior developer with 10 years experience</context>
@@ -217,15 +199,9 @@ exports[`promptUserMemory > mixed memory types > should format all memory types
 "<user_memory>
 <instruction>The following are memories about this user retrieved from previous conversations. Use this information to personalize your responses and maintain continuity.</instruction>
 <identities count="3">
-  <personal count="1">
-    <identity role="Father">User is a father</identity>
-  </personal>
-  <professional count="1">
-    <identity role="Senior Engineer">User is a senior engineer</identity>
-  </professional>
-  <demographic count="1">
-    <identity>User lives in Beijing</identity>
-  </demographic>
+  <identity type="personal" role="Father" id="id-1">User is a father</identity>
+  <identity type="professional" role="Senior Engineer" id="id-2">User is a senior engineer</identity>
+  <identity type="demographic" id="id-3">User lives in Beijing</identity>
 </identities>
 <contexts count="1">
   <context id="ctx-1" title="Current Work">Working on AI products</context>

package/packages/prompts/src/prompts/userMemory/index.ts

@@ -98,29 +98,10 @@ const isValidIdentityItem = (item: UserMemoryIdentityItem): boolean => {
  * Formats a single identity memory item
  */
 const formatIdentityItem = (item: UserMemoryIdentityItem): string => {
+  const typeAttr = item.type ? ` type="${item.type}"` : '';
   const roleAttr = item.role ? ` role="${item.role}"` : '';
-  return `    <identity${roleAttr}>${item.description || ''}</identity>`;
-};
-
-/**
- * Format identities grouped by type as XML
- * Types: personal (角色), professional (职业), demographic (属性)
- */
-const formatIdentitiesSection = (identities: UserMemoryIdentityItem[]): string => {
-  const personal = identities.filter((i) => i.type === 'personal');
-  const professional = identities.filter((i) => i.type === 'professional');
-  const demographic = identities.filter((i) => i.type === 'demographic');
-
-  return [
-    personal.length > 0 &&
-      `  <personal count="${personal.length}">\n${personal.map(formatIdentityItem).join('\n')}\n  </personal>`,
-    professional.length > 0 &&
-      `  <professional count="${professional.length}">\n${professional.map(formatIdentityItem).join('\n')}\n  </professional>`,
-    demographic.length > 0 &&
-      `  <demographic count="${demographic.length}">\n${demographic.map(formatIdentityItem).join('\n')}\n  </demographic>`,
-  ]
-    .filter(Boolean)
-    .join('\n');
+  const idAttr = item.id ? ` id="${item.id}"` : '';
+  return `  <identity${typeAttr}${roleAttr}${idAttr}>${item.description || ''}</identity>`;
 };
 
 /**
@@ -156,9 +137,9 @@ export const promptUserMemory = ({ memories }: PromptUserMemoryOptions): string
     '<instruction>The following are memories about this user retrieved from previous conversations. Use this information to personalize your responses and maintain continuity.</instruction>',
   );
 
-  // Add identities section (user's identity information, grouped by type)
+  // Add identities section (user's identity information)
   if (hasIdentities) {
-    const identitiesXml = formatIdentitiesSection(identities);
+    const identitiesXml = identities.map((item) => formatIdentityItem(item)).join('\n');
     contentParts.push(`<identities count="${identities.length}">
 ${identitiesXml}
 </identities>`);