@lobehub/lobehub 2.0.0-next.311 → 2.0.0-next.313

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

@@ -3,6 +3,7 @@ import type {
   GroupOrchestrationExecutor,
   GroupOrchestrationExecutorOutput,
   SupervisorInstruction,
+  SupervisorInstructionBatchExecAsyncTasks,
   SupervisorInstructionCallAgent,
   SupervisorInstructionCallSupervisor,
   SupervisorInstructionDelegate,
@@ -589,5 +590,298 @@ export const createGroupOrchestrationExecutors = (
         };
       }
     },
+
+    /**
+     * batch_exec_async_tasks Executor
+     * Executes multiple async tasks for agents in parallel using aiAgentService with polling
+     *
+     * Flow:
+     * 1. Create task messages (role: 'task') for each task as placeholders
+     * 2. Call execSubAgentTask API for each task in parallel
+     * 3. Poll for all tasks completion
+     * 4. Update task messages with results on completion
+     *
+     * Returns: tasks_completed result
+     */
+    batch_exec_async_tasks: async (
+      instruction,
+      state,
+    ): Promise<GroupOrchestrationExecutorOutput> => {
+      const { tasks, toolMessageId } = (instruction as SupervisorInstructionBatchExecAsyncTasks)
+        .payload;
+
+      const sessionLogId = `${state.operationId}:batch_exec_async_tasks`;
+      log(`[${sessionLogId}] Executing ${tasks.length} async tasks in parallel`);
+
+      const { groupId, topicId } = messageContext;
+
+      if (!groupId || !topicId) {
+        log(`[${sessionLogId}] No valid context, cannot execute async tasks`, groupId, topicId);
+        return {
+          events: [] as GroupOrchestrationEvent[],
+          newState: state,
+          result: {
+            payload: {
+              results: tasks.map((t) => ({
+                agentId: t.agentId,
+                error: 'No valid context available',
+                success: false,
+              })),
+            },
+            type: 'tasks_completed',
+          },
+        };
+      }
+
+      // Track all tasks with their messages and thread IDs
+      interface TaskTracker {
+        agentId: string;
+        error?: string;
+        result?: string;
+        status: 'pending' | 'running' | 'completed' | 'failed';
+        task: string;
+        taskMessageId?: string;
+        threadId?: string;
+        timeout: number;
+        title?: string;
+      }
+
+      const taskTrackers: TaskTracker[] = tasks.map((t) => ({
+        agentId: t.agentId,
+        status: 'pending',
+        task: t.task,
+        timeout: t.timeout || 1_800_000, // Default 30 minutes
+        title: t.title,
+      }));
+
+      // 1. Create task messages for all tasks in parallel
+      await Promise.all(
+        taskTrackers.map(async (tracker, index) => {
+          const taskLogId = `${sessionLogId}:task-${index}`;
+          try {
+            const taskMessageResult = await get().optimisticCreateMessage(
+              {
+                agentId: tracker.agentId,
+                content: '',
+                groupId,
+                metadata: { instruction: tracker.task, taskTitle: tracker.title },
+                parentId: toolMessageId,
+                role: 'task',
+                topicId,
+              },
+              { operationId: state.operationId },
+            );
+
+            if (taskMessageResult) {
+              tracker.taskMessageId = taskMessageResult.id;
+              log(`[${taskLogId}] Created task message: ${tracker.taskMessageId}`);
+            } else {
+              tracker.status = 'failed';
+              tracker.error = 'Failed to create task message';
+              console.error(`[${taskLogId}] Failed to create task message`);
+            }
+          } catch (error) {
+            tracker.status = 'failed';
+            tracker.error = error instanceof Error ? error.message : 'Unknown error';
+            console.error(`[${taskLogId}] Error creating task message: ${error}`);
+          }
+        }),
+      );
+
+      // 2. Start all tasks in parallel via backend API
+      await Promise.all(
+        taskTrackers.map(async (tracker, index) => {
+          if (tracker.status === 'failed' || !tracker.taskMessageId) return;
+
+          const taskLogId = `${sessionLogId}:task-${index}`;
+          try {
+            const createResult = await aiAgentService.execSubAgentTask({
+              agentId: tracker.agentId,
+              groupId,
+              instruction: tracker.task,
+              parentMessageId: tracker.taskMessageId,
+              title: tracker.title,
+              topicId,
+            });
+
+            if (createResult.success) {
+              tracker.threadId = createResult.threadId;
+              tracker.status = 'running';
+              log(`[${taskLogId}] Task started with threadId: ${tracker.threadId}`);
+            } else {
+              tracker.status = 'failed';
+              tracker.error = createResult.error;
+              log(`[${taskLogId}] Failed to start task: ${createResult.error}`);
+              // Update task message with error
+              await get().optimisticUpdateMessageContent(
+                tracker.taskMessageId,
+                `Task creation failed: ${createResult.error}`,
+                undefined,
+                { operationId: state.operationId },
+              );
+            }
+          } catch (error) {
+            tracker.status = 'failed';
+            tracker.error = error instanceof Error ? error.message : 'Unknown error';
+            console.error(`[${taskLogId}] Error starting task: ${error}`);
+          }
+        }),
+      );
+
+      // 3. Poll for all tasks completion
+      const pollInterval = 3000; // 3 seconds
+      const startTime = Date.now();
+      const maxTimeout = Math.max(...taskTrackers.map((t) => t.timeout));
+
+      while (Date.now() - startTime < maxTimeout) {
+        // Check if operation has been cancelled
+        const currentOperation = get().operations[state.operationId];
+        if (currentOperation?.status === 'cancelled') {
+          console.warn(`[${sessionLogId}] Operation cancelled, stopping polling`);
+          return {
+            events: [] as GroupOrchestrationEvent[],
+            newState: { ...state, status: 'done' },
+            result: {
+              payload: {
+                results: taskTrackers.map((t) => ({
+                  agentId: t.agentId,
+                  error: t.status === 'running' ? 'Operation cancelled' : t.error,
+                  result: t.result,
+                  success: t.status === 'completed',
+                })),
+              },
+              type: 'tasks_completed',
+            },
+          };
+        }
+
+        // Check status of all running tasks
+        const runningTasks = taskTrackers.filter((t) => t.status === 'running');
+        if (runningTasks.length === 0) {
+          // All tasks have completed or failed
+          break;
+        }
+
+        await Promise.all(
+          runningTasks.map(async (tracker, index) => {
+            if (!tracker.threadId || !tracker.taskMessageId) return;
+
+            const taskLogId = `${sessionLogId}:task-${index}`;
+            try {
+              const status = await aiAgentService.getSubAgentTaskStatus({
+                threadId: tracker.threadId,
+              });
+
+              // Update taskDetail in message if available
+              if (status.taskDetail) {
+                get().internal_dispatchMessage(
+                  {
+                    id: tracker.taskMessageId,
+                    type: 'updateMessage',
+                    value: { taskDetail: status.taskDetail },
+                  },
+                  { operationId: state.operationId },
+                );
+              }
+
+              switch (status.status) {
+              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,
+                  `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
+              }
+
+              // Check individual task timeout
+              if (tracker.status === 'running' && Date.now() - startTime > tracker.timeout) {
+                tracker.status = 'failed';
+                tracker.error = `Task timeout after ${tracker.timeout}ms`;
+                log(`[${taskLogId}] Task timeout`);
+                await get().optimisticUpdateMessageContent(
+                  tracker.taskMessageId,
+                  `Task timeout after ${tracker.timeout}ms`,
+                  undefined,
+                  { operationId: state.operationId },
+                );
+              }
+            } catch (error) {
+              console.error(`[${taskLogId}] Error polling task status: ${error}`);
+            }
+          }),
+        );
+
+        // Wait before next poll
+        await sleep(pollInterval);
+      }
+
+      // Mark any remaining running tasks as timed out
+      for (const tracker of taskTrackers) {
+        if (tracker.status === 'running' && tracker.taskMessageId) {
+          tracker.status = 'failed';
+          tracker.error = `Task timeout after ${tracker.timeout}ms`;
+          await get().optimisticUpdateMessageContent(
+            tracker.taskMessageId,
+            `Task timeout after ${tracker.timeout}ms`,
+            undefined,
+            { operationId: state.operationId },
+          );
+        }
+      }
+
+      log(`[${sessionLogId}] All tasks completed`);
+
+      return {
+        events: [] as GroupOrchestrationEvent[],
+        newState: state,
+        result: {
+          payload: {
+            results: taskTrackers.map((t) => ({
+              agentId: t.agentId,
+              error: t.error,
+              result: t.result,
+              success: t.status === 'completed',
+            })),
+          },
+          type: 'tasks_completed',
+        },
+      };
+    },
   };
 };

package/src/store/chat/slices/plugin/action.test.ts

@@ -1606,53 +1606,5 @@ describe('ChatPluginAction', () => {
         );
       });
     });
-
-    describe('invokeCloudCodeInterpreterTool', () => {
-      it('should use optimisticUpdateToolMessage for successful result', async () => {
-        const mockResult = {
-          content: 'code interpreter result',
-          state: { output: 'test output' },
-          success: true,
-        };
-
-        // Mock CloudSandboxExecutionRuntime using doMock for dynamic mocking
-        vi.doMock('@lobechat/builtin-tool-cloud-sandbox/executionRuntime', () => ({
-          CloudSandboxExecutionRuntime: class {
-            'test-api' = vi.fn().mockResolvedValue(mockResult);
-          },
-        }));
-
-        const optimisticUpdateToolMessageMock = vi.fn().mockResolvedValue(undefined);
-
-        act(() => {
-          useChatStore.setState({
-            activeAgentId: 'session-id',
-            messagesMap: { [messageMapKey({ agentId: 'session-id' })]: [] },
-            optimisticUpdateToolMessage: optimisticUpdateToolMessageMock,
-            replaceMessages: vi.fn(),
-            messageOperationMap: {},
-            operations: {},
-          });
-        });
-
-        const { result } = renderHook(() => useChatStore());
-
-        await act(async () => {
-          await result.current.invokeCloudCodeInterpreterTool(messageId, payload);
-        });
-
-        expect(optimisticUpdateToolMessageMock).toHaveBeenCalledWith(
-          messageId,
-          {
-            content: mockResult.content,
-            pluginError: undefined,
-            pluginState: mockResult.state,
-          },
-          undefined,
-        );
-
-        vi.doUnmock('@lobechat/builtin-tool-cloud-sandbox/executionRuntime');
-      });
-    });
   });
 });

package/src/store/chat/slices/plugin/actions/pluginTypes.ts

@@ -1,5 +1,4 @@
 /* eslint-disable sort-keys-fix/sort-keys-fix, typescript-sort-keys/interface */
-import { CloudSandboxIdentifier, type ExportFileState } from '@lobechat/builtin-tool-cloud-sandbox';
 import { type ChatToolPayload, type RuntimeStepContext } from '@lobechat/types';
 import { PluginErrorType } from '@lobehub/chat-plugin-sdk';
 import debug from 'debug';
@@ -14,8 +13,6 @@ import { AI_RUNTIME_OPERATION_TYPES } from '@/store/chat/slices/operation';
 import { type ChatStore } from '@/store/chat/store';
 import { useToolStore } from '@/store/tool';
 import { hasExecutor } from '@/store/tool/slices/builtin/executors';
-import { useUserStore } from '@/store/user';
-import { userProfileSelectors } from '@/store/user/slices/auth/selectors';
 import { safeParseJSON } from '@/utils/safeParseJSON';
 
 import { dbMessageSelectors } from '../../message/selectors';
@@ -42,14 +39,6 @@ export interface PluginTypesAction {
     stepContext?: RuntimeStepContext,
   ) => Promise<any>;
 
-  /**
-   * Invoke Cloud Code Interpreter tool
-   */
-  invokeCloudCodeInterpreterTool: (
-    id: string,
-    payload: ChatToolPayload,
-  ) => Promise<string | undefined>;
-
   /**
    * Invoke default type plugin (returns data)
    */
@@ -116,11 +105,6 @@ export const pluginTypes: StateCreator<
       return await get().invokeLobehubSkillTypePlugin(id, payload);
     }
 
-    // Check if this is Cloud Code Interpreter - route to specific handler
-    if (payload.identifier === CloudSandboxIdentifier) {
-      return await get().invokeCloudCodeInterpreterTool(id, payload);
-    }
-
     const params = safeParseJSON(payload.arguments);
     if (!params) return { error: 'Invalid arguments', success: false };
 
@@ -245,121 +229,6 @@ export const pluginTypes: StateCreator<
     return;
   },
 
-  invokeCloudCodeInterpreterTool: async (id, payload) => {
-    // Get message to extract topicId
-    const message = dbMessageSelectors.getDbMessageById(id)(get());
-
-    // Get abort controller from operation
-    const operationId = get().messageOperationMap[id];
-    const operation = operationId ? get().operations[operationId] : undefined;
-    const abortController = operation?.abortController;
-
-    log(
-      '[invokeCloudCodeInterpreterTool] messageId=%s, tool=%s, operationId=%s, aborted=%s',
-      id,
-      payload.apiName,
-      operationId,
-      abortController?.signal.aborted,
-    );
-
-    let data: { content: string; error?: any; state?: any; success: boolean } | undefined;
-
-    try {
-      // Import ExecutionRuntime dynamically to avoid circular dependencies
-      const { CloudSandboxExecutionRuntime } =
-        await import('@lobechat/builtin-tool-cloud-sandbox/executionRuntime');
-
-      // Get userId from user store
-      const userId = userProfileSelectors.userId(useUserStore.getState()) || 'anonymous';
-
-      // Create runtime with context
-      const runtime = new CloudSandboxExecutionRuntime({
-        topicId: message?.topicId || 'default',
-        userId,
-      });
-
-      // Parse arguments
-      const args = safeParseJSON(payload.arguments) || {};
-
-      // Call the appropriate method based on apiName
-      const apiMethod = (runtime as Record<string, any>)[payload.apiName];
-      if (!apiMethod) {
-        throw new Error(`Cloud Code Interpreter API not found: ${payload.apiName}`);
-      }
-
-      data = await apiMethod.call(runtime, args);
-    } catch (error) {
-      console.error('[invokeCloudCodeInterpreterTool] Error:', error);
-
-      const err = error as Error;
-      if (err.message.includes('aborted') || err.message.includes('The user aborted a request.')) {
-        log(
-          '[invokeCloudCodeInterpreterTool] Request aborted: messageId=%s, tool=%s',
-          id,
-          payload.apiName,
-        );
-      } else {
-        const result = await messageService.updateMessageError(id, error as any, {
-          agentId: message?.agentId,
-          topicId: message?.topicId,
-        });
-        if (result?.success && result.messages) {
-          get().replaceMessages(result.messages, {
-            context: {
-              agentId: message?.agentId,
-              topicId: message?.topicId,
-            },
-          });
-        }
-      }
-    }
-
-    if (!data) return;
-
-    const context = operationId ? { operationId } : undefined;
-
-    // Use optimisticUpdateToolMessage to update content and state/error in a single call
-    await get().optimisticUpdateToolMessage(
-      id,
-      {
-        content: data.content,
-        pluginError: data.success ? undefined : data.error,
-        pluginState: data.success ? data.state : undefined,
-      },
-      context,
-    );
-
-    // Handle exportFile: associate the file (already created by server) with assistant message (parent)
-    if (payload.apiName === 'exportFile' && data.success && data.state) {
-      const exportState = data.state as ExportFileState;
-      // Server now creates the file record and returns fileId in the response
-      if (exportState.fileId && exportState.filename) {
-        try {
-          // Associate file with the assistant message (parent of tool message)
-          // The current message (id) is the tool message, we need to attach to its parent
-          const targetMessageId = message?.parentId || id;
-
-          await messageService.addFilesToMessage(targetMessageId, [exportState.fileId], {
-            agentId: message?.agentId,
-            topicId: message?.topicId,
-          });
-
-          log(
-            '[invokeCloudCodeInterpreterTool] Associated exported file with message: targetMessageId=%s, fileId=%s, filename=%s',
-            targetMessageId,
-            exportState.fileId,
-            exportState.filename,
-          );
-        } catch (error) {
-          // Log error but don't fail the tool execution
-          console.error('[invokeCloudCodeInterpreterTool] Failed to save exported file:', error);
-        }
-      }
-    }
-
-    return data.content;
-  },
-
   invokeDefaultTypePlugin: async (id, payload) => {
     const { internal_callPluginApi } = get();
 

package/src/store/tool/slices/builtin/executors/index.ts

@@ -5,6 +5,7 @@
  * Executors are registered as class instances by identifier.
  */
 import { agentBuilderExecutor } from '@lobechat/builtin-tool-agent-builder/executor';
+import { cloudSandboxExecutor } from '@lobechat/builtin-tool-cloud-sandbox/executor';
 import { groupAgentBuilderExecutor } from '@lobechat/builtin-tool-group-agent-builder/executor';
 import { groupManagementExecutor } from '@lobechat/builtin-tool-group-management/executor';
 import { gtdExecutor } from '@lobechat/builtin-tool-gtd/executor';
@@ -120,6 +121,7 @@ const registerExecutors = (executors: IBuiltinToolExecutor[]): void => {
 // Register all executor instances
 registerExecutors([
   agentBuilderExecutor,
+  cloudSandboxExecutor,
   groupAgentBuilderExecutor,
   groupManagementExecutor,
   gtdExecutor,

package/src/store/user/slices/settings/selectors/toolIntervention.test.ts

@@ -0,0 +1,143 @@
+import { UserStore } from '@/store/user';
+import { UserState, initialState } from '@/store/user/initialState';
+import { merge } from '@/utils/merge';
+
+import { toolInterventionSelectors } from './toolIntervention';
+
+describe('toolInterventionSelectors', () => {
+  describe('approvalMode', () => {
+    it('should return "manual" by default when no config exists', () => {
+      const s: UserState = merge(initialState, {
+        settings: {},
+      });
+
+      const result = toolInterventionSelectors.approvalMode(s as UserStore);
+
+      expect(result).toBe('manual');
+    });
+
+    it('should return "auto-run" when configured', () => {
+      const s: UserState = merge(initialState, {
+        settings: {
+          tool: {
+            humanIntervention: {
+              approvalMode: 'auto-run',
+            },
+          },
+        },
+      });
+
+      const result = toolInterventionSelectors.approvalMode(s as UserStore);
+
+      expect(result).toBe('auto-run');
+    });
+
+    it('should return "allow-list" when configured', () => {
+      const s: UserState = merge(initialState, {
+        settings: {
+          tool: {
+            humanIntervention: {
+              approvalMode: 'allow-list',
+            },
+          },
+        },
+      });
+
+      const result = toolInterventionSelectors.approvalMode(s as UserStore);
+
+      expect(result).toBe('allow-list');
+    });
+
+    it('should return "manual" when configured', () => {
+      const s: UserState = merge(initialState, {
+        settings: {
+          tool: {
+            humanIntervention: {
+              approvalMode: 'manual',
+            },
+          },
+        },
+      });
+
+      const result = toolInterventionSelectors.approvalMode(s as UserStore);
+
+      expect(result).toBe('manual');
+    });
+
+    it('should fallback to "auto-run" when approvalMode is "headless"', () => {
+      const s: UserState = merge(initialState, {
+        settings: {
+          tool: {
+            humanIntervention: {
+              approvalMode: 'headless' as any,
+            },
+          },
+        },
+      });
+
+      const result = toolInterventionSelectors.approvalMode(s as UserStore);
+
+      // headless is for backend async tasks only, UI should show auto-run
+      expect(result).toBe('auto-run');
+    });
+  });
+
+  describe('allowList', () => {
+    it('should return empty array by default', () => {
+      const s: UserState = merge(initialState, {
+        settings: {},
+      });
+
+      const result = toolInterventionSelectors.allowList(s as UserStore);
+
+      expect(result).toEqual([]);
+    });
+
+    it('should return configured allowList', () => {
+      const allowList = ['bash/bash', 'web-search/search'];
+      const s: UserState = merge(initialState, {
+        settings: {
+          tool: {
+            humanIntervention: {
+              allowList,
+            },
+          },
+        },
+      });
+
+      const result = toolInterventionSelectors.allowList(s as UserStore);
+
+      expect(result).toEqual(allowList);
+    });
+  });
+
+  describe('config', () => {
+    it('should return empty object by default', () => {
+      const s: UserState = merge(initialState, {
+        settings: {},
+      });
+
+      const result = toolInterventionSelectors.config(s as UserStore);
+
+      expect(result).toEqual({});
+    });
+
+    it('should return full humanIntervention config', () => {
+      const config = {
+        approvalMode: 'allow-list' as const,
+        allowList: ['bash/bash'],
+      };
+      const s: UserState = merge(initialState, {
+        settings: {
+          tool: {
+            humanIntervention: config,
+          },
+        },
+      });
+
+      const result = toolInterventionSelectors.config(s as UserStore);
+
+      expect(result).toEqual(config);
+    });
+  });
+});