@lobehub/lobehub 2.0.0-next.337 → 2.0.0-next.339

package/src/services/chat/mecha/agentConfigResolver.ts

@@ -51,6 +51,12 @@ export interface AgentConfigResolverContext {
   /** Agent ID to resolve config for */
   agentId: string;
 
+  /**
+   * Whether to disable all tools for this agent execution.
+   * When true, returns empty plugins array (used for broadcast scenarios).
+   */
+  disableTools?: boolean;
+
   // Builtin agent specific context
   /** Document content for page-agent */
   documentContent?: string;
@@ -112,13 +118,27 @@ export interface ResolvedAgentConfig {
  * For regular agents, this simply returns the config from the store.
  */
 export const resolveAgentConfig = (ctx: AgentConfigResolverContext): ResolvedAgentConfig => {
-  const { agentId, model, documentContent, plugins, targetAgentConfig, isSubTask } = ctx;
-
-  log('resolveAgentConfig called with agentId: %s, scope: %s, isSubTask: %s', agentId, ctx.scope, isSubTask);
-
-  // Helper to filter out lobe-gtd in sub-task context to prevent nested sub-task creation
-  const applySubTaskFilter = (pluginIds: string[]) =>
-    isSubTask ? pluginIds.filter((id) => id !== 'lobe-gtd') : pluginIds;
+  const { agentId, model, documentContent, plugins, targetAgentConfig, isSubTask, disableTools } =
+    ctx;
+
+  log(
+    'resolveAgentConfig called with agentId: %s, scope: %s, isSubTask: %s, disableTools: %s',
+    agentId,
+    ctx.scope,
+    isSubTask,
+    disableTools,
+  );
+
+  // Helper to apply plugin filters:
+  // 1. If disableTools is true, return empty array (for broadcast scenarios)
+  // 2. If isSubTask is true, filter out lobe-gtd to prevent nested sub-task creation
+  const applyPluginFilters = (pluginIds: string[]) => {
+    if (disableTools) {
+      log('disableTools is true, returning empty plugins');
+      return [];
+    }
+    return isSubTask ? pluginIds.filter((id) => id !== 'lobe-gtd') : pluginIds;
+  };
 
   const agentStoreState = getAgentStoreState();
 
@@ -130,18 +150,18 @@ export const resolveAgentConfig = (ctx: AgentConfigResolverContext): ResolvedAge
   const basePlugins = agentConfig.plugins ?? [];
 
   // Check if this is a builtin agent
-  // First check agent store, then check if this is a supervisor agent via groupId
-  let slug = agentSelectors.getAgentSlugById(agentId)(agentStoreState);
-  log('slug from agentStore: %s (agentId: %s)', slug, agentId);
+  // Priority: supervisor check (when in group scope) > agent store slug
+  let slug: string | undefined;
 
-  // If not found in agent store, check if this is a supervisor agent using groupId
-  // This is more reliable than iterating all groups to find a match
-  if (!slug && ctx.groupId) {
+  // IMPORTANT: When in group scope with groupId, check if this agent is the group's supervisor FIRST
+  // This takes priority because supervisor needs special group-supervisor behavior,
+  // even if the agent has its own slug
+  if (ctx.groupId && ctx.scope === 'group') {
     const groupStoreState = getChatGroupStoreState();
     const group = agentGroupByIdSelectors.groupById(ctx.groupId)(groupStoreState);
 
     log(
-      'checking supervisor via groupId %s: group=%o',
+      'checking supervisor FIRST (scope=group): groupId=%s, group=%O, agentId=%s',
       ctx.groupId,
       group
         ? {
@@ -150,6 +170,7 @@ export const resolveAgentConfig = (ctx: AgentConfigResolverContext): ResolvedAge
             title: group.title,
           }
         : null,
+      agentId,
     );
 
     // Check if this agent is the supervisor of the specified group
@@ -164,6 +185,12 @@ export const resolveAgentConfig = (ctx: AgentConfigResolverContext): ResolvedAge
     }
   }
 
+  // If not identified as supervisor, check agent store for slug
+  if (!slug) {
+    slug = agentSelectors.getAgentSlugById(agentId)(agentStoreState) ?? undefined;
+    log('slug from agentStore: %s (agentId: %s)', slug, agentId);
+  }
+
   if (!slug) {
     log('agentId %s is not a builtin agent (no slug found)', agentId);
     // Regular agent - use provided plugins if available, fallback to agent's plugins
@@ -209,7 +236,7 @@ export const resolveAgentConfig = (ctx: AgentConfigResolverContext): ResolvedAge
         agentConfig: finalAgentConfig,
         chatConfig: finalChatConfig,
         isBuiltinAgent: false,
-        plugins: applySubTaskFilter(pageAgentPlugins),
+        plugins: applyPluginFilters(pageAgentPlugins),
       };
     }
 
@@ -218,7 +245,7 @@ export const resolveAgentConfig = (ctx: AgentConfigResolverContext): ResolvedAge
       agentConfig: finalAgentConfig,
       chatConfig: finalChatConfig,
       isBuiltinAgent: false,
-      plugins: applySubTaskFilter(finalPlugins),
+      plugins: applyPluginFilters(finalPlugins),
     };
   }
 
