@lobehub/lobehub 2.0.0-next.273 → 2.0.0-next.274

package/packages/builtin-tool-group-agent-builder/src/ExecutionRuntime/index.ts

@@ -1,18 +1,27 @@
 import type { BuiltinServerRuntimeOutput } from '@lobechat/types';
 
-import { chatGroupService } from '@/services/chatGroup';
+import { agentService } from '@/services/agent';
+import { type GroupMemberConfig, chatGroupService } from '@/services/chatGroup';
+import { useAgentStore } from '@/store/agent';
 import { getChatGroupStoreState } from '@/store/agentGroup';
 import { agentGroupSelectors } from '@/store/agentGroup/selectors';
 
 import type {
+  BatchCreateAgentsParams,
+  BatchCreateAgentsState,
+  CreateAgentParams,
+  CreateAgentState,
   InviteAgentParams,
   InviteAgentState,
   RemoveAgentParams,
   RemoveAgentState,
-  UpdateGroupConfigParams,
-  UpdateGroupConfigState,
+  SearchAgentParams,
+  SearchAgentState,
+  UpdateAgentPromptParams,
+  UpdateGroupParams,
   UpdateGroupPromptParams,
   UpdateGroupPromptState,
+  UpdateGroupState,
 } from '../types';
 
 /**
@@ -21,7 +30,184 @@ import type {
  * Extends AgentBuilder functionality with group-specific operations
  */
 export class GroupAgentBuilderExecutionRuntime {
-  // ==================== Group-specific Operations ====================
+  // ==================== Group Member Management ====================
+
+  /**
+   * Search for agents that can be invited to the group
+   */
+  async searchAgent(args: SearchAgentParams): Promise<BuiltinServerRuntimeOutput> {
+    const { query, limit = 10 } = args;
+
+    try {
+      const results = await agentService.queryAgents({ keyword: query, limit });
+
+      const agents = results.map((agent) => ({
+        avatar: agent.avatar,
+        description: agent.description,
+        id: agent.id,
+        title: agent.title,
+      }));
+
+      const total = agents.length;
+
+      if (total === 0) {
+        return {
+          content: query
+            ? `No agents found matching "${query}".`
+            : 'No agents found. You can create a new agent or search with different keywords.',
+          state: { agents: [], query, total: 0 } as SearchAgentState,
+          success: true,
+        };
+      }
+
+      // Format agents list for LLM consumption
+      const agentList = agents
+        .map(
+          (a, i) =>
+            `${i + 1}. ${a.title || 'Untitled'} (ID: ${a.id})${a.description ? ` - ${a.description}` : ''}`,
+        )
+        .join('\n');
+
+      return {
+        content: query
+          ? `Found ${total} agent${total > 1 ? 's' : ''} matching "${query}":\n${agentList}`
+          : `Found ${total} agent${total > 1 ? 's' : ''}:\n${agentList}`,
+        state: { agents, query, total } as SearchAgentState,
+        success: true,
+      };
+    } catch (error) {
+      const err = error as Error;
+      return {
+        content: `Failed to search agents: ${err.message}`,
+        error,
+        success: false,
+      };
+    }
+  }
+
+  /**
+   * Create a new agent and add it to the group
+   */
+  async createAgent(groupId: string, args: CreateAgentParams): Promise<BuiltinServerRuntimeOutput> {
+    try {
+      const state = getChatGroupStoreState();
+      const group = agentGroupSelectors.getGroupById(groupId)(state);
+
+      if (!group) {
+        return {
+          content: 'Group not found',
+          error: 'Group not found',
+          success: false,
+        };
+      }
+
+      // Create a virtual agent only (no session needed for group agents)
+      // Map 'tools' from LLM input to 'plugins' for internal API
+      const result = await agentService.createAgentOnly({
+        config: {
+          avatar: args.avatar,
+          description: args.description,
+          plugins: args.tools,
+          systemRole: args.systemRole,
+          title: args.title,
+          virtual: true,
+        },
+        groupId,
+      });
+
+      if (!result.agentId) {
+        return {
+          content: 'Failed to create agent: No agent ID returned',
+          success: false,
+        };
+      }
+
+      // Refresh the group detail in the store
+      await state.refreshGroupDetail(groupId);
+
+      return {
+        content: `Successfully created agent "${args.title}" and added it to the group.`,
+        state: {
+          agentId: result.agentId,
+          success: true,
+          title: args.title,
+        } as CreateAgentState,
+        success: true,
+      };
+    } catch (error) {
+      const err = error as Error;
+      return {
+        content: `Failed to create agent: ${err.message}`,
+        error,
+        success: false,
+      };
+    }
+  }
+
+  /**
+   * Create multiple agents at once and add them to the group
+   * Uses batch API for efficiency (single request instead of N requests)
+   */
+  async batchCreateAgents(
+    groupId: string,
+    args: BatchCreateAgentsParams,
+  ): Promise<BuiltinServerRuntimeOutput> {
+    try {
+      const state = getChatGroupStoreState();
+      const group = agentGroupSelectors.getGroupById(groupId)(state);
+
+      if (!group) {
+        return {
+          content: 'Group not found',
+          error: 'Group not found',
+          success: false,
+        };
+      }
+
+      // Use batch API to create all agents in one request
+      // Map 'tools' from LLM input to 'plugins' for internal API
+      const agentConfigs: GroupMemberConfig[] = args.agents.map((agentDef) => ({
+        avatar: agentDef.avatar,
+        description: agentDef.description,
+        plugins: agentDef.tools,
+        systemRole: agentDef.systemRole,
+        title: agentDef.title,
+      }));
+
+      const { agents: createdAgents } = await chatGroupService.batchCreateAgentsInGroup(
+        groupId,
+        agentConfigs,
+      );
+
+      // Refresh the group detail in the store
+      await state.refreshGroupDetail(groupId);
+
+      const results = createdAgents.map((agent, index) => ({
+        agentId: agent.id,
+        success: true,
+        title: args.agents[index].title,
+      }));
+
+      const createdList = results.map((r) => `- ${r.title} (ID: ${r.agentId})`).join('\n');
+
+      return {
+        content: `Successfully created ${results.length} agent${results.length > 1 ? 's' : ''}:\n${createdList}`,
+        state: {
+          agents: results,
+          failedCount: 0,
+          successCount: results.length,
+        } as BatchCreateAgentsState,
+        success: true,
+      };
+    } catch (error) {
+      const err = error as Error;
+      return {
+        content: `Failed to create agents: ${err.message}`,
+        error,
+        success: false,
+      };
+    }
+  }
 
   /**
    * Invite an agent to the group
@@ -149,64 +335,58 @@ export class GroupAgentBuilderExecutionRuntime {
     }
   }
 
+  // ==================== Group Configuration ====================
+
   /**
-   * Update group system prompt
-   * Unlike regular AgentBuilder, this updates the group's systemPrompt in groupConfig
+   * Update a specific agent's system prompt (systemRole)
    */
-  async updatePrompt(args: UpdateGroupPromptParams): Promise<BuiltinServerRuntimeOutput> {
+  async updateAgentPrompt(
+    groupId: string,
+    args: UpdateAgentPromptParams,
+  ): Promise<BuiltinServerRuntimeOutput> {
     try {
-      const state = getChatGroupStoreState();
-      const group = agentGroupSelectors.currentGroup(state);
+      const { agentId, prompt } = args;
 
-      if (!group) {
-        return {
-          content: 'No active group found',
-          error: 'No active group found',
-          success: false,
-        };
-      }
+      // Get previous prompt for state
+      const state = getChatGroupStoreState();
+      const group = agentGroupSelectors.getGroupById(groupId)(state);
+      const agent = group?.agents?.find((a) => a.id === agentId);
+      const previousPrompt = agent?.systemRole ?? undefined;
 
-      const previousPrompt = group.config?.systemPrompt;
+      // Update the agent's systemRole via agent store
+      await useAgentStore.getState().updateAgentConfigById(agentId, { systemRole: prompt });
 
-      if (args.streaming) {
-        // Use streaming mode for typewriter effect
-        await this.streamUpdatePrompt(args.prompt);
-      } else {
-        // Update the system prompt directly
-        await state.updateGroupConfig({ systemPrompt: args.prompt });
-      }
+      // Refresh the group detail in the store to sync agent data
+      await state.refreshGroupDetail(groupId);
 
-      const content = args.prompt
-        ? `Successfully updated group system prompt (${args.prompt.length} characters)`
-        : 'Successfully cleared group system prompt';
+      const content = prompt
+        ? `Successfully updated agent ${agentId} system prompt (${prompt.length} characters)`
+        : `Successfully cleared agent ${agentId} system prompt`;
 
       return {
         content,
         state: {
-          newPrompt: args.prompt,
+          agentId,
+          newPrompt: prompt,
           previousPrompt,
           success: true,
-        } as UpdateGroupPromptState,
+        },
         success: true,
       };
     } catch (error) {
       const err = error as Error;
       return {
-        content: `Failed to update group prompt: ${err.message}`,
+        content: `Failed to update agent prompt: ${err.message}`,
         error,
-        state: {
-          newPrompt: args.prompt,
-          success: false,
-        } as UpdateGroupPromptState,
         success: false,
       };
     }
   }
 
   /**
-   * Update group configuration (openingMessage, openingQuestions)
+   * Update group configuration and metadata (unified method)
    */
-  async updateGroupConfig(args: UpdateGroupConfigParams): Promise<BuiltinServerRuntimeOutput> {
+  async updateGroup(args: UpdateGroupParams): Promise<BuiltinServerRuntimeOutput> {
     try {
       const state = getChatGroupStoreState();
       const group = agentGroupSelectors.currentGroup(state);
@@ -219,91 +399,155 @@ export class GroupAgentBuilderExecutionRuntime {
         };
       }
 
-      const { config } = args;
+      const { config, meta } = args;
 
-      if (!config) {
+      if (!config && !meta) {
         return {
-          content: 'No configuration provided',
-          error: 'No configuration provided',
+          content: 'No configuration or metadata provided',
+          error: 'No configuration or metadata provided',
           success: false,
         };
       }
 
-      // Build the config update object
-      const configUpdate: { openingMessage?: string; openingQuestions?: string[] } = {};
-
-      if (config.openingMessage !== undefined) {
-        configUpdate.openingMessage = config.openingMessage;
+      const updatedFields: string[] = [];
+      const resultState: UpdateGroupState = { success: true };
+
+      // Update config if provided
+      if (config) {
+        const configUpdate: { openingMessage?: string; openingQuestions?: string[] } = {};
+
+        if (config.openingMessage !== undefined) {
+          configUpdate.openingMessage = config.openingMessage;
+          updatedFields.push(
+            config.openingMessage
+              ? `openingMessage (${config.openingMessage.length} chars)`
+              : 'openingMessage (cleared)',
+          );
+        }
+
+        if (config.openingQuestions !== undefined) {
+          configUpdate.openingQuestions = config.openingQuestions;
+          updatedFields.push(
+            config.openingQuestions.length > 0
+              ? `openingQuestions (${config.openingQuestions.length} questions)`
+              : 'openingQuestions (cleared)',
+          );
+        }
+
+        if (Object.keys(configUpdate).length > 0) {
+          await state.updateGroupConfig(configUpdate);
+          resultState.updatedConfig = configUpdate;
+        }
       }
 
-      if (config.openingQuestions !== undefined) {
-        configUpdate.openingQuestions = config.openingQuestions;
+      // Update meta if provided
+      if (meta && Object.keys(meta).length > 0) {
+        await state.updateGroupMeta(meta);
+        resultState.updatedMeta = meta;
+
+        if (meta.avatar !== undefined) {
+          updatedFields.push(`avatar (${meta.avatar || 'cleared'})`);
+        }
+        if (meta.title !== undefined) {
+          updatedFields.push(`title (${meta.title || 'cleared'})`);
+        }
+        if (meta.description !== undefined) {
+          updatedFields.push(
+            meta.description
+              ? `description (${meta.description.length} chars)`
+              : 'description (cleared)',
+          );
+        }
+        if (meta.backgroundColor !== undefined) {
+          updatedFields.push(`backgroundColor (${meta.backgroundColor || 'cleared'})`);
+        }
       }
 
-      // Update the group config
-      await state.updateGroupConfig(configUpdate);
+      // Refresh the group detail in the store to ensure data sync
+      await state.refreshGroupDetail(group.id);
 
-      const updatedFields: string[] = [];
-      if (config.openingMessage !== undefined) {
-        updatedFields.push(
-          config.openingMessage
-            ? `openingMessage (${config.openingMessage.length} chars)`
-            : 'openingMessage (cleared)',
-        );
+      const content = `Successfully updated group: ${updatedFields.join(', ')}`;
+
+      return {
+        content,
+        state: resultState,
+        success: true,
+      };
+    } catch (error) {
+      const err = error as Error;
+      return {
+        content: `Failed to update group: ${err.message}`,
+        error,
+        success: false,
+      };
+    }
+  }
+
+  /**
+   * Update group shared prompt/content
+   */
+  async updateGroupPrompt(args: UpdateGroupPromptParams): Promise<BuiltinServerRuntimeOutput> {
+    try {
+      const state = getChatGroupStoreState();
+      const group = agentGroupSelectors.currentGroup(state);
+
+      if (!group) {
+        return {
+          content: 'No active group found',
+          error: 'No active group found',
+          success: false,
+        };
       }
-      if (config.openingQuestions !== undefined) {
-        updatedFields.push(
-          config.openingQuestions.length > 0
-            ? `openingQuestions (${config.openingQuestions.length} questions)`
-            : 'openingQuestions (cleared)',
-        );
+
+      const previousPrompt = group.content ?? undefined;
+
+      if (args.streaming) {
+        // Use streaming mode for typewriter effect
+        await this.streamUpdateGroupPrompt(args.prompt);
+      } else {
+        // Update the content directly
+        await state.updateGroup(group.id, { content: args.prompt });
       }
 
-      const content = `Successfully updated group configuration: ${updatedFields.join(', ')}`;
+      // Refresh the group detail in the store to ensure data sync
+      await state.refreshGroupDetail(group.id);
+
+      const content = args.prompt
+        ? `Successfully updated group shared prompt (${args.prompt.length} characters)`
+        : 'Successfully cleared group shared prompt';
 
       return {
         content,
         state: {
+          newPrompt: args.prompt,
+          previousPrompt,
           success: true,
-          updatedConfig: configUpdate,
-        } as UpdateGroupConfigState,
+        } as UpdateGroupPromptState,
         success: true,
       };
     } catch (error) {
       const err = error as Error;
       return {
-        content: `Failed to update group configuration: ${err.message}`,
+        content: `Failed to update group prompt: ${err.message}`,
         error,
+        state: {
+          newPrompt: args.prompt,
+          success: false,
+        } as UpdateGroupPromptState,
         success: false,
       };
     }
   }
 
   /**
-   * Stream update prompt with typewriter effect for group
+   * Stream update group prompt with typewriter effect
    */
-  private async streamUpdatePrompt(prompt: string): Promise<void> {
+  private async streamUpdateGroupPrompt(prompt: string): Promise<void> {
     const state = getChatGroupStoreState();
+    const group = agentGroupSelectors.currentGroup(state);
 
-    // Start streaming
-    state.startStreamingSystemPrompt();
-
-    // Simulate streaming by chunking the content
-    const chunkSize = 5; // Characters per chunk
-    const delay = 10; // Milliseconds between chunks
-
-    for (let i = 0; i < prompt.length; i += chunkSize) {
-      const chunk = prompt.slice(i, i + chunkSize);
-      getChatGroupStoreState().appendStreamingSystemPrompt(chunk);
-
-      // Small delay for typewriter effect
-      if (i + chunkSize < prompt.length) {
-        // eslint-disable-next-line no-promise-executor-return
-        await new Promise((resolve) => setTimeout(resolve, delay));
-      }
-    }
+    if (!group) return;
 
-    // Finish streaming - EditorCanvas will handle save when streaming ends
-    await getChatGroupStoreState().finishStreamingSystemPrompt();
+    await state.updateGroup(group.id, { content: prompt });
   }
 }

package/packages/builtin-tool-group-agent-builder/src/client/Inspector/BatchCreateAgents/index.tsx

@@ -0,0 +1,110 @@
+'use client';
+
+import type { BuiltinInspectorProps } from '@lobechat/types';
+import { Avatar, Flexbox } from '@lobehub/ui';
+import { createStaticStyles, cssVar, cx } from 'antd-style';
+import { Check } from 'lucide-react';
+import { memo, useMemo } from 'react';
+import { useTranslation } from 'react-i18next';
+
+import { shinyTextStyles } from '@/styles';
+
+import type { BatchCreateAgentsParams, BatchCreateAgentsState } from '../../../types';
+
+const styles = createStaticStyles(({ css, cssVar: cv }) => ({
+  avatarGroup: css`
+    display: flex;
+    gap: 2px;
+    align-items: center;
+  `,
+  count: css`
+    color: ${cv.colorTextSecondary};
+    font-size: 12px;
+  `,
+  root: css`
+    overflow: hidden;
+    display: flex;
+    gap: 8px;
+    align-items: center;
+  `,
+  statusIcon: css`
+    flex-shrink: 0;
+    margin-block-end: -2px;
+  `,
+  title: css`
+    flex-shrink: 0;
+    color: ${cv.colorTextSecondary};
+    white-space: nowrap;
+  `,
+}));
+
+export const BatchCreateAgentsInspector = memo<
+  BuiltinInspectorProps<BatchCreateAgentsParams, BatchCreateAgentsState>
+>(({ args, partialArgs, isArgumentsStreaming, isLoading, pluginState }) => {
+  const { t } = useTranslation('plugin');
+
+  const agents = args?.agents || partialArgs?.agents;
+
+  // Get display info from agents
+  const displayInfo = useMemo(() => {
+    if (!agents || agents.length === 0) return null;
+
+    const count = agents.length;
+    const displayAgents = agents.slice(0, 3); // Show up to 3 avatars
+
+    return { count, displayAgents };
+  }, [agents]);
+
+  // Initial streaming state
+  if (isArgumentsStreaming && !displayInfo) {
+    return (
+      <div className={cx(styles.root, shinyTextStyles.shinyText)}>
+        <span>{t('builtins.lobe-group-agent-builder.apiName.batchCreateAgents')}</span>
+      </div>
+    );
+  }
+
+  const isSuccess = pluginState?.successCount === pluginState?.agents?.length;
+  const successCount = pluginState?.successCount ?? 0;
+  const totalCount = displayInfo?.count ?? 0;
+
+  return (
+    <Flexbox
+      align={'center'}
+      className={cx(styles.root, (isArgumentsStreaming || isLoading) && shinyTextStyles.shinyText)}
+      gap={8}
+      horizontal
+    >
+      <span className={styles.title}>
+        {t('builtins.lobe-group-agent-builder.apiName.batchCreateAgents')}:
+      </span>
+      {displayInfo && (
+        <>
+          <div className={styles.avatarGroup}>
+            {displayInfo.displayAgents.map((agent, index) => (
+              <Avatar
+                key={index}
+                avatar={agent.avatar}
+                shape={'square'}
+                size={20}
+                title={agent.title}
+              />
+            ))}
+          </div>
+          <span className={styles.count}>
+            {pluginState
+              ? `${successCount}/${totalCount}`
+              : `${totalCount} ${t('builtins.lobe-group-agent-builder.inspector.agents')}`}
+          </span>
+        </>
+      )}
+      {!isLoading && isSuccess && (
+        <Check className={styles.statusIcon} color={cssVar.colorSuccess} size={14} />
+      )}
+    </Flexbox>
+  );
+});
+
+BatchCreateAgentsInspector.displayName = 'BatchCreateAgentsInspector';
+
+export default BatchCreateAgentsInspector;

package/packages/builtin-tool-group-agent-builder/src/client/Inspector/CreateAgent/index.tsx

@@ -0,0 +1,72 @@
+'use client';
+
+import type { BuiltinInspectorProps } from '@lobechat/types';
+import { Avatar, Flexbox } from '@lobehub/ui';
+import { createStaticStyles, cssVar, cx } from 'antd-style';
+import { Check } from 'lucide-react';
+import { memo } from 'react';
+import { useTranslation } from 'react-i18next';
+
+import { shinyTextStyles } from '@/styles';
+
+import type { CreateAgentParams, CreateAgentState } from '../../../types';
+
+const styles = createStaticStyles(({ css, cssVar: cv }) => ({
+  root: css`
+    overflow: hidden;
+    display: flex;
+    gap: 8px;
+    align-items: center;
+  `,
+  statusIcon: css`
+    flex-shrink: 0;
+    margin-block-end: -2px;
+  `,
+  title: css`
+    flex-shrink: 0;
+    color: ${cv.colorTextSecondary};
+    white-space: nowrap;
+  `,
+}));
+
+export const CreateAgentInspector = memo<
+  BuiltinInspectorProps<CreateAgentParams, CreateAgentState>
+>(({ args, partialArgs, isArgumentsStreaming, isLoading, pluginState }) => {
+  const { t } = useTranslation('plugin');
+
+  const title = args?.title || partialArgs?.title;
+  const avatar = args?.avatar || partialArgs?.avatar;
+
+  // Initial streaming state
+  if (isArgumentsStreaming && !title) {
+    return (
+      <div className={cx(styles.root, shinyTextStyles.shinyText)}>
+        <span>{t('builtins.lobe-group-agent-builder.apiName.createAgent')}</span>
+      </div>
+    );
+  }
+
+  const isSuccess = pluginState?.success;
+
+  return (
+    <Flexbox
+      align={'center'}
+      className={cx(styles.root, (isArgumentsStreaming || isLoading) && shinyTextStyles.shinyText)}
+      gap={8}
+      horizontal
+    >
+      <span className={styles.title}>
+        {t('builtins.lobe-group-agent-builder.apiName.createAgent')}:
+      </span>
+      {avatar && <Avatar avatar={avatar} shape={'square'} size={20} title={title || undefined} />}
+      {title && <span>{title}</span>}
+      {!isLoading && isSuccess && (
+        <Check className={styles.statusIcon} color={cssVar.colorSuccess} size={14} />
+      )}
+    </Flexbox>
+  );
+});
+
+CreateAgentInspector.displayName = 'CreateAgentInspector';
+
+export default CreateAgentInspector;