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

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',