@lobehub/lobehub 2.0.10 → 2.0.12

package/packages/agent-runtime/src/groupOrchestration/__tests__/GroupOrchestrationSupervisor.test.ts

@@ -161,7 +161,7 @@ describe('GroupOrchestrationSupervisor', () => {
           decision: 'execute_task',
           params: {
             agentId: 'agent-1',
-            task: 'Analyze data',
+            instruction: 'Analyze data',
             timeout: 30000,
             toolMessageId: 'tool-msg-1',
           },
@@ -175,7 +175,7 @@ describe('GroupOrchestrationSupervisor', () => {
         type: 'exec_async_task',
         payload: {
           agentId: 'agent-1',
-          task: 'Analyze data',
+          instruction: 'Analyze data',
           timeout: 30000,
           title: undefined,
           toolMessageId: 'tool-msg-1',
@@ -193,7 +193,7 @@ describe('GroupOrchestrationSupervisor', () => {
           decision: 'execute_task',
           params: {
             agentId: 'agent-1',
-            task: 'Analyze data',
+            instruction: 'Analyze data',
             timeout: 30000,
             title: 'Data Analysis Task',
             toolMessageId: 'tool-msg-1',
@@ -208,7 +208,7 @@ describe('GroupOrchestrationSupervisor', () => {
         type: 'exec_async_task',
         payload: {
           agentId: 'agent-1',
-          task: 'Analyze data',
+          instruction: 'Analyze data',
           timeout: 30000,
           title: 'Data Analysis Task',
           toolMessageId: 'tool-msg-1',
@@ -409,7 +409,7 @@ describe('GroupOrchestrationSupervisor', () => {
           type: 'supervisor_decided',
           payload: {
             decision: 'execute_task',
-            params: { agentId: 'agent-1', task: 'Do something', toolMessageId: 'tool-1' },
+            params: { agentId: 'agent-1', instruction: 'Do something', toolMessageId: 'tool-1' },
             skipCallSupervisor: false,
           },
         },
@@ -427,6 +427,77 @@ describe('GroupOrchestrationSupervisor', () => {
     });
   });
 
+  describe('decide - execute_tasks decision', () => {
+    it('should return batch_exec_async_tasks instruction for execute_tasks decision', async () => {
+      // Regression test: execute_tasks decision should return batch_exec_async_tasks instruction
+      // Previously, execute_tasks was not implemented and would fall through to default case,
+      // returning { type: 'finish', reason: 'unknown_decision: execute_tasks' }
+      const supervisor = new GroupOrchestrationSupervisor(defaultConfig);
+      const state = createMockState();
+
+      const result: ExecutorResult = {
+        type: 'supervisor_decided',
+        payload: {
+          decision: 'execute_tasks',
+          params: {
+            tasks: [
+              { agentId: 'agent-1', title: 'Task 1', instruction: 'Do task 1' },
+              { agentId: 'agent-2', title: 'Task 2', instruction: 'Do task 2' },
+            ],
+            toolMessageId: 'tool-msg-1',
+          },
+          skipCallSupervisor: false,
+        },
+      };
+
+      const instruction = await supervisor.decide(result, state);
+
+      // Should return batch_exec_async_tasks, NOT finish with unknown_decision
+      expect(instruction.type).toBe('batch_exec_async_tasks');
+      expect((instruction as any).payload).toEqual({
+        tasks: [
+          { agentId: 'agent-1', title: 'Task 1', instruction: 'Do task 1' },
+          { agentId: 'agent-2', title: 'Task 2', instruction: 'Do task 2' },
+        ],
+        toolMessageId: 'tool-msg-1',
+      });
+    });
+
+    it('should handle execute_tasks with skipCallSupervisor flag', async () => {
+      const supervisor = new GroupOrchestrationSupervisor(defaultConfig);
+      const state = createMockState();
+
+      // First, trigger execute_tasks with skipCallSupervisor: true
+      await supervisor.decide(
+        {
+          type: 'supervisor_decided',
+          payload: {
+            decision: 'execute_tasks',
+            params: {
+              tasks: [{ agentId: 'agent-1', title: 'Task 1', instruction: 'Do task 1' }],
+              toolMessageId: 'tool-msg-1',
+            },
+            skipCallSupervisor: true,
+          },
+        },
+        state,
+      );
+
+      // When tasks_completed, should finish (not call supervisor again)
+      const result: ExecutorResult = {
+        type: 'tasks_completed',
+        payload: { results: [{ agentId: 'agent-1', success: true }] },
+      };
+
+      const instruction = await supervisor.decide(result, state);
+
+      expect(instruction).toEqual({
+        type: 'finish',
+        reason: 'skip_call_supervisor',
+      });
+    });
+  });
+
   describe('decide - delegated result', () => {
     it('should always return finish instruction', async () => {
       const supervisor = new GroupOrchestrationSupervisor(defaultConfig);

package/packages/agent-runtime/src/groupOrchestration/types.ts

@@ -53,7 +53,7 @@ export interface SupervisorInstructionParallelCallAgents {
 export interface SupervisorInstructionExecAsyncTask {
   payload: {
     agentId: string;
-    task: string;
+    instruction: string;
     timeout?: number;
     /** Task title (shown in UI, used as thread title) */
     title?: string;
@@ -69,7 +69,7 @@ export interface SupervisorInstructionExecAsyncTask {
 export interface SupervisorInstructionExecClientAsyncTask {
   payload: {
     agentId: string;
-    task: string;
+    instruction: string;
     timeout?: number;
     /** Task title (shown in UI, used as thread title) */
     title?: string;
@@ -85,7 +85,7 @@ export interface SupervisorInstructionBatchExecAsyncTasks {
   payload: {
     tasks: Array<{
       agentId: string;
-      task: string;
+      instruction: string;
       timeout?: number;
       /** Task title (shown in UI, used as thread title) */
       title?: string;

package/packages/builtin-tool-group-management/src/client/Intervention/ExecuteTask.tsx

@@ -81,21 +81,21 @@ const ExecuteTaskIntervention = memo<BuiltinInterventionProps<ExecuteTaskParams>
     );
 
     // Local state
-    const [task, setTask] = useState(args?.task || '');
+    const [instruction, setInstruction] = useState(args?.instruction || '');
     const [timeout, setTimeout] = useState(args?.timeout ?? DEFAULT_TIMEOUT);
     const [hasChanges, setHasChanges] = useState(false);
 
     // Sync local state when args change externally
     useEffect(() => {
       if (!hasChanges) {
-        setTask(args?.task || '');
+        setInstruction(args?.instruction || '');
         setTimeout(args?.timeout ?? DEFAULT_TIMEOUT);
       }
-    }, [args?.task, args?.timeout, hasChanges]);
+    }, [args?.instruction, args?.timeout, hasChanges]);
 
-    // Handle task change
-    const handleTaskChange = useCallback((e: ChangeEvent<HTMLTextAreaElement>) => {
-      setTask(e.target.value);
+    // Handle instruction change
+    const handleInstructionChange = useCallback((e: ChangeEvent<HTMLTextAreaElement>) => {
+      setInstruction(e.target.value);
       setHasChanges(true);
     }, []);
 
@@ -113,12 +113,12 @@ const ExecuteTaskIntervention = memo<BuiltinInterventionProps<ExecuteTaskParams>
 
       const cleanup = registerBeforeApprove('executeTask', async () => {
         if (hasChanges && onArgsChange) {
-          await onArgsChange({ ...args, task, timeout });
+          await onArgsChange({ ...args, instruction, timeout });
         }
       });
 
       return cleanup;
-    }, [registerBeforeApprove, hasChanges, task, timeout, args, onArgsChange]);
+    }, [registerBeforeApprove, hasChanges, instruction, timeout, args, onArgsChange]);
 
     return (
       <Flexbox className={styles.container} gap={12}>
@@ -154,12 +154,12 @@ const ExecuteTaskIntervention = memo<BuiltinInterventionProps<ExecuteTaskParams>
           </Flexbox>
         </Flexbox>
 
-        {/* Task input */}
+        {/* Instruction input */}
         <Input.TextArea
           autoSize={{ maxRows: 10, minRows: 6 }}
-          onChange={handleTaskChange}
+          onChange={handleInstructionChange}
           placeholder={t('agentGroupManagement.executeTask.intervention.taskPlaceholder')}
-          value={task}
+          value={instruction}
         />
       </Flexbox>
     );

package/packages/builtin-tool-group-management/src/client/Intervention/ExecuteTasks.tsx

@@ -2,8 +2,8 @@
 
 import { DEFAULT_AVATAR } from '@lobechat/const';
 import { BuiltinInterventionProps } from '@lobechat/types';
-import { Avatar, Flexbox, Icon, Tooltip } from '@lobehub/ui';
-import { Collapse, Input, InputNumber } from 'antd';
+import { Accordion, AccordionItem, Avatar, Flexbox, Icon, Tooltip } from '@lobehub/ui';
+import { Input, InputNumber } from 'antd';
 import { createStaticStyles, useTheme } from 'antd-style';
 import isEqual from 'fast-deep-equal';
 import { Clock, Trash2 } from 'lucide-react';
@@ -16,10 +16,14 @@ import { agentGroupSelectors } from '@/store/agentGroup/selectors';
 import type { ExecuteTasksParams, TaskItem } from '../../types';
 
 const styles = createStaticStyles(({ css, cssVar }) => ({
-  agentTitle: css`
-    font-size: 14px;
-    font-weight: 500;
-    color: ${cssVar.colorText};
+  assignee: css`
+    display: flex;
+    flex-shrink: 0;
+    gap: 6px;
+    align-items: center;
+
+    font-size: 12px;
+    color: ${cssVar.colorTextSecondary};
   `,
   container: css`
     padding-block: 12px;
@@ -34,20 +38,18 @@ const styles = createStaticStyles(({ css, cssVar }) => ({
       color: ${cssVar.colorError};
     }
   `,
-  taskCard: css`
-    .ant-collapse-header {
-      padding-block: 8px !important;
-      padding-inline: 12px !important;
-    }
-
-    .ant-collapse-content-box {
-      padding: 12px !important;
-    }
+  index: css`
+    flex-shrink: 0;
+    font-size: 12px;
+    color: ${cssVar.colorTextQuaternary};
   `,
   taskTitle: css`
-    font-size: 13px;
+    overflow: hidden;
+
+    font-size: 14px;
     font-weight: 500;
-    color: ${cssVar.colorText};
+    text-overflow: ellipsis;
+    white-space: nowrap;
   `,
   timeoutInput: css`
     width: 100px;
@@ -102,69 +104,66 @@ const TaskEditor = memo<TaskEditorProps>(({ task, index, onChange, onDelete }) =
     onDelete(index);
   }, [index, onDelete]);
 
-  const header = (
-    <Flexbox align={'center'} gap={8} horizontal justify={'space-between'}>
-      <Flexbox align={'center'} flex={1} gap={8} horizontal style={{ minWidth: 0 }}>
-        <Avatar
-          avatar={agent?.avatar || DEFAULT_AVATAR}
-          background={agent?.backgroundColor || theme.colorBgContainer}
-          shape={'square'}
-          size={24}
-        />
-        <span className={styles.taskTitle}>{task.title || agent?.title || 'Task'}</span>
-      </Flexbox>
-      <Flexbox align={'center'} gap={8} horizontal onClick={(e) => e.stopPropagation()}>
-        <Tooltip title={t('agentGroupManagement.executeTask.intervention.timeout')}>
-          <Clock size={14} />
-        </Tooltip>
-        <InputNumber
-          className={styles.timeoutInput}
-          max={120}
-          min={1}
-          onChange={handleTimeoutChange}
-          size={'small'}
-          suffix={t('agentGroupManagement.executeTask.intervention.timeoutUnit')}
-          value={Math.round((task.timeout || DEFAULT_TIMEOUT) / 60_000)}
+  return (
+    <AccordionItem
+      defaultExpand
+      itemKey={String(index)}
+      paddingBlock={4}
+      paddingInline={2}
+      title={
+        <Flexbox align={'center'} gap={8} horizontal>
+          <div className={styles.assignee}>
+            <Avatar
+              avatar={agent?.avatar || DEFAULT_AVATAR}
+              background={agent?.backgroundColor || theme.colorBgContainer}
+              shape={'circle'}
+              size={20}
+            />
+            <span>{agent?.title}</span>
+          </div>
+        </Flexbox>
+      }
+    >
+      <Flexbox gap={12} style={{ marginTop: 8 }}>
+        <Flexbox gap={12} horizontal>
+          <Input
+            onChange={handleTitleChange}
+            placeholder={t('agentGroupManagement.executeTasks.intervention.titlePlaceholder')}
+            size={'small'}
+            value={task.title}
+            variant={'filled'}
+          />
+          <Flexbox align={'center'} gap={8} horizontal onClick={(e) => e.stopPropagation()}>
+            <Tooltip title={t('agentGroupManagement.executeTask.intervention.timeout')}>
+              <Clock size={14} />
+            </Tooltip>
+            <InputNumber
+              className={styles.timeoutInput}
+              max={120}
+              min={1}
+              onChange={handleTimeoutChange}
+              size={'small'}
+              suffix={t('agentGroupManagement.executeTask.intervention.timeoutUnit')}
+              value={Math.round((task.timeout || DEFAULT_TIMEOUT) / 60_000)}
+              variant={'filled'}
+            />
+            <Icon
+              className={styles.deleteButton}
+              icon={Trash2}
+              onClick={handleDelete}
+              size={{ size: 16 }}
+            />
+          </Flexbox>
+        </Flexbox>
+        <Input.TextArea
+          autoSize={{ maxRows: 20, minRows: 8 }}
+          onChange={handleInstructionChange}
+          placeholder={t('agentGroupManagement.executeTasks.intervention.instructionPlaceholder')}
+          value={task.instruction}
           variant={'filled'}
         />
-        <Icon
-          className={styles.deleteButton}
-          icon={Trash2}
-          onClick={handleDelete}
-          size={{ size: 16 }}
-        />
       </Flexbox>
-    </Flexbox>
-  );
-
-  return (
-    <Collapse
-      className={styles.taskCard}
-      defaultActiveKey={[index]}
-      items={[
-        {
-          children: (
-            <Flexbox gap={12}>
-              <Input
-                onChange={handleTitleChange}
-                placeholder={t('agentGroupManagement.executeTasks.intervention.titlePlaceholder')}
-                value={task.title}
-              />
-              <Input.TextArea
-                autoSize={{ maxRows: 8, minRows: 4 }}
-                onChange={handleInstructionChange}
-                placeholder={t(
-                  'agentGroupManagement.executeTasks.intervention.instructionPlaceholder',
-                )}
-                value={task.instruction}
-              />
-            </Flexbox>
-          ),
-          key: index,
-          label: header,
-        },
-      ]}
-    />
+    </AccordionItem>
   );
 });
 
@@ -216,7 +215,7 @@ const ExecuteTasksIntervention = memo<BuiltinInterventionProps<ExecuteTasksParam
     }, [registerBeforeApprove, hasChanges, tasks, args, onArgsChange]);
 
     return (
-      <Flexbox className={styles.container} gap={12}>
+      <Accordion className={styles.container} gap={0} variant={'borderless'}>
         {tasks.map((task, index) => (
           <TaskEditor
             index={index}
@@ -226,7 +225,7 @@ const ExecuteTasksIntervention = memo<BuiltinInterventionProps<ExecuteTasksParam
             task={task}
           />
         ))}
-      </Flexbox>
+      </Accordion>
     );
   },
   isEqual,

package/packages/builtin-tool-group-management/src/client/Render/ExecuteTask/index.tsx

@@ -54,10 +54,10 @@ const ExecuteTaskRender = memo<BuiltinRenderProps<ExecuteTaskParams, ExecuteTask
           </Flexbox>
         </Flexbox>
 
-        {/* Task content (read-only) */}
-        {args?.task && (
+        {/* Instruction content (read-only) */}
+        {args?.instruction && (
           <Text className={styles.taskContent} style={{ margin: 0 }}>
-            {args.task}
+            {args.instruction}
           </Text>
         )}
       </Flexbox>

package/packages/builtin-tool-group-management/src/client/Render/ExecuteTasks/index.tsx

@@ -2,11 +2,9 @@
 
 import { DEFAULT_AVATAR } from '@lobechat/const';
 import type { AgentGroupMember, BuiltinRenderProps } from '@lobechat/types';
-import { Avatar, Flexbox, Text } from '@lobehub/ui';
+import { Accordion, AccordionItem, Avatar, Block, Flexbox, Text } from '@lobehub/ui';
 import { createStaticStyles, useTheme } from 'antd-style';
-import { Clock } from 'lucide-react';
 import { memo, useMemo } from 'react';
-import { useTranslation } from 'react-i18next';
 
 import { useAgentGroupStore } from '@/store/agentGroup';
 import { agentGroupSelectors } from '@/store/agentGroup/selectors';
@@ -14,40 +12,45 @@ import { agentGroupSelectors } from '@/store/agentGroup/selectors';
 import type { ExecuteTasksParams } from '../../../types';
 
 const styles = createStaticStyles(({ css, cssVar }) => ({
-  container: css`
+  assignee: css`
     display: flex;
-    flex-direction: column;
-    gap: 12px;
-    padding-block: 12px;
+    flex-shrink: 0;
+    gap: 6px;
+    align-items: center;
+
+    font-size: 12px;
+    color: ${cssVar.colorTextSecondary};
   `,
-  taskCard: css`
-    padding: 12px;
-    border-radius: 8px;
-    background: ${cssVar.colorFillQuaternary};
+  container: css`
+    .accordion-action {
+      margin-inline-end: 8px;
+      opacity: 1 !important;
+    }
   `,
-  taskContent: css`
-    padding-block: 8px;
-    padding-inline: 12px;
-    border-radius: ${cssVar.borderRadius};
-    background: ${cssVar.colorFillTertiary};
+  index: css`
+    flex-shrink: 0;
+    font-size: 12px;
+    color: ${cssVar.colorTextQuaternary};
   `,
-  taskHeader: css`
+  instruction: css`
     font-size: 13px;
-    font-weight: 500;
-    color: ${cssVar.colorText};
+    line-height: 1.6;
+    color: ${cssVar.colorTextSecondary};
   `,
-  timeout: css`
-    font-size: 12px;
-    color: ${cssVar.colorTextTertiary};
+
+  taskTitle: css`
+    overflow: hidden;
+    font-size: 14px;
+    text-overflow: ellipsis;
+    white-space: nowrap;
   `,
 }));
 
 /**
  * ExecuteTasks Render component for Group Management tool
- * Read-only display of multiple task execution requests
+ * Accordion-style task list with expandable instruction and assignee on the right
  */
 const ExecuteTasksRender = memo<BuiltinRenderProps<ExecuteTasksParams>>(({ args }) => {
-  const { t } = useTranslation('tool');
   const theme = useTheme();
   const { tasks } = args || {};
 
@@ -69,46 +72,41 @@ const ExecuteTasksRender = memo<BuiltinRenderProps<ExecuteTasksParams>>(({ args
   if (!tasksWithAgents.length) return null;
 
   return (
-    <div className={styles.container}>
-      {tasksWithAgents.map((task, index) => {
-        const timeoutMinutes = task.timeout ? Math.round(task.timeout / 60_000) : 30;
-
-        return (
-          <div className={styles.taskCard} key={task.agentId || index}>
-            <Flexbox gap={12}>
-              {/* Header: Agent info + Timeout */}
-              <Flexbox align={'center'} gap={12} horizontal justify={'space-between'}>
-                <Flexbox align={'center'} flex={1} gap={8} horizontal style={{ minWidth: 0 }}>
-                  <Avatar
-                    avatar={task.agent?.avatar || DEFAULT_AVATAR}
-                    background={task.agent?.backgroundColor || theme.colorBgContainer}
-                    shape={'square'}
-                    size={20}
-                  />
-                  <span className={styles.taskHeader}>
-                    {task.title || task.agent?.title || 'Task'}
-                  </span>
-                </Flexbox>
-                <Flexbox align="center" className={styles.timeout} gap={4} horizontal>
-                  <Clock size={14} />
-                  <span>
-                    {timeoutMinutes}{' '}
-                    {t('agentGroupManagement.executeTask.intervention.timeoutUnit')}
-                  </span>
-                </Flexbox>
-              </Flexbox>
-
-              {/* Task content (read-only) */}
-              {task.instruction && (
-                <Text className={styles.taskContent} style={{ margin: 0 }}>
-                  {task.instruction}
-                </Text>
-              )}
+    <Accordion className={styles.container} defaultExpandedKeys={[]} gap={0} variant={'borderless'}>
+      {tasksWithAgents.map((task, index) => (
+        <AccordionItem
+          action={
+            <div className={styles.assignee}>
+              <Avatar
+                avatar={task.agent?.avatar || DEFAULT_AVATAR}
+                background={task.agent?.backgroundColor || theme.colorBgContainer}
+                shape={'circle'}
+                size={20}
+              />
+              <span>{task.agent?.title}</span>
+            </div>
+          }
+          itemKey={task.agentId || String(index)}
+          key={task.agentId || index}
+          paddingBlock={8}
+          paddingInline={4}
+          title={
+            <Flexbox align={'center'} gap={8} horizontal style={{ minWidth: 0 }}>
+              <span className={styles.index}>{index + 1}.</span>
+              <Text className={styles.taskTitle} weight={500}>
+                {task.title || 'Task'}
+              </Text>
             </Flexbox>
-          </div>
-        );
-      })}
-    </div>
+          }
+        >
+          {task.instruction && (
+            <Block padding={12} style={{ marginTop: 8 }} variant={'filled'}>
+              <Text className={styles.instruction}>{task.instruction}</Text>
+            </Block>
+          )}
+        </AccordionItem>
+      ))}
+    </Accordion>
   );
 });
 

package/packages/builtin-tool-group-management/src/client/Streaming/ExecuteTask/index.tsx

@@ -29,7 +29,7 @@ const styles = createStaticStyles(({ css, cssVar }) => ({
 }));
 
 export const ExecuteTaskStreaming = memo<BuiltinStreamingProps<ExecuteTaskParams>>(({ args }) => {
-  const { agentId, task } = args || {};
+  const { agentId, instruction } = args || {};
   const theme = useTheme();
 
   // Get active group ID and agent from store
@@ -40,7 +40,7 @@ export const ExecuteTaskStreaming = memo<BuiltinStreamingProps<ExecuteTaskParams
       : undefined,
   );
 
-  if (!task) return null;
+  if (!instruction) return null;
 
   return (
     <div className={styles.container}>
@@ -56,7 +56,7 @@ export const ExecuteTaskStreaming = memo<BuiltinStreamingProps<ExecuteTaskParams
         </Flexbox>
         <div className={styles.task}>
           <Markdown animated variant={'chat'}>
-            {task}
+            {instruction}
           </Markdown>
         </div>
       </Flexbox>