@@ -339,7 +366,7 @@ export const resolveAgentConfig = (ctx: AgentConfigResolverContext): ResolvedAge
     agentConfig: finalAgentConfig,
     chatConfig: resolvedChatConfig,
     isBuiltinAgent: true,
-    plugins: applySubTaskFilter(finalPlugins),
+    plugins: applyPluginFilters(finalPlugins),
     slug,
   };
 };

package/src/store/chat/agents/GroupOrchestration/createGroupOrchestrationExecutors.ts

@@ -235,13 +235,14 @@ export const createGroupOrchestrationExecutors = (
     parallel_call_agents: async (instruction, state): Promise<GroupOrchestrationExecutorOutput> => {
       const {
         agentIds,
+        disableTools,
         instruction: agentInstruction,
         toolMessageId,
       } = (instruction as SupervisorInstructionParallelCallAgents).payload;
 
       const sessionLogId = `${state.operationId}:parallel_call_agents`;
       log(
-        `[${sessionLogId}] Broadcasting to agents: ${agentIds.join(', ')}, instruction: ${agentInstruction}, toolMessageId: ${toolMessageId}`,
+        `[${sessionLogId}] Broadcasting to agents: ${agentIds.join(', ')}, instruction: ${agentInstruction}, toolMessageId: ${toolMessageId}, disableTools: ${disableTools}`,
       );
 
       const messages = getMessages();
@@ -279,10 +280,12 @@ export const createGroupOrchestrationExecutors = (
       // - messageContext keeps the group's main conversation context (for message storage)
       // - subAgentId specifies which agent's config to use for each agent
       // - toolMessageId is used as parentMessageId so agent responses are children of the tool message
+      // - disableTools prevents broadcast agents from calling tools (expected behavior for broadcast)
       await Promise.all(
         agentIds.map(async (agentId) => {
           await get().internal_execAgentRuntime({
             context: { ...messageContext, subAgentId: agentId },
+            disableTools,
             messages: messagesWithInstruction,
             parentMessageId: toolMessageId,
             parentMessageType: 'tool',
@@ -776,48 +779,48 @@ export const createGroupOrchestrationExecutors = (
               }
 
               switch (status.status) {
-              case 'completed': {
-                tracker.status = 'completed';
-                tracker.result = status.result;
-                log(`[${taskLogId}] Task completed successfully`);
-                if (status.result) {
+                case 'completed': {
+                  tracker.status = 'completed';
+                  tracker.result = status.result;
+                  log(`[${taskLogId}] Task completed successfully`);
+                  if (status.result) {
+                    await get().optimisticUpdateMessageContent(
+                      tracker.taskMessageId,
+                      status.result,
+                      undefined,
+                      { operationId: state.operationId },
+                    );
+                  }
+
+                  break;
+                }
+                case 'failed': {
+                  tracker.status = 'failed';
+                  tracker.error = status.error;
+                  console.error(`[${taskLogId}] Task failed: ${status.error}`);
                   await get().optimisticUpdateMessageContent(
                     tracker.taskMessageId,
-                    status.result,
+                    `Task failed: ${status.error}`,
                     undefined,
                     { operationId: state.operationId },
                   );
+
+                  break;
                 }
-              
-              break;
-              }
-              case 'failed': {
-                tracker.status = 'failed';
-                tracker.error = status.error;
-                console.error(`[${taskLogId}] Task failed: ${status.error}`);
-                await get().optimisticUpdateMessageContent(
-                  tracker.taskMessageId,
-                  `Task failed: ${status.error}`,
-                  undefined,
-                  { operationId: state.operationId },
-                );
-              
-              break;
-              }
-              case 'cancel': {
-                tracker.status = 'failed';
-                tracker.error = 'Task was cancelled';
-                log(`[${taskLogId}] Task was cancelled`);
-                await get().optimisticUpdateMessageContent(
-                  tracker.taskMessageId,
-                  'Task was cancelled',
-                  undefined,
-                  { operationId: state.operationId },
-                );
-              
-              break;
-              }
-              // No default
+                case 'cancel': {
+                  tracker.status = 'failed';
+                  tracker.error = 'Task was cancelled';
+                  log(`[${taskLogId}] Task was cancelled`);
+                  await get().optimisticUpdateMessageContent(
+                    tracker.taskMessageId,
+                    'Task was cancelled',
+                    undefined,
+                    { operationId: state.operationId },
+                  );
+
+                  break;
+                }
+                // No default
               }
 
               // Check individual task timeout

package/src/store/chat/slices/aiChat/actions/__tests__/streamingExecutor.test.ts

@@ -1451,6 +1451,84 @@ describe('StreamingExecutor actions', () => {
     });
   });
 
+  describe('internal_createAgentState with disableTools', () => {
+    it('should return empty toolManifestMap when disableTools is true', async () => {
+      act(() => {
+        useChatStore.setState({ internal_execAgentRuntime: realExecAgentRuntime });
+      });
+
+      const { result } = renderHook(() => useChatStore());
+      const userMessage = {
+        id: TEST_IDS.USER_MESSAGE_ID,
+        role: 'user',
+        content: TEST_CONTENT.USER_MESSAGE,
+        sessionId: TEST_IDS.SESSION_ID,
+        topicId: TEST_IDS.TOPIC_ID,
+      } as UIChatMessage;
+
+      // Get actual internal_createAgentState result with disableTools: true
+      const { state } = result.current.internal_createAgentState({
+        messages: [userMessage],
+        parentMessageId: userMessage.id,
+        agentId: TEST_IDS.SESSION_ID,
+        topicId: TEST_IDS.TOPIC_ID,
+        disableTools: true,
+      });
+
+      // toolManifestMap should be empty when disableTools is true
+      expect(state.toolManifestMap).toEqual({});
+    });
+
+    it('should include tools in toolManifestMap when disableTools is false or undefined', async () => {
+      act(() => {
+        useChatStore.setState({ internal_execAgentRuntime: realExecAgentRuntime });
+      });
+
+      const { result } = renderHook(() => useChatStore());
+      const userMessage = {
+        id: TEST_IDS.USER_MESSAGE_ID,
+        role: 'user',
+        content: TEST_CONTENT.USER_MESSAGE,
+        sessionId: TEST_IDS.SESSION_ID,
+        topicId: TEST_IDS.TOPIC_ID,
+      } as UIChatMessage;
+
+      // Mock resolveAgentConfig to return plugins
+      vi.spyOn(agentConfigResolver, 'resolveAgentConfig').mockReturnValue({
+        agentConfig: {
+          ...createMockAgentConfig(),
+          plugins: ['test-plugin'],
+        },
+        chatConfig: createMockChatConfig(),
+        isBuiltinAgent: false,
+        plugins: ['test-plugin'],
+      });
+
+      // Get actual internal_createAgentState result without disableTools
+      const { state: stateWithoutDisable } = result.current.internal_createAgentState({
+        messages: [userMessage],
+        parentMessageId: userMessage.id,
+        agentId: TEST_IDS.SESSION_ID,
+        topicId: TEST_IDS.TOPIC_ID,
+        // disableTools not set (undefined)
+      });
+
+      // Get actual internal_createAgentState result with disableTools: false
+      const { state: stateWithDisableFalse } = result.current.internal_createAgentState({
+        messages: [userMessage],
+        parentMessageId: userMessage.id,
+        agentId: TEST_IDS.SESSION_ID,
+        topicId: TEST_IDS.TOPIC_ID,
+        disableTools: false,
+      });
+
+      // Both should have the same toolManifestMap (tools enabled)
+      // Note: The actual content depends on what plugins are resolved,
+      // but the key point is they should not be empty (unless no plugins are configured)
+      expect(stateWithoutDisable.toolManifestMap).toEqual(stateWithDisableFalse.toolManifestMap);
+    });
+  });
+
   describe('operation status handling', () => {
     it('should complete operation when state is waiting_for_human', async () => {
       const { result } = renderHook(() => useChatStore());

package/src/store/chat/slices/aiChat/actions/streamingExecutor.ts

@@ -59,6 +59,11 @@ export interface StreamingExecutorAction {
      * Explicit agentId for this execution (avoids using global activeAgentId)
      */
     agentId?: string;
+    /**
+     * Whether to disable tools for this agent execution
+     * When true, agent will respond without calling any tools
+     */
+    disableTools?: boolean;
     /**
      * Explicit topicId for this execution (avoids using global activeTopicId)
      */
@@ -117,6 +122,11 @@ export interface StreamingExecutorAction {
      * Contains agentId, topicId, threadId, groupId, scope, etc.
      */
     context: ConversationContext;
+    /**
+     * Whether to disable tools for this agent execution
+     * When true, agent will respond without calling any tools
+     */
+    disableTools?: boolean;
     /**
      * Initial agent runtime context (for resuming execution from a specific phase)
      */
@@ -156,6 +166,7 @@ export const streamingExecutor: StateCreator<
     messages,
     parentMessageId,
     agentId: paramAgentId,
+    disableTools,
     topicId: paramTopicId,
     threadId,
     initialState,
@@ -165,8 +176,9 @@ export const streamingExecutor: StateCreator<
     isSubTask,
   }) => {
     // Use provided agentId/topicId or fallback to global state
+    // Note: Use || instead of ?? to also fallback when paramAgentId is empty string
     const { activeAgentId, activeTopicId } = get();
-    const agentId = paramAgentId ?? activeAgentId;
+    const agentId = paramAgentId || activeAgentId;
     const topicId = paramTopicId !== undefined ? paramTopicId : activeTopicId;
 
     // For group orchestration scenarios:
@@ -181,29 +193,48 @@ export const streamingExecutor: StateCreator<
 
     // Resolve agent config with builtin agent runtime config merged
     // This ensures runtime plugins (e.g., 'lobe-agent-builder' for Agent Builder) are included
-    // isSubTask is passed to filter out lobe-gtd tools to prevent nested sub-task creation
+    // - isSubTask: filters out lobe-gtd tools to prevent nested sub-task creation
+    // - disableTools: clears all plugins for broadcast scenarios
     const agentConfig = resolveAgentConfig({
       agentId: effectiveAgentId || '',
+      disableTools, // Clear plugins for broadcast scenarios
       groupId, // Pass groupId for supervisor detection
       isSubTask, // Filter out lobe-gtd in sub-task context
       scope, // Pass scope from operation context
     });
     const { agentConfig: agentConfigData, plugins: pluginIds } = agentConfig;
 
-    log('[internal_createAgentState] resolved plugins=%o, isSubTask=%s', pluginIds, isSubTask);
+    log(
+      '[internal_createAgentState] resolved plugins=%o, isSubTask=%s, disableTools=%s',
+      pluginIds,
+      isSubTask,
+      disableTools,
+    );
 
-    // Get tools manifest map
-    const toolsEngine = createAgentToolsEngine({
-      model: agentConfigData.model,
-      provider: agentConfigData.provider!,
-    });
-    const { enabledToolIds } = toolsEngine.generateToolsDetailed({
-      model: agentConfigData.model,
-      provider: agentConfigData.provider!,
-      toolIds: pluginIds,
-    });
-    const toolManifestMap = Object.fromEntries(
-      toolsEngine.getEnabledPluginManifests(enabledToolIds).entries(),
+    // Get tools manifest map (skip if disableTools is true / no plugins)
+    let toolManifestMap: Record<string, unknown> = {};
+    let enabledToolIds: string[] = [];
+
+    if (pluginIds.length > 0) {
+      const toolsEngine = createAgentToolsEngine({
+        model: agentConfigData.model,
+        provider: agentConfigData.provider!,
+      });
+      const toolsDetailed = toolsEngine.generateToolsDetailed({
+        model: agentConfigData.model,
+        provider: agentConfigData.provider!,
+        toolIds: pluginIds,
+      });
+      enabledToolIds = toolsDetailed.enabledToolIds;
+      toolManifestMap = Object.fromEntries(
+        toolsEngine.getEnabledPluginManifests(enabledToolIds).entries(),
+      );
+    }
+
+    log(
+      '[internal_createAgentState] toolManifestMap keys=%o, count=%d',
+      Object.keys(toolManifestMap),
+      Object.keys(toolManifestMap).length,
     );
 
     // Get user intervention config
@@ -549,6 +580,7 @@ export const streamingExecutor: StateCreator<
 
   internal_execAgentRuntime: async (params) => {
     const {
+      disableTools,
       messages: originalMessages,
       parentMessageId,
       parentMessageType,
@@ -588,7 +620,7 @@ export const streamingExecutor: StateCreator<
     }
 
     log(
-      '[internal_execAgentRuntime] start, operationId: %s, agentId: %s, subAgentId: %s, effectiveAgentId: %s, topicId: %s, messageKey: %s, parentMessageId: %s, parentMessageType: %s, messages count: %d',
+      '[internal_execAgentRuntime] start, operationId: %s, agentId: %s, subAgentId: %s, effectiveAgentId: %s, topicId: %s, messageKey: %s, parentMessageId: %s, parentMessageType: %s, messages count: %d, disableTools: %s',
       operationId,
       agentId,
       subAgentId,
@@ -598,6 +630,7 @@ export const streamingExecutor: StateCreator<
       parentMessageId,
       parentMessageType,
       originalMessages.length,
+      disableTools,
     );
 
     // Create a new array to avoid modifying the original messages
@@ -615,6 +648,7 @@ export const streamingExecutor: StateCreator<
       messages,
       parentMessageId: params.parentMessageId,
       agentId,
+      disableTools,
       topicId,
       threadId: threadId ?? undefined,
       initialState: params.initialState,

package/src/store/global/initialState.ts

@@ -48,6 +48,7 @@ export enum SettingsTabs {
   Provider = 'provider',
   Proxy = 'proxy',
   Security = 'security',
+  Skill = 'skill',
   Stats = 'stats',
   Storage = 'storage',
   TTS = 'tts',