@lobehub/lobehub 2.0.0-next.264 → 2.0.0-next.265

package/src/server/routers/lambda/agent.ts

@@ -130,6 +130,21 @@ export const agentRouter = router({
       return ctx.agentModel.deleteAgentKnowledgeBase(input.agentId, input.knowledgeBaseId);
     }),
 
+  /**
+   * Duplicate an agent and its associated session.
+   * Returns the new agent ID and session ID.
+   */
+  duplicateAgent: agentProcedure
+    .input(
+      z.object({
+        agentId: z.string(),
+        newTitle: z.string().optional(),
+      }),
+    )
+    .mutation(async ({ input, ctx }) => {
+      return ctx.agentModel.duplicate(input.agentId, input.newTitle);
+    }),
+
   /**
    * Get an agent by marketIdentifier
    * @returns agent id if exists, null otherwise

package/src/server/routers/lambda/agentGroup.ts

@@ -126,6 +126,22 @@ export const agentGroupRouter = router({
       return ctx.agentGroupService.deleteGroup(input.id);
     }),
 
+  /**
+   * Duplicate a chat group with all its members.
+   * Creates a new group with the same config, a new supervisor, and copies of virtual members.
+   * Non-virtual members are referenced (not copied).
+   */
+  duplicateGroup: agentGroupProcedure
+    .input(
+      z.object({
+        groupId: z.string(),
+        newTitle: z.string().optional(),
+      }),
+    )
+    .mutation(async ({ input, ctx }) => {
+      return ctx.agentGroupRepo.duplicate(input.groupId, input.newTitle);
+    }),
+
   getGroup: agentGroupProcedure
     .input(z.object({ id: z.string() }))
     .query(async ({ input, ctx }) => {

package/src/services/agent.ts

@@ -185,6 +185,17 @@ class AgentService {
   updateAgentPinned = async (agentId: string, pinned: boolean) => {
     return lambdaClient.agent.updateAgentPinned.mutate({ id: agentId, pinned });
   };
+
+  /**
+   * Duplicate an agent.
+   * Returns the new agent ID.
+   */
+  duplicateAgent = async (
+    agentId: string,
+    newTitle?: string,
+  ): Promise<{ agentId: string } | null> => {
+    return lambdaClient.agent.duplicateAgent.mutate({ agentId, newTitle });
+  };
 }
 
 export const agentService = new AgentService();

package/src/services/chatGroup/index.ts

@@ -107,6 +107,17 @@ class ChatGroupService {
   getGroupAgents = (groupId: string): Promise<ChatGroupAgentItem[]> => {
     return lambdaClient.group.getGroupAgents.query({ groupId });
   };
+
+  /**
+   * Duplicate a chat group with all its members.
+   * Returns the new group ID and supervisor agent ID.
+   */
+  duplicateGroup = (
+    groupId: string,
+    newTitle?: string,
+  ): Promise<{ groupId: string; supervisorAgentId: string } | null> => {
+    return lambdaClient.group.duplicateGroup.mutate({ groupId, newTitle });
+  };
 }
 
 export const chatGroupService = new ChatGroupService();

package/src/store/home/slices/sidebarUI/action.test.ts

@@ -6,6 +6,7 @@ import { agentService } from '@/services/agent';
 import { chatGroupService } from '@/services/chatGroup';
 import { homeService } from '@/services/home';
 import { sessionService } from '@/services/session';
+import { getAgentStoreState } from '@/store/agent';
 import { useHomeStore } from '@/store/home';
 import { getSessionStoreState } from '@/store/session';
 
@@ -26,6 +27,12 @@ vi.mock('@/store/session', () => ({
   })),
 }));
 
+vi.mock('@/store/agent', () => ({
+  getAgentStoreState: vi.fn(() => ({
+    setActiveAgentId: vi.fn(),
+  })),
+}));
+
 afterEach(() => {
   vi.restoreAllMocks();
 });
