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

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/database/src/repositories/agentGroup/index.ts

@@ -15,8 +15,14 @@ import {
 import { LobeChatDatabase } from '../../type';
 
 export interface SupervisorAgentConfig {
+  avatar?: string;
+  backgroundColor?: string;
+  description?: string;
   model?: string;
+  params?: any;
   provider?: string;
+  systemRole?: string;
+  tags?: string[];
   title?: string;
 }
 
@@ -164,8 +170,14 @@ export class AgentGroupRepository {
     const [supervisorAgent] = await this.db
       .insert(agents)
       .values({
+        avatar: supervisorConfig?.avatar,
+        backgroundColor: supervisorConfig?.backgroundColor,
+        description: supervisorConfig?.description,
         model: supervisorConfig?.model,
+        params: supervisorConfig?.params,
         provider: supervisorConfig?.provider,
+        systemRole: supervisorConfig?.systemRole,
+        tags: supervisorConfig?.tags,
         title: supervisorConfig?.title ?? 'Supervisor',
         userId: this.userId,
         virtual: true,
@@ -356,7 +368,12 @@ export class AgentGroupRepository {
       const [newGroup] = await trx
         .insert(chatGroups)
         .values({
+          avatar: sourceGroup.avatar,
+          backgroundColor: sourceGroup.backgroundColor,
           config: sourceGroup.config,
+          content: sourceGroup.content,
+          description: sourceGroup.description,
+          editorData: sourceGroup.editorData,
           pinned: sourceGroup.pinned,
           title: newTitle || (sourceGroup.title ? `${sourceGroup.title} (Copy)` : 'Copy'),
           userId: this.userId,
@@ -368,8 +385,14 @@ export class AgentGroupRepository {
       const [newSupervisor] = await trx
         .insert(agents)
         .values({
+          avatar: supervisorAgent?.avatar,
+          backgroundColor: supervisorAgent?.backgroundColor,
+          description: supervisorAgent?.description,
           model: supervisorAgent?.model,
+          params: supervisorAgent?.params,
           provider: supervisorAgent?.provider,
+          systemRole: supervisorAgent?.systemRole,
+          tags: supervisorAgent?.tags,
           title: supervisorAgent?.title || 'Supervisor',
           userId: this.userId,
           virtual: true,

package/packages/prompts/src/prompts/fileSystem/formatCommandOutput.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, it } from 'vitest';
+
+import { formatCommandOutput } from './formatCommandOutput';
+
+describe('formatCommandOutput', () => {
+  it('should format successful output while running', () => {
+    const result = formatCommandOutput({
+      running: true,
+      success: true,
+    });
+    expect(result).toMatchInlineSnapshot(`"Output retrieved. Running: true"`);
+  });
+
+  it('should format successful output when not running', () => {
+    const result = formatCommandOutput({
+      running: false,
+      success: true,
+    });
+    expect(result).toMatchInlineSnapshot(`"Output retrieved. Running: false"`);
+  });
+
+  it('should format successful output with content', () => {
+    const result = formatCommandOutput({
+      output: 'Process output here',
+      running: true,
+      success: true,
+    });
+    expect(result).toMatchInlineSnapshot(`
+      "Output retrieved. Running: true
+
+      Output:
+      Process output here"
+    `);
+  });
+
+  it('should format failed output', () => {
+    const result = formatCommandOutput({
+      error: 'Process not found',
+      running: false,
+      success: false,
+    });
+    expect(result).toMatchInlineSnapshot(`"Failed: Process not found"`);
+  });
+
+  it('should format successful output with error info', () => {
+    const result = formatCommandOutput({
+      error: 'Warning message',
+      output: 'Some output',
+      running: false,
+      success: true,
+    });
+    expect(result).toMatchInlineSnapshot(`
+      "Output retrieved. Running: false
+
+      Output:
+      Some output
+
+      Error: Warning message"
+    `);
+  });
+});

package/packages/prompts/src/prompts/fileSystem/formatCommandOutput.ts

@@ -0,0 +1,21 @@
+export interface FormatCommandOutputParams {
+  error?: string;
+  output?: string;
+  running: boolean;
+  success: boolean;
+}
+
+export const formatCommandOutput = ({
+  success,
+  running,
+  output,
+  error,
+}: FormatCommandOutputParams): string => {
+  const message = success ? `Output retrieved. Running: ${running}` : `Failed: ${error}`;
+
+  const parts: string[] = [message];
+  if (output) parts.push(`Output:\n${output}`);
+  if (error && success) parts.push(`Error: ${error}`);
+
+  return parts.join('\n\n');
+};

package/packages/prompts/src/prompts/fileSystem/formatCommandResult.test.ts

@@ -0,0 +1,87 @@
+import { describe, expect, it } from 'vitest';
+
+import { formatCommandResult } from './formatCommandResult';
+
+describe('formatCommandResult', () => {
+  it('should format successful command without output', () => {
+    const result = formatCommandResult({ success: true });
+    expect(result).toMatchInlineSnapshot(`"Command completed successfully."`);
+  });
+
+  it('should format successful background command', () => {
+    const result = formatCommandResult({
+      shellId: 'shell-123',
+      success: true,
+    });
+    expect(result).toMatchInlineSnapshot(
+      `"Command started in background with shell_id: shell-123"`,
+    );
+  });
+
+  it('should format successful command with stdout', () => {
+    const result = formatCommandResult({
+      stdout: 'Hello World',
+      success: true,
+    });
+    expect(result).toMatchInlineSnapshot(`
+      "Command completed successfully.
+
+      Output:
+      Hello World"
+    `);
+  });
+
+  it('should format successful command with stderr', () => {
+    const result = formatCommandResult({
+      stderr: 'Warning: deprecated',
+      success: true,
+    });
+    expect(result).toMatchInlineSnapshot(`
+      "Command completed successfully.
+
+      Stderr:
+      Warning: deprecated"
+    `);
+  });
+
+  it('should format successful command with exit code', () => {
+    const result = formatCommandResult({
+      exitCode: 0,
+      success: true,
+    });
+    expect(result).toMatchInlineSnapshot(`
+      "Command completed successfully.
+
+      Exit code: 0"
+    `);
+  });
+
+  it('should format failed command', () => {
+    const result = formatCommandResult({
+      error: 'Permission denied',
+      success: false,
+    });
+    expect(result).toMatchInlineSnapshot(`"Command failed: Permission denied"`);
+  });
+
+  it('should format command with all fields', () => {
+    const result = formatCommandResult({
+      error: 'Command error',
+      exitCode: 1,
+      stderr: 'Error occurred',
+      stdout: 'Some output',
+      success: false,
+    });
+    expect(result).toMatchInlineSnapshot(`
+      "Command failed: Command error
+
+      Output:
+      Some output
+
+      Stderr:
+      Error occurred
+
+      Exit code: 1"
+    `);
+  });
+});

package/packages/prompts/src/prompts/fileSystem/formatCommandResult.ts

@@ -0,0 +1,35 @@
+export interface FormatCommandResultParams {
+  error?: string;
+  exitCode?: number;
+  shellId?: string;
+  stderr?: string;
+  stdout?: string;
+  success: boolean;
+}
+
+export const formatCommandResult = ({
+  success,
+  shellId,
+  error,
+  stdout,
+  stderr,
+  exitCode,
+}: FormatCommandResultParams): string => {
+  const parts: string[] = [];
+
+  if (success) {
+    if (shellId) {
+      parts.push(`Command started in background with shell_id: ${shellId}`);
+    } else {
+      parts.push('Command completed successfully.');
+    }
+  } else {
+    parts.push(`Command failed: ${error}`);
+  }
+
+  if (stdout) parts.push(`Output:\n${stdout}`);
+  if (stderr) parts.push(`Stderr:\n${stderr}`);
+  if (exitCode !== undefined) parts.push(`Exit code: ${exitCode}`);
+
+  return parts.join('\n\n');
+};