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

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 # Changelog
 
+## [Version 2.0.0-next.306](https://github.com/lobehub/lobe-chat/compare/v2.0.0-next.305...v2.0.0-next.306)
+
+<sup>Released on **2026-01-18**</sup>
+
+#### 🐛 Bug Fixes
+
+- **misc**: Fix supervisor id issue.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### What's fixed
+
+- **misc**: Fix supervisor id issue, closes [#11584](https://github.com/lobehub/lobe-chat/issues/11584) ([c097584](https://github.com/lobehub/lobe-chat/commit/c097584))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
 ## [Version 2.0.0-next.305](https://github.com/lobehub/lobe-chat/compare/v2.0.0-next.304...v2.0.0-next.305)
 
 <sup>Released on **2026-01-18**</sup>

package/changelog/v1.json

@@ -1,4 +1,13 @@
 [
+  {
+    "children": {
+      "fixes": [
+        "Fix supervisor id issue."
+      ]
+    },
+    "date": "2026-01-18",
+    "version": "2.0.0-next.306"
+  },
   {
     "children": {},
     "date": "2026-01-18",

package/e2e/src/steps/community/detail-pages.steps.ts

@@ -8,7 +8,9 @@ import { CustomWorld } from '../../support/world';
 // ============================================
 
 Given('I wait for the page to fully load', async function (this: CustomWorld) {
-  await this.page.waitForLoadState('networkidle', { timeout: 30_000 });
+   // Use domcontentloaded instead of networkidle to avoid hanging on persistent connections
+  await this.page.waitForLoadState('domcontentloaded', { timeout: 10_000 });
+  // Short wait for React hydration
   await this.page.waitForTimeout(1000);
 });
 

package/e2e/src/steps/community/interactions.steps.ts

@@ -446,8 +446,8 @@ Then('I should be navigated to the assistant detail page', async function (this:
 Then('I should see the assistant detail content', async function (this: CustomWorld) {
   await this.page.waitForLoadState('networkidle', { timeout: 30_000 });
 
-  // Look for detail page elements (e.g., title, description, etc.)
-  const detailContent = this.page.locator('[data-testid="detail-content"], main, article').first();
+  // Look for assistant detail page content
+  const detailContent = this.page.locator('[data-testid="assistant-detail-content"]');
   await expect(detailContent).toBeVisible({ timeout: 30_000 });
 });
 
@@ -561,8 +561,8 @@ Then('I should be navigated to the MCP detail page', async function (this: Custo
 Then('I should see the MCP detail content', async function (this: CustomWorld) {
   await this.page.waitForLoadState('networkidle', { timeout: 30_000 });
 
-  // Look for detail page elements
-  const detailContent = this.page.locator('[data-testid="detail-content"], main, article').first();
+  // Look for MCP detail page content
+  const detailContent = this.page.locator('[data-testid="mcp-detail-content"]');
   await expect(detailContent).toBeVisible({ timeout: 30_000 });
 });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/lobehub",
-  "version": "2.0.0-next.305",
+  "version": "2.0.0-next.306",
   "description": "LobeHub - an open-source,comprehensive AI Agent framework that supports speech synthesis, multimodal, and extensible Function Call plugin system. Supports one-click free deployment of your private ChatGPT/LLM web application.",
   "keywords": [
     "framework",

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

@@ -7,9 +7,9 @@ const log = debug('context-engine:processor:GroupMessageFlattenProcessor');
 
 /**
  * Group Message Flatten Processor
- * Responsible for flattening role=assistantGroup messages into standard assistant + tool message sequences
+ * Responsible for flattening role=assistantGroup and role=supervisor messages into standard assistant + tool message sequences
  *
- * AssistantGroup messages are created when assistant messages with tools are merged with their tool results.
+ * AssistantGroup/Supervisor messages are created when assistant messages with tools are merged with their tool results.
  * This processor converts them back to a flat structure that AI models can understand.
  */
 export class GroupMessageFlattenProcessor extends BaseProcessor {
@@ -31,8 +31,11 @@ export class GroupMessageFlattenProcessor extends BaseProcessor {
 
     // Process each message
     for (const message of clonedContext.messages) {
-      // Check if this is an assistantGroup message with children field
-      if (message.role === 'assistantGroup' && message.children) {
+      // Check if this is an assistantGroup or supervisor message with children field
+      if (
+        (message.role === 'assistantGroup' || message.role === 'supervisor') &&
+        message.children
+      ) {
         // If children array is empty, skip this message entirely (no content to flatten)
         if (message.children.length === 0) {
           continue;
@@ -42,7 +45,7 @@ export class GroupMessageFlattenProcessor extends BaseProcessor {
         groupMessagesFlattened++;
 
         log(
-          `Flattening assistantGroup message ${message.id} with ${message.children.length} children`,
+          `Flattening ${message.role} message ${message.id} with ${message.children.length} children`,
         );
 
         // Flatten each child
@@ -148,7 +151,7 @@ export class GroupMessageFlattenProcessor extends BaseProcessor {
     clonedContext.metadata.toolMessagesCreated = toolMessagesCreated;
 
     log(
-      `AssistantGroup message flatten processing completed: ${groupMessagesFlattened} groups flattened, ${assistantMessagesCreated} assistant messages created, ${toolMessagesCreated} tool messages created`,
+      `AssistantGroup/Supervisor message flatten processing completed: ${groupMessagesFlattened} groups flattened, ${assistantMessagesCreated} assistant messages created, ${toolMessagesCreated} tool messages created`,
     );
 
     return this.markAsExecuted(clonedContext);

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">');
+    });
+  });
+});