@@ -136,17 +143,16 @@ describe('createSidebarUISlice', () => {
   });
 
   describe('duplicateAgent', () => {
-    it('should duplicate an agent and switch to the new session', async () => {
+    it('should duplicate an agent and switch to the new agent', async () => {
       const mockAgentId = 'agent-123';
-      const mockNewId = 'new-agent-456';
-      const mockSwitchSession = vi.fn();
+      const mockNewAgentId = 'new-agent-456';
+      const mockSetActiveAgentId = vi.fn();
 
-      vi.mocked(getSessionStoreState).mockReturnValue({
-        activeId: 'other-agent',
-        switchSession: mockSwitchSession,
+      vi.mocked(getAgentStoreState).mockReturnValue({
+        setActiveAgentId: mockSetActiveAgentId,
       } as any);
 
-      vi.spyOn(sessionService, 'cloneSession').mockResolvedValueOnce(mockNewId);
+      vi.spyOn(agentService, 'duplicateAgent').mockResolvedValueOnce({ agentId: mockNewAgentId });
       const spyOnRefresh = vi.spyOn(useHomeStore.getState(), 'refreshAgentList');
 
       const { result } = renderHook(() => useHomeStore());
@@ -155,16 +161,16 @@ describe('createSidebarUISlice', () => {
         await result.current.duplicateAgent(mockAgentId, 'Copied Agent');
       });
 
-      expect(sessionService.cloneSession).toHaveBeenCalledWith(mockAgentId, 'Copied Agent');
+      expect(agentService.duplicateAgent).toHaveBeenCalledWith(mockAgentId, 'Copied Agent');
       expect(spyOnRefresh).toHaveBeenCalled();
-      expect(mockSwitchSession).toHaveBeenCalledWith(mockNewId);
+      expect(mockSetActiveAgentId).toHaveBeenCalledWith(mockNewAgentId);
     });
 
     it('should show error message when duplication fails', async () => {
       const mockAgentId = 'agent-123';
       const { message } = await import('@/components/AntdStaticMethods');
 
-      vi.spyOn(sessionService, 'cloneSession').mockResolvedValueOnce(undefined);
+      vi.spyOn(agentService, 'duplicateAgent').mockResolvedValueOnce(null);
       vi.spyOn(useHomeStore.getState(), 'refreshAgentList');
 
       const { result } = renderHook(() => useHomeStore());
@@ -176,29 +182,24 @@ describe('createSidebarUISlice', () => {
       expect(message.error).toHaveBeenCalled();
     });
 
-    it('should use default title when not provided', async () => {
+    it('should use provided title when duplicating', async () => {
       const mockAgentId = 'agent-123';
-      const mockNewId = 'new-agent-456';
+      const mockNewAgentId = 'new-agent-456';
 
-      vi.mocked(getSessionStoreState).mockReturnValue({
-        activeId: 'other-agent',
-        switchSession: vi.fn(),
+      vi.mocked(getAgentStoreState).mockReturnValue({
+        setActiveAgentId: vi.fn(),
       } as any);
 
-      vi.spyOn(sessionService, 'cloneSession').mockResolvedValueOnce(mockNewId);
+      vi.spyOn(agentService, 'duplicateAgent').mockResolvedValueOnce({ agentId: mockNewAgentId });
       vi.spyOn(useHomeStore.getState(), 'refreshAgentList');
 
       const { result } = renderHook(() => useHomeStore());
 
       await act(async () => {
-        await result.current.duplicateAgent(mockAgentId);
+        await result.current.duplicateAgent(mockAgentId, 'Custom Title');
       });
 
-      // default title is i18n based
-      expect(sessionService.cloneSession).toHaveBeenCalledWith(
-        mockAgentId,
-        expect.stringContaining('Copy'),
-      );
+      expect(agentService.duplicateAgent).toHaveBeenCalledWith(mockAgentId, 'Custom Title');
     });
   });
 

package/src/store/home/slices/sidebarUI/action.ts

@@ -7,8 +7,8 @@ import { agentService } from '@/services/agent';
 import { chatGroupService } from '@/services/chatGroup';
 import { homeService } from '@/services/home';
 import { sessionService } from '@/services/session';
+import { getAgentStoreState } from '@/store/agent';
 import type { HomeStore } from '@/store/home/store';
-import { getSessionStoreState } from '@/store/session';
 import { type SessionGroupItem } from '@/types/session';
 import { setNamespace } from '@/utils/storeDebug';
 
@@ -17,9 +17,13 @@ const n = setNamespace('sidebarUI');
 export interface SidebarUIAction {
   // ========== Agent Operations ==========
   /**
-   * Duplicate an agent
+   * Duplicate an agent using agentService
    */
   duplicateAgent: (agentId: string, newTitle?: string) => Promise<void>;
+  /**
+   * Duplicate a chat group (multi-agent group)
+   */
+  duplicateAgentGroup: (groupId: string, newTitle?: string) => Promise<void>;
   /**
    * Pin or unpin an agent
    */
@@ -94,11 +98,35 @@ export const createSidebarUISlice: StateCreator<
       key: messageLoadingKey,
     });
 
-    // Use provided title or generate default
-    const title = newTitle ?? t('duplicateSession.title', { ns: 'chat', title: 'Agent' }) ?? 'Copy';
-    const newId = await sessionService.cloneSession(agentId, title);
+    const result = await agentService.duplicateAgent(agentId, newTitle);
+
+    if (!result) {
+      message.destroy(messageLoadingKey);
+      message.error(t('copyFail', { ns: 'common' }));
+      return;
+    }
+
+    await get().refreshAgentList();
+    message.destroy(messageLoadingKey);
+    message.success(t('duplicateSession.success', { ns: 'chat' }));
+
+    // Switch to the new agent
+    const agentStore = getAgentStoreState();
+    agentStore.setActiveAgentId(result.agentId);
+  },
+
+  duplicateAgentGroup: async (groupId, newTitle?: string) => {
+    const messageLoadingKey = 'duplicateAgentGroup.loading';
+
+    message.loading({
+      content: t('duplicateSession.loading', { ns: 'chat' }),
+      duration: 0,
+      key: messageLoadingKey,
+    });
+
+    const result = await chatGroupService.duplicateGroup(groupId, newTitle);
 
-    if (!newId) {
+    if (!result) {
       message.destroy(messageLoadingKey);
       message.error(t('copyFail', { ns: 'common' }));
       return;
@@ -108,9 +136,9 @@ export const createSidebarUISlice: StateCreator<
     message.destroy(messageLoadingKey);
     message.success(t('duplicateSession.success', { ns: 'chat' }));
 
-    // Switch to new session
-    const sessionStore = getSessionStoreState();
-    sessionStore.switchSession(newId);
+    // Switch to the new group (using supervisor agent id)
+    const agentStore = getAgentStoreState();
+    agentStore.setActiveAgentId(result.supervisorAgentId);
   },
 
   pinAgent: async (agentId, pinned) => {

package/src/app/[variants]/(main)/home/_layout/Body/Agent/List/Item/useDropdownMenu.tsx

@@ -1,62 +0,0 @@
-import { type MenuProps } from '@lobehub/ui';
-import { useCallback } from 'react';
-
-import { useSessionItemMenuItems } from '../../../../hooks';
-
-interface ActionProps {
-  group: string | undefined;
-  id: string;
-  openCreateGroupModal: () => void;
-  parentType: 'agent' | 'group';
-  pinned: boolean;
-  sessionType?: string;
-  toggleEditing: (visible?: boolean) => void;
-}
-
-export const useDropdownMenu = ({
-  group,
-  id,
-  openCreateGroupModal,
-  parentType,
-  pinned,
-  sessionType,
-  toggleEditing,
-}: ActionProps): (() => MenuProps['items']) => {
-  const {
-    pinMenuItem,
-    renameMenuItem,
-    duplicateMenuItem,
-    openInNewWindowMenuItem,
-    moveToGroupMenuItem,
-    deleteMenuItem,
-  } = useSessionItemMenuItems();
-
-  return useCallback(
-    () =>
-      [
-        pinMenuItem(id, pinned, parentType),
-        renameMenuItem(toggleEditing),
-        duplicateMenuItem(id),
-        openInNewWindowMenuItem(id),
-        { type: 'divider' },
-        moveToGroupMenuItem(id, group, openCreateGroupModal),
-        { type: 'divider' },
-        deleteMenuItem(id, parentType, sessionType),
-      ].filter(Boolean) as MenuProps['items'],
-    [
-      id,
-      pinned,
-      parentType,
-      group,
-      sessionType,
-      pinMenuItem,
-      renameMenuItem,
-      duplicateMenuItem,
-      openInNewWindowMenuItem,
-      moveToGroupMenuItem,
-      deleteMenuItem,
-      openCreateGroupModal,
-      toggleEditing,
-    ],
-  );
-};

package/src/app/[variants]/(main)/home/_layout/hooks/useSessionItemMenuItems.tsx

@@ -1,238 +0,0 @@
-import { SessionDefaultGroup } from '@lobechat/types';
-import { Icon } from '@lobehub/ui';
-import { App } from 'antd';
-import { createStaticStyles } from 'antd-style';
-import { type ItemType } from 'antd/es/menu/interface';
-import isEqual from 'fast-deep-equal';
-import {
-  Check,
-  FolderInputIcon,
-  LucideCopy,
-  LucidePlus,
-  Pen,
-  PictureInPicture2Icon,
-  Pin,
-  PinOff,
-  Trash,
-} from 'lucide-react';
-import { useCallback } from 'react';
-import { useTranslation } from 'react-i18next';
-
-import { useGlobalStore } from '@/store/global';
-import { useHomeStore } from '@/store/home';
-import { homeAgentListSelectors } from '@/store/home/selectors';
-
-const styles = createStaticStyles(({ css }) => ({
-  modalRoot: css`
-    z-index: 2000;
-  `,
-}));
-
-/**
- * Hook for generating menu items for individual session/agent items
- * Used in List/Item/Actions.tsx
- */
-export const useSessionItemMenuItems = () => {
-  const { t } = useTranslation('chat');
-  const { modal, message } = App.useApp();
-
-  const openAgentInNewWindow = useGlobalStore((s) => s.openAgentInNewWindow);
-  const sessionCustomGroups = useHomeStore(homeAgentListSelectors.agentGroups, isEqual);
-
-  const [pinAgent, pinAgentGroup, duplicateAgent, updateAgentGroup, removeAgent, removeAgentGroup] =
-    useHomeStore((s) => [
-      s.pinAgent,
-      s.pinAgentGroup,
-      s.duplicateAgent,
-      s.updateAgentGroup,
-      s.removeAgent,
-      s.removeAgentGroup,
-    ]);
-
-  /**
-   * Pin/Unpin menu item
-   */
-  const pinMenuItem = useCallback(
-    (id: string, isPinned: boolean, parentType: 'agent' | 'group'): ItemType => {
-      const iconElement = <Icon icon={isPinned ? PinOff : Pin} />;
-      return {
-        icon: iconElement,
-        key: 'pin',
-        label: t(isPinned ? 'pinOff' : 'pin'),
-        onClick: () => {
-          if (parentType === 'group') {
-            pinAgentGroup(id, !isPinned);
-          } else {
-            pinAgent(id, !isPinned);
-          }
-        },
-      };
-    },
-    [t, pinAgentGroup, pinAgent],
-  );
-
-  /**
-   * Rename session menu item
-   */
-  const renameMenuItem = useCallback(
-    (onToggleEdit: (visible?: boolean) => void): ItemType => {
-      const iconElement = <Icon icon={Pen} />;
-      return {
-        icon: iconElement,
-        key: 'rename',
-        label: t('rename', { ns: 'common' }),
-        onClick: (info: any) => {
-          info.domEvent?.stopPropagation();
-          onToggleEdit(true);
-        },
-      };
-    },
-    [t],
-  );
-
-  /**
-   * Duplicate session menu item
-   */
-  const duplicateMenuItem = useCallback(
-    (id: string): ItemType => {
-      const iconElement = <Icon icon={LucideCopy} />;
-      return {
-        icon: iconElement,
-        key: 'duplicate',
-        label: t('duplicate', { ns: 'common' }),
-        onClick: ({ domEvent }: any) => {
-          domEvent.stopPropagation();
-          duplicateAgent(id);
-        },
-      };
-    },
-    [t, duplicateAgent],
-  );
-
-  /**
-   * Open in new window menu item
-   * Desktop: Opens in a new electron window
-   * Browser: Opens in a popup window
-   */
-  const openInNewWindowMenuItem = useCallback(
-    (id: string): ItemType => {
-      const iconElement = <Icon icon={PictureInPicture2Icon} />;
-      return {
-        icon: iconElement,
-        key: 'openInNewWindow',
-        label: t('openInNewWindow'),
-        onClick: ({ domEvent }: any) => {
-          domEvent.stopPropagation();
-          openAgentInNewWindow(id);
-        },
-      };
-    },
-    [t, openAgentInNewWindow],
-  );
-
-  /**
-   * Move to group submenu item
-   * Contains all custom groups, default list, and create new group option
-   */
-  const moveToGroupMenuItem = useCallback(
-    (
-      id: string,
-      currentGroup: string | undefined,
-      onOpenCreateGroupModal: () => void,
-    ): ItemType => {
-      const isDefault = currentGroup === SessionDefaultGroup.Default;
-
-      const children = [
-        ...sessionCustomGroups.map(({ id: groupId, name }) => {
-          const checkIcon = currentGroup === groupId ? <Icon icon={Check} /> : <div />;
-          return {
-            icon: checkIcon,
-            key: groupId,
-            label: name,
-            onClick: () => {
-              updateAgentGroup(id, groupId);
-            },
-          };
-        }),
-        {
-          icon: isDefault ? <Icon icon={Check} /> : <div />,
-          key: 'defaultList',
-          label: t('defaultList'),
-          onClick: () => {
-            updateAgentGroup(id, SessionDefaultGroup.Default);
-          },
-        },
-        {
-          type: 'divider' as const,
-        },
-        {
-          icon: <Icon icon={LucidePlus} />,
-          key: 'createGroup',
-          label: <div>{t('sessionGroup.createGroup')}</div>,
-          onClick: ({ domEvent }: any) => {
-            domEvent.stopPropagation();
-            onOpenCreateGroupModal();
-          },
-        },
-      ];
-
-      const folderIcon = <Icon icon={FolderInputIcon} />;
-      return {
-        children,
-        icon: folderIcon,
-        key: 'moveGroup',
-        label: t('sessionGroup.moveGroup'),
-      };
-    },
-    [t, sessionCustomGroups, updateAgentGroup],
-  );
-
-  /**
-   * Delete menu item with confirmation modal
-   * Handles both session and group types
-   */
-  const deleteMenuItem = useCallback(
-    (id: string, parentType: 'agent' | 'group', sessionType?: string): ItemType => {
-      const trashIcon = <Icon icon={Trash} />;
-      return {
-        danger: true,
-        icon: trashIcon,
-        key: 'delete',
-        label: t('delete', { ns: 'common' }),
-        onClick: ({ domEvent }: any) => {
-          domEvent.stopPropagation();
-          modal.confirm({
-            centered: true,
-            classNames: {
-              root: styles.modalRoot,
-            },
-            okButtonProps: { danger: true },
-            onOk: async () => {
-              if (parentType === 'group') {
-                await removeAgentGroup(id);
-                message.success(t('confirmRemoveGroupSuccess'));
-              } else {
-                await removeAgent(id);
-                message.success(t('confirmRemoveSessionSuccess'));
-              }
-            },
-            title:
-              sessionType === 'group'
-                ? t('confirmRemoveChatGroupItemAlert')
-                : t('confirmRemoveSessionItemAlert'),
-          });
-        },
-      };
-    },
-    [t, modal, styles.modalRoot, removeAgentGroup, message, removeAgent],
-  );
-
-  return {
-    deleteMenuItem,
-    duplicateMenuItem,
-    moveToGroupMenuItem,
-    openInNewWindowMenuItem,
-    pinMenuItem,
-    renameMenuItem,
-  };
-};