@lobehub/lobehub 2.0.0-next.287 → 2.0.0-next.289

package/packages/builtin-tool-group-management/src/types.ts

@@ -2,17 +2,12 @@
 
 /**
  * API names for Group Management tool
+ *
+ * Note: Member management APIs (searchAgent, inviteAgent, createAgent, removeAgent)
+ * are handled by group-agent-builder tool. This tool focuses on orchestration.
  */
 export const GroupManagementApiName = {
-  // ==================== Member Management ====================
-  /** Search for agents that can be invited to the group */
-  searchAgent: 'searchAgent',
-  /** Invite an agent to join the group */
-  inviteAgent: 'inviteAgent',
-  /** Create a new agent and add it to the group */
-  createAgent: 'createAgent',
-  /** Remove an agent from the group */
-  removeAgent: 'removeAgent',
+  // ==================== Agent Info ====================
   /** Get detailed information about an agent */
   getAgentInfo: 'getAgentInfo',
 
@@ -26,7 +21,9 @@ export const GroupManagementApiName = {
 
   // ==================== Task Execution ====================
   /** Let an agent execute a task asynchronously */
-  executeTask: 'executeTask',
+  executeAgentTask: 'executeAgentTask',
+  /** Let multiple agents execute different tasks in parallel */
+  executeAgentTasks: 'executeAgentTasks',
   /** Interrupt a running agent task */
   interrupt: 'interrupt',
 
@@ -44,28 +41,7 @@ export const GroupManagementApiName = {
 export type GroupManagementApiNameType =
   (typeof GroupManagementApiName)[keyof typeof GroupManagementApiName];
 
-// ==================== Member Management Params ====================
-
-export interface SearchAgentParams {
-  limit?: number;
-  query?: string;
-  source?: 'user' | 'community';
-}
-
-export interface InviteAgentParams {
-  agentId: string;
-}
-
-export interface CreateAgentParams {
-  avatar?: string;
-  description?: string;
-  systemRole: string;
-  title: string;
-}
-
-export interface RemoveAgentParams {
-  agentId: string;
-}
+// ==================== Agent Info Params ====================
 
 export interface GetAgentInfoParams {
   agentId: string;
@@ -116,6 +92,27 @@ export interface ExecuteTaskParams {
   timeout?: number;
 }
 
+export interface TaskItem {
+  /** The ID of the agent to execute this task */
+  agentId: string;
+  /** Detailed instruction/prompt for the task execution */
+  instruction: string;
+  /** Optional timeout in milliseconds for this specific task */
+  timeout?: number;
+  /** Brief title describing what this task does (shown in UI) */
+  title: string;
+}
+
+export interface ExecuteTasksParams {
+  /**
+   * If true, the orchestration will end after all tasks complete,
+   * without calling the supervisor again.
+   */
+  skipCallSupervisor?: boolean;
+  /** Array of tasks to execute, each assigned to a specific agent */
+  tasks: TaskItem[];
+}
+
 export interface InterruptParams {
   taskId: string;
 }
@@ -156,14 +153,6 @@ export interface VoteParams {
 
 // ==================== Result Types ====================
 
-export interface AgentSearchResult {
-  avatar?: string;
-  description?: string;
-  id: string;
-  source: 'user' | 'community';
-  title: string;
-}
-
 export interface VoteResult {
   agentId: string;
   reasoning?: string;

package/packages/context-engine/src/engine/messages/MessagesEngine.ts

@@ -7,7 +7,8 @@ import { ContextEngine } from '../../pipeline';
 import {
   AgentCouncilFlattenProcessor,
   GroupMessageFlattenProcessor,
-  GroupMessageSenderProcessor,
+  GroupOrchestrationFilterProcessor,
+  GroupRoleTransformProcessor,
   HistoryTruncateProcessor,
   InputTemplateProcessor,
   MessageCleanupProcessor,
@@ -274,11 +275,28 @@ export class MessagesEngine {
       // 15. Supervisor role restore (convert role=supervisor back to role=assistant for model)
       new SupervisorRoleRestoreProcessor(),
 
-      // 16. Group message sender identity injection (for multi-agent chat)
-      ...(isAgentGroupEnabled
+      // 15.5. Group orchestration filter (remove supervisor's orchestration messages like broadcast/speak)
+      // This must be BEFORE GroupRoleTransformProcessor so we filter based on original agentId/tools
+      ...(isAgentGroupEnabled && agentGroup.agentMap && agentGroup.currentAgentId
         ? [
-            new GroupMessageSenderProcessor({
+            new GroupOrchestrationFilterProcessor({
+              agentMap: Object.fromEntries(
+                Object.entries(agentGroup.agentMap).map(([id, info]) => [id, { role: info.role }]),
+              ),
+              currentAgentId: agentGroup.currentAgentId,
+              // Only enabled when current agent is NOT supervisor (supervisor needs to see orchestration history)
+              enabled: agentGroup.currentAgentRole !== 'supervisor',
+            }),
+          ]
+        : []),
+
+      // 16. Group role transform (convert other agents' messages to user role with speaker tags)
+      // This must be BEFORE ToolCallProcessor so other agents' tool messages are converted first
+      ...(isAgentGroupEnabled && agentGroup.currentAgentId
+        ? [
+            new GroupRoleTransformProcessor({
               agentMap: agentGroup.agentMap!,
+              currentAgentId: agentGroup.currentAgentId,
             }),
           ]
         : []),

package/packages/context-engine/src/engine/messages/types.ts

@@ -4,12 +4,12 @@ import type { RuntimeInitialContext, RuntimeStepContext } from '@lobechat/types'
 
 import type { OpenAIChatMessage, UIChatMessage } from '@/types/index';
 
-import type { AgentInfo } from '../../processors/GroupMessageSender';
+import type { AgentInfo } from '../../processors/GroupRoleTransform';
 import type { AgentBuilderContext } from '../../providers/AgentBuilderContextInjector';
-import type { GroupAgentBuilderContext } from '../../providers/GroupAgentBuilderContextInjector';
-import type { GroupMemberInfo } from '../../providers/GroupContextInjector';
 import type { GTDPlan } from '../../providers/GTDPlanInjector';
 import type { GTDTodoList } from '../../providers/GTDTodoInjector';
+import type { GroupAgentBuilderContext } from '../../providers/GroupAgentBuilderContextInjector';
+import type { GroupMemberInfo } from '../../providers/GroupContextInjector';
 import type { LobeToolManifest } from '../tools/types';
 
 /**
@@ -249,7 +249,7 @@ export interface MessagesEngineResult {
 
 // Re-export types for convenience
 
-export { type AgentInfo } from '../../processors/GroupMessageSender';
+export { type AgentInfo } from '../../processors/GroupRoleTransform';
 export { type AgentBuilderContext } from '../../providers/AgentBuilderContextInjector';
 export { type GroupAgentBuilderContext } from '../../providers/GroupAgentBuilderContextInjector';
 export { type GTDPlan } from '../../providers/GTDPlanInjector';

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

@@ -0,0 +1,211 @@
+import debug from 'debug';
+
+import { BaseProcessor } from '../base/BaseProcessor';
+import type { Message, PipelineContext, ProcessorOptions } from '../types';
+
+const log = debug('context-engine:processor:GroupOrchestrationFilterProcessor');
+
+/**
+ * Default orchestration tool identifier
+ */
+const DEFAULT_ORCHESTRATION_IDENTIFIER = 'lobe-group-management';
+
+/**
+ * Default orchestration api names that should be filtered
+ */
+const DEFAULT_ORCHESTRATION_API_NAMES = ['broadcast', 'speak', 'executeTask', 'executeTasks'];
+
+/**
+ * Agent info for identifying supervisor
+ */
+export interface OrchestrationAgentInfo {
+  role: 'supervisor' | 'participant';
+}
+
+/**
+ * Tool info structure
+ */
+interface ToolInfo {
+  apiName?: string;
+  identifier?: string;
+}
+
+/**
+ * Configuration for GroupOrchestrationFilterProcessor
+ */
+export interface GroupOrchestrationFilterConfig {
+  /**
+   * Mapping from agentId to agent info
+   * Used to identify supervisor messages
+   */
+  agentMap?: Record<string, OrchestrationAgentInfo>;
+  /**
+   * The current agent ID that is responding
+   * If the current agent is supervisor, filtering will be skipped
+   * (Supervisor needs to see its own orchestration history)
+   */
+  currentAgentId?: string;
+  /**
+   * Whether to enable filtering
+   * @default true
+   */
+  enabled?: boolean;
+  /**
+   * Api names of orchestration tools to filter
+   * @default ['broadcast', 'speak', 'executeTask', 'executeTasks']
+   */
+  orchestrationApiNames?: string[];
+  /**
+   * Tool identifiers that are considered orchestration tools
+   * @default ['lobe-group-management']
+   */
+  orchestrationToolIdentifiers?: string[];
+}
+
+/**
+ * Group Orchestration Filter Processor
+ *
+ * Filters out Supervisor's orchestration messages (broadcast, speak, executeTask, etc.)
+ * from the context to reduce noise for participant agents.
+ *
+ * These messages are coordination metadata that participant agents don't need to see.
+ * Filtering them reduces context window usage and prevents model confusion.
+ *
+ * Filtering rules:
+ * - Supervisor assistant + orchestration tool_use: REMOVE
+ * - Supervisor tool_result for orchestration tools: REMOVE
+ * - Supervisor assistant without tools: KEEP (may contain meaningful summaries)
+ * - Supervisor assistant + non-orchestration tools: KEEP (e.g., search)
+ *
+ * @example
+ * ```typescript
+ * const processor = new GroupOrchestrationFilterProcessor({
+ *   agentMap: {
+ *     'supervisor-id': { role: 'supervisor' },
+ *     'agent-1': { role: 'participant' },
+ *   },
+ * });
+ * ```
+ */
+export class GroupOrchestrationFilterProcessor extends BaseProcessor {
+  readonly name = 'GroupOrchestrationFilterProcessor';
+
+  private config: GroupOrchestrationFilterConfig;
+  private orchestrationIdentifiers: Set<string>;
+  private orchestrationApiNames: Set<string>;
+
+  constructor(config: GroupOrchestrationFilterConfig = {}, options: ProcessorOptions = {}) {
+    super(options);
+    this.config = config;
+    this.orchestrationIdentifiers = new Set(
+      config.orchestrationToolIdentifiers || [DEFAULT_ORCHESTRATION_IDENTIFIER],
+    );
+    this.orchestrationApiNames = new Set(
+      config.orchestrationApiNames || DEFAULT_ORCHESTRATION_API_NAMES,
+    );
+  }
+
+  protected async doProcess(context: PipelineContext): Promise<PipelineContext> {
+    const clonedContext = this.cloneContext(context);
+
+    // Skip if disabled or no agentMap provided
+    if (this.config.enabled === false || !this.config.agentMap) {
+      log('Processor disabled or no agentMap provided, skipping');
+      return this.markAsExecuted(clonedContext);
+    }
+
+    // Skip if current agent is supervisor (supervisor needs to see its orchestration history)
+    if (this.isCurrentAgentSupervisor()) {
+      log('Current agent is supervisor, skipping orchestration filter');
+      return this.markAsExecuted(clonedContext);
+    }
+
+    let filteredCount = 0;
+    let assistantFiltered = 0;
+    let toolFiltered = 0;
+
+    const filteredMessages = clonedContext.messages.filter((msg: Message) => {
+      // Only filter supervisor messages
+      if (!this.isSupervisorMessage(msg)) {
+        return true;
+      }
+
+      // Check assistant messages with tools
+      if (msg.role === 'assistant' && msg.tools && msg.tools.length > 0) {
+        const hasOrchestrationTool = msg.tools.some((tool: ToolInfo) =>
+          this.isOrchestrationTool(tool),
+        );
+
+        if (hasOrchestrationTool) {
+          filteredCount++;
+          assistantFiltered++;
+          log(`Filtering supervisor orchestration assistant message: ${msg.id}`);
+          return false;
+        }
+      }
+
+      // Check tool result messages
+      if (msg.role === 'tool' && msg.plugin && this.isOrchestrationTool(msg.plugin)) {
+        filteredCount++;
+        toolFiltered++;
+        log(`Filtering supervisor orchestration tool result: ${msg.id}`);
+        return false;
+      }
+
+      // Keep other supervisor messages (pure text, non-orchestration tools)
+      return true;
+    });
+
+    clonedContext.messages = filteredMessages;
+
+    // Update metadata
+    clonedContext.metadata.orchestrationFilterProcessed = {
+      assistantFiltered,
+      filteredCount,
+      toolFiltered,
+    };
+
+    log(
+      `Orchestration filter completed: ${filteredCount} messages filtered (${assistantFiltered} assistant, ${toolFiltered} tool)`,
+    );
+
+    return this.markAsExecuted(clonedContext);
+  }
+
+  /**
+   * Check if the current agent is a supervisor
+   * Supervisor doesn't need orchestration messages filtered (they need to see their history)
+   */
+  private isCurrentAgentSupervisor(): boolean {
+    if (!this.config.currentAgentId || !this.config.agentMap) {
+      return false;
+    }
+
+    const currentAgentInfo = this.config.agentMap[this.config.currentAgentId];
+    return currentAgentInfo?.role === 'supervisor';
+  }
+
+  /**
+   * Check if a message is from a supervisor agent
+   */
+  private isSupervisorMessage(msg: Message): boolean {
+    if (!msg.agentId || !this.config.agentMap) {
+      return false;
+    }
+
+    const agentInfo = this.config.agentMap[msg.agentId];
+    return agentInfo?.role === 'supervisor';
+  }
+
+  /**
+   * Check if a tool is an orchestration tool that should be filtered
+   */
+  private isOrchestrationTool(tool: ToolInfo): boolean {
+    if (!tool) return false;
+
+    const identifier = tool.identifier || '';
+    const apiName = tool.apiName || '';
+
+    return this.orchestrationIdentifiers.has(identifier) && this.orchestrationApiNames.has(apiName);
+  }
+}

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

@@ -0,0 +1,261 @@
+import debug from 'debug';
+
+import { BaseProcessor } from '../base/BaseProcessor';
+import type { Message, PipelineContext, ProcessorOptions } from '../types';
+
+const log = debug('context-engine:processor:GroupRoleTransformProcessor');
+
+/**
+ * Agent info for message sender identification
+ */
+export interface AgentInfo {
+  name: string;
+  role: 'supervisor' | 'participant';
+}
+
+/**
+ * Configuration for GroupRoleTransformProcessor
+ */
+export interface GroupRoleTransformConfig {
+  /**
+   * Mapping from agentId to agent info
+   * Used to look up agent name for each message
+   */
+  agentMap: Record<string, AgentInfo>;
+  /**
+   * The current agent ID that is responding
+   * Messages from this agent will remain as assistant role
+   */
+  currentAgentId: string;
+  /**
+   * Custom function to generate tool name from identifier and apiName
+   */
+  genToolName?: (identifier: string, apiName: string) => string;
+}
+
+/**
+ * Group Role Transform Processor
+ *
+ * Transforms messages from other agents to user role with speaker tags.
+ * This prevents the model from imitating speaker tags in its output.
+ *
+ * From the model's perspective:
+ * - role: assistant = "my" responses (current agent)
+ * - role: user = external input (human users and other agents)
+ *
+ * Processing logic:
+ * 1. Current agent's messages: Keep as assistant (no modifications)
+ * 2. Other agents' assistant messages: Convert to user with speaker tag
+ * 3. Other agents' tool messages: Convert to user with tool_result tag
+ *
+ * @example
+ * ```typescript
+ * const processor = new GroupRoleTransformProcessor({
+ *   currentAgentId: 'travel-advisor',
+ *   agentMap: {
+ *     'weather-expert': { name: 'Weather Expert', role: 'participant' },
+ *     'travel-advisor': { name: 'Travel Advisor', role: 'participant' },
+ *     'supervisor': { name: 'Supervisor', role: 'supervisor' },
+ *   }
+ * });
+ * ```
+ */
+export class GroupRoleTransformProcessor extends BaseProcessor {
+  readonly name = 'GroupRoleTransformProcessor';
+
+  constructor(
+    private config: GroupRoleTransformConfig,
+    options: ProcessorOptions = {},
+  ) {
+    super(options);
+  }
+
+  protected async doProcess(context: PipelineContext): Promise<PipelineContext> {
+    const clonedContext = this.cloneContext(context);
+
+    // Skip if no currentAgentId or agentMap provided
+    if (!this.config.currentAgentId || !this.config.agentMap) {
+      log('No currentAgentId or agentMap provided, skipping processing');
+      return this.markAsExecuted(clonedContext);
+    }
+
+    let assistantTransformed = 0;
+    let toolTransformed = 0;
+
+    clonedContext.messages = clonedContext.messages.map((msg: Message) => {
+      // Process assistant messages
+      if (msg.role === 'assistant' && msg.agentId) {
+        if (msg.agentId === this.config.currentAgentId) {
+          // Current agent: keep as assistant, no modifications
+          return msg;
+        }
+
+        // Other agent: transform to user with speaker tag
+        const transformed = this.transformAssistantMessage(msg);
+        if (transformed !== msg) {
+          assistantTransformed++;
+          log(`Transformed assistant message from agent: ${msg.agentId} to user`);
+        }
+        return transformed;
+      }
+
+      // Process tool messages
+      if (msg.role === 'tool' && msg.agentId) {
+        if (msg.agentId === this.config.currentAgentId) {
+          // Current agent: keep as tool
+          return msg;
+        }
+
+        // Other agent: transform to user with tool_result tag
+        const transformed = this.transformToolMessage(msg);
+        if (transformed !== msg) {
+          toolTransformed++;
+          log(`Transformed tool message from agent: ${msg.agentId} to user`);
+        }
+        return transformed;
+      }
+
+      return msg;
+    });
+
+    // Update metadata
+    clonedContext.metadata.groupRoleTransformProcessed = {
+      assistantTransformed,
+      toolTransformed,
+    };
+
+    log(
+      `Group role transform completed: ${assistantTransformed} assistant messages, ${toolTransformed} tool messages transformed`,
+    );
+
+    return this.markAsExecuted(clonedContext);
+  }
+
+  /**
+   * Transform an assistant message from another agent to a user message
+   */
+  private transformAssistantMessage(msg: Message): Message {
+    const agentInfo = this.config.agentMap[msg.agentId];
+    if (!agentInfo) {
+      // No agent info found, keep original
+      return msg;
+    }
+
+    const agentName = agentInfo.name;
+    let content = this.buildSpeakerTag(agentName);
+
+    // Add original content
+    const originalContent = this.getStringContent(msg.content);
+    if (originalContent) {
+      content += originalContent;
+    }
+
+    // Add tool_use section if message has tools
+    if (msg.tools && msg.tools.length > 0) {
+      content += this.buildToolUseSection(msg.tools);
+    }
+
+    return {
+      ...msg,
+      content,
+      role: 'user',
+      // Remove tool-related fields as they're now embedded in content
+      tools: undefined,
+    };
+  }
+
+  /**
+   * Transform a tool result message from another agent to a user message
+   */
+  private transformToolMessage(msg: Message): Message {
+    const agentInfo = this.config.agentMap[msg.agentId];
+    if (!agentInfo) {
+      // No agent info found, keep original
+      return msg;
+    }
+
+    const agentName = agentInfo.name;
+    const toolName = this.getToolName(msg.plugin);
+    const toolCallId = msg.tool_call_id || 'unknown';
+    const resultContent = this.getStringContent(msg.content);
+
+    const content = `${this.buildSpeakerTag(agentName)}<tool_result id="${toolCallId}" name="${toolName}">
+${resultContent}
+</tool_result>`;
+
+    return {
+      ...msg,
+      content,
+      // Remove tool-related fields
+      plugin: undefined,
+      role: 'user',
+      tool_call_id: undefined,
+    };
+  }
+
+  /**
+   * Build the speaker tag
+   */
+  private buildSpeakerTag(agentName: string): string {
+    return `<speaker name="${agentName}" />\n`;
+  }
+
+  /**
+   * Build the tool_use section for assistant messages with tools
+   */
+  private buildToolUseSection(tools: any[]): string {
+    let section = '\n\n<tool_use>\n';
+
+    for (const tool of tools) {
+      const toolName = this.getToolName(tool);
+      const toolId = tool.id || 'unknown';
+      const args = tool.arguments || '';
+
+      section += `<tool id="${toolId}" name="${toolName}">\n`;
+      section += `${args}\n`;
+      section += `</tool>\n`;
+    }
+
+    section += '</tool_use>';
+    return section;
+  }
+
+  /**
+   * Get tool name from tool object
+   */
+  private getToolName(tool: any): string {
+    if (!tool) return 'unknown';
+
+    const identifier = tool.identifier || '';
+    const apiName = tool.apiName || '';
+
+    if (this.config.genToolName) {
+      return this.config.genToolName(identifier, apiName);
+    }
+
+    if (identifier && apiName) {
+      return `${identifier}.${apiName}`;
+    }
+
+    return identifier || apiName || 'unknown';
+  }
+
+  /**
+   * Extract string content from message content (handles both string and array formats)
+   */
+  private getStringContent(content: string | any[]): string {
+    if (typeof content === 'string') {
+      return content;
+    }
+
+    if (Array.isArray(content)) {
+      // Extract text from array content
+      return content
+        .filter((part: any) => part.type === 'text')
+        .map((part: any) => part.text || '')
+        .join('\n');
+    }
+
+    return '';
+  }
+}