@lobehub/lobehub 2.0.0-next.305 → 2.0.0-next.306

package/src/store/agentGroup/slices/lifecycle.test.ts

@@ -10,19 +10,31 @@ vi.mock('@/services/chatGroup', () => ({
   chatGroupService: {
     addAgentsToGroup: vi.fn(),
     createGroup: vi.fn(),
+    getGroupDetail: vi.fn(),
     getGroups: vi.fn(),
   },
 }));
 
-vi.mock('@/store/session', () => ({
-  getSessionStoreState: vi.fn(() => ({
-    activeId: 'some-session-id',
-    refreshSessions: vi.fn().mockResolvedValue(undefined),
-    sessions: [],
-    switchSession: vi.fn(),
+vi.mock('@/store/home', () => ({
+  getHomeStoreState: vi.fn(() => ({
+    refreshAgentList: vi.fn(),
+    switchToGroup: vi.fn(),
   })),
 }));
 
+vi.mock('@/store/agent', () => ({
+  getAgentStoreState: vi.fn(() => ({
+    internal_dispatchAgentMap: vi.fn(),
+    setActiveAgentId: vi.fn(),
+  })),
+}));
+
+vi.mock('@/store/chat', () => ({
+  useChatStore: {
+    setState: vi.fn(),
+  },
+}));
+
 describe('ChatGroupLifecycleSlice', () => {
   beforeEach(() => {
     vi.clearAllMocks();
@@ -47,12 +59,17 @@ describe('ChatGroupLifecycleSlice', () => {
         title: 'Test Group',
         userId: 'user-1',
       };
+      const mockGroupDetail = {
+        ...mockGroup,
+        agents: [],
+        supervisorAgentId: 'supervisor-1',
+      };
 
       vi.mocked(chatGroupService.createGroup).mockResolvedValue({
         group: mockGroup as any,
         supervisorAgentId: 'supervisor-1',
       });
-      vi.mocked(chatGroupService.getGroups).mockResolvedValue([mockGroup as any]);
+      vi.mocked(chatGroupService.getGroupDetail).mockResolvedValue(mockGroupDetail as any);
 
       const { result } = renderHook(() => useAgentGroupStore());
 
@@ -71,13 +88,18 @@ describe('ChatGroupLifecycleSlice', () => {
         title: 'Test Group',
         userId: 'user-1',
       };
+      const mockGroupDetail = {
+        ...mockGroup,
+        agents: [],
+        supervisorAgentId: 'supervisor-1',
+      };
 
       vi.mocked(chatGroupService.createGroup).mockResolvedValue({
         group: mockGroup as any,
         supervisorAgentId: 'supervisor-1',
       });
       vi.mocked(chatGroupService.addAgentsToGroup).mockResolvedValue({ added: [], existing: [] });
-      vi.mocked(chatGroupService.getGroups).mockResolvedValue([mockGroup as any]);
+      vi.mocked(chatGroupService.getGroupDetail).mockResolvedValue(mockGroupDetail as any);
 
       const { result } = renderHook(() => useAgentGroupStore());
 
@@ -91,14 +113,46 @@ describe('ChatGroupLifecycleSlice', () => {
       ]);
     });
 
-    it('should not switch session when silent is true', async () => {
-      const mockSwitchSession = vi.fn();
-      const { getSessionStoreState } = await import('@/store/session');
-      vi.mocked(getSessionStoreState).mockReturnValue({
-        activeId: 'some-session-id',
-        refreshSessions: vi.fn().mockResolvedValue(undefined),
-        sessions: [],
-        switchSession: mockSwitchSession,
+    it('should fetch group detail and store supervisorAgentId for tools injection', async () => {
+      const mockGroup = {
+        id: 'new-group-id',
+        title: 'Test Group',
+        userId: 'user-1',
+      };
+      const mockSupervisorAgentId = 'supervisor-agent-123';
+      const mockGroupDetail = {
+        ...mockGroup,
+        agents: [],
+        supervisorAgentId: mockSupervisorAgentId,
+      };
+
+      vi.mocked(chatGroupService.createGroup).mockResolvedValue({
+        group: mockGroup as any,
+        supervisorAgentId: mockSupervisorAgentId,
+      });
+      vi.mocked(chatGroupService.getGroupDetail).mockResolvedValue(mockGroupDetail as any);
+
+      const { result } = renderHook(() => useAgentGroupStore());
+
+      await act(async () => {
+        await result.current.createGroup({ title: 'Test Group' });
+      });
+
+      // Verify getGroupDetail was called to fetch full group info
+      expect(chatGroupService.getGroupDetail).toHaveBeenCalledWith('new-group-id');
+
+      // Verify supervisorAgentId is stored in groupMap for tools injection
+      const groupDetail = result.current.groupMap['new-group-id'];
+      expect(groupDetail).toBeDefined();
+      expect(groupDetail.supervisorAgentId).toBe(mockSupervisorAgentId);
+    });
+
+    it('should not switch to group when silent is true', async () => {
+      const mockSwitchToGroup = vi.fn();
+      const { getHomeStoreState } = await import('@/store/home');
+      vi.mocked(getHomeStoreState).mockReturnValue({
+        refreshAgentList: vi.fn(),
+        switchToGroup: mockSwitchToGroup,
       } as any);
 
       const mockGroup = {
@@ -106,12 +160,17 @@ describe('ChatGroupLifecycleSlice', () => {
         title: 'Test Group',
         userId: 'user-1',
       };
+      const mockGroupDetail = {
+        ...mockGroup,
+        agents: [],
+        supervisorAgentId: 'supervisor-1',
+      };
 
       vi.mocked(chatGroupService.createGroup).mockResolvedValue({
         group: mockGroup as any,
         supervisorAgentId: 'supervisor-1',
       });
-      vi.mocked(chatGroupService.getGroups).mockResolvedValue([mockGroup as any]);
+      vi.mocked(chatGroupService.getGroupDetail).mockResolvedValue(mockGroupDetail as any);
 
       const { result } = renderHook(() => useAgentGroupStore());
 
@@ -119,7 +178,7 @@ describe('ChatGroupLifecycleSlice', () => {
         await result.current.createGroup({ title: 'Test Group' }, [], true);
       });
 
-      expect(mockSwitchSession).not.toHaveBeenCalled();
+      expect(mockSwitchToGroup).not.toHaveBeenCalled();
     });
   });
 });

package/src/store/agentGroup/slices/lifecycle.ts

@@ -5,7 +5,7 @@ import { type StateCreator } from 'zustand/vanilla';
 import { chatGroupService } from '@/services/chatGroup';
 import { type ChatGroupStore } from '@/store/agentGroup/store';
 import { useChatStore } from '@/store/chat';
-import { getSessionStoreState } from '@/store/session';
+import { getHomeStoreState } from '@/store/home';
 
 export interface ChatGroupLifecycleAction {
   createGroup: (
@@ -14,7 +14,6 @@ export interface ChatGroupLifecycleAction {
     silent?: boolean,
   ) => Promise<string>;
   /**
-   * @deprecated Use switchTopic(undefined) instead
    * Switch to a new topic in the group
    * Clears activeTopicId and navigates to group root
    */
@@ -32,11 +31,8 @@ export const chatGroupLifecycleSlice: StateCreator<
   [],
   ChatGroupLifecycleAction
 > = (_, get) => ({
-  /**
-   * @param silent - if true, do not switch to the new group session
-   */
   createGroup: async (newGroup, agentIds, silent = false) => {
-    const { switchSession } = getSessionStoreState();
+    const { switchToGroup, refreshAgentList } = getHomeStoreState();
 
     const { group } = await chatGroupService.createGroup(newGroup);
 
@@ -52,11 +48,13 @@ export const chatGroupLifecycleSlice: StateCreator<
 
     get().internal_dispatchChatGroup({ payload: group, type: 'addGroup' });
 
-    await get().loadGroups();
-    await getSessionStoreState().refreshSessions();
+    // Fetch full group detail to get supervisorAgentId and agents for tools injection
+    await get().internal_fetchGroupDetail(group.id);
+
+    refreshAgentList();
 
     if (!silent) {
-      switchSession(group.id);
+      switchToGroup(group.id);
     }
 
     return group.id;

package/src/store/chat/slices/operation/__tests__/selectors.test.ts

@@ -509,6 +509,130 @@ describe('Operation Selectors', () => {
     });
   });
 
+  describe('isAgentRunning', () => {
+    it('should return false when no operations exist', () => {
+      const { result } = renderHook(() => useChatStore());
+
+      expect(operationSelectors.isAgentRunning('agent1')(result.current)).toBe(false);
+    });
+
+    it('should return true only for the agent with running operations', () => {
+      const { result } = renderHook(() => useChatStore());
+
+      act(() => {
+        result.current.startOperation({
+          type: 'execAgentRuntime',
+          context: { agentId: 'agent1' },
+        });
+      });
+
+      expect(operationSelectors.isAgentRunning('agent1')(result.current)).toBe(true);
+      expect(operationSelectors.isAgentRunning('agent2')(result.current)).toBe(false);
+    });
+
+    it('should return false when operation completes', () => {
+      const { result } = renderHook(() => useChatStore());
+
+      let opId: string;
+
+      act(() => {
+        opId = result.current.startOperation({
+          type: 'execAgentRuntime',
+          context: { agentId: 'agent1' },
+        }).operationId;
+      });
+
+      expect(operationSelectors.isAgentRunning('agent1')(result.current)).toBe(true);
+
+      act(() => {
+        result.current.completeOperation(opId!);
+      });
+
+      expect(operationSelectors.isAgentRunning('agent1')(result.current)).toBe(false);
+    });
+
+    it('should exclude aborting operations', () => {
+      const { result } = renderHook(() => useChatStore());
+
+      let opId: string;
+
+      act(() => {
+        opId = result.current.startOperation({
+          type: 'execAgentRuntime',
+          context: { agentId: 'agent1' },
+        }).operationId;
+      });
+
+      expect(operationSelectors.isAgentRunning('agent1')(result.current)).toBe(true);
+
+      act(() => {
+        result.current.updateOperationMetadata(opId!, { isAborting: true });
+      });
+
+      expect(operationSelectors.isAgentRunning('agent1')(result.current)).toBe(false);
+    });
+
+    it('should detect any topic with running operations for the agent', () => {
+      const { result } = renderHook(() => useChatStore());
+
+      act(() => {
+        // Agent 1, topic 1
+        result.current.startOperation({
+          type: 'execAgentRuntime',
+          context: { agentId: 'agent1', topicId: 'topic1' },
+        });
+
+        // Agent 1, topic 2
+        result.current.startOperation({
+          type: 'execAgentRuntime',
+          context: { agentId: 'agent1', topicId: 'topic2' },
+        });
+
+        // Agent 2, topic 3
+        result.current.startOperation({
+          type: 'execAgentRuntime',
+          context: { agentId: 'agent2', topicId: 'topic3' },
+        });
+      });
+
+      // Agent 1 should be running (has 2 topics with operations)
+      expect(operationSelectors.isAgentRunning('agent1')(result.current)).toBe(true);
+      // Agent 2 should also be running
+      expect(operationSelectors.isAgentRunning('agent2')(result.current)).toBe(true);
+      // Agent 3 should not be running
+      expect(operationSelectors.isAgentRunning('agent3')(result.current)).toBe(false);
+    });
+
+    it('should detect server agent runtime operations', () => {
+      const { result } = renderHook(() => useChatStore());
+
+      act(() => {
+        result.current.startOperation({
+          type: 'execServerAgentRuntime',
+          context: { agentId: 'agent1', groupId: 'group1' },
+        });
+      });
+
+      expect(operationSelectors.isAgentRunning('agent1')(result.current)).toBe(true);
+      expect(operationSelectors.isAgentRunning('agent2')(result.current)).toBe(false);
+    });
+
+    it('should not detect non-AI-runtime operations', () => {
+      const { result } = renderHook(() => useChatStore());
+
+      act(() => {
+        // sendMessage is not an AI runtime operation type
+        result.current.startOperation({
+          type: 'sendMessage',
+          context: { agentId: 'agent1' },
+        });
+      });
+
+      // sendMessage is not in AI_RUNTIME_OPERATION_TYPES, so should return false
+      expect(operationSelectors.isAgentRunning('agent1')(result.current)).toBe(false);
+    });
+  });
+
   describe('backward compatibility selectors', () => {
     it('isAgentRuntimeRunning should work', () => {
       const { result } = renderHook(() => useChatStore());

package/src/store/chat/slices/operation/selectors.ts

@@ -234,6 +234,27 @@ const isAgentRuntimeRunningByContext =
   };
 
 // === Backward Compatibility ===
+
+/**
+ * Check if a specific agent has running AI runtime operations
+ * Used for agent list item loading states where we need per-agent granularity
+ */
+const isAgentRunning =
+  (agentId: string) =>
+  (s: ChatStoreState): boolean => {
+    for (const type of AI_RUNTIME_OPERATION_TYPES) {
+      const operationIds = s.operationsByType[type] || [];
+      const hasRunning = operationIds.some((id) => {
+        const op = s.operations[id];
+        return (
+          op && op.status === 'running' && !op.metadata.isAborting && op.context.agentId === agentId
+        );
+      });
+      if (hasRunning) return true;
+    }
+    return false;
+  };
+
 /**
  * Check if agent runtime is running (including both main window and thread)
  * Checks both client-side (execAgentRuntime) and server-side (execServerAgentRuntime) operations
@@ -477,6 +498,7 @@ export const operationSelectors = {
 
   isAborting,
 
+  isAgentRunning,
   isAgentRuntimeRunning,
   isAgentRuntimeRunningByContext,
   isAnyMessageLoading,