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

package/packages/database/src/repositories/home/__tests__/index.test.ts

@@ -36,6 +36,86 @@ describe('HomeRepository', () => {
       expect(result.groups).toEqual([]);
     });
 
+    it('should return non-virtual agents without agentsToSessions relationship', async () => {
+      // Create an agent without session relationship (e.g., duplicated agent)
+      const agentId = 'standalone-agent';
+
+      await clientDB.insert(Schema.agents).values({
+        id: agentId,
+        userId,
+        title: 'Standalone Agent',
+        description: 'Agent without session',
+        pinned: false,
+        virtual: false,
+      });
+
+      const result = await homeRepo.getSidebarAgentList();
+
+      // Agent should appear in ungrouped list even without agentsToSessions
+      expect(result.ungrouped).toHaveLength(1);
+      expect(result.ungrouped[0].id).toBe(agentId);
+      expect(result.ungrouped[0].title).toBe('Standalone Agent');
+    });
+
+    it('should return pinned non-virtual agents without agentsToSessions relationship', async () => {
+      // Create a pinned agent without session relationship
+      const agentId = 'pinned-standalone';
+
+      await clientDB.insert(Schema.agents).values({
+        id: agentId,
+        userId,
+        title: 'Pinned Standalone Agent',
+        pinned: true,
+        virtual: false,
+      });
+
+      const result = await homeRepo.getSidebarAgentList();
+
+      // Agent should appear in pinned list
+      expect(result.pinned).toHaveLength(1);
+      expect(result.pinned[0].id).toBe(agentId);
+      expect(result.pinned[0].pinned).toBe(true);
+    });
+
+    it('should return mixed agents with and without session relationships', async () => {
+      // Agent with session
+      await clientDB.transaction(async (tx) => {
+        await tx.insert(Schema.agents).values({
+          id: 'with-session',
+          userId,
+          title: 'Agent With Session',
+          pinned: false,
+          virtual: false,
+        });
+        await tx.insert(Schema.sessions).values({
+          id: 'session-1',
+          slug: 'session-1',
+          userId,
+        });
+        await tx.insert(Schema.agentsToSessions).values({
+          agentId: 'with-session',
+          sessionId: 'session-1',
+          userId,
+        });
+      });
+
+      // Agent without session (e.g., duplicated)
+      await clientDB.insert(Schema.agents).values({
+        id: 'without-session',
+        userId,
+        title: 'Agent Without Session',
+        pinned: false,
+        virtual: false,
+      });
+
+      const result = await homeRepo.getSidebarAgentList();
+
+      // Both agents should appear
+      expect(result.ungrouped).toHaveLength(2);
+      expect(result.ungrouped.map((a) => a.id)).toContain('with-session');
+      expect(result.ungrouped.map((a) => a.id)).toContain('without-session');
+    });
+
     it('should return agents with pinned status from agents table', async () => {
       // Create an agent with pinned=true
       const agentId = 'agent-1';
@@ -380,6 +460,16 @@ describe('HomeRepository', () => {
           sessionId: 'session-search-unpinned',
           userId,
         });
+
+        // Agent without session (e.g., duplicated agent)
+        await tx.insert(Schema.agents).values({
+          id: 'search-standalone',
+          userId,
+          title: 'Standalone Searchable Agent',
+          description: 'A standalone agent without session',
+          pinned: false,
+          virtual: false,
+        });
       });
     });
 
@@ -388,6 +478,24 @@ describe('HomeRepository', () => {
       expect(result).toEqual([]);
     });
 
+    it('should search agents without agentsToSessions relationship', async () => {
+      const result = await homeRepo.searchAgents('Standalone');
+
+      expect(result).toHaveLength(1);
+      expect(result[0].id).toBe('search-standalone');
+      expect(result[0].title).toBe('Standalone Searchable Agent');
+    });
+
+    it('should search and return mixed agents with and without session relationships', async () => {
+      // Search for "Searchable" should return all 3 agents
+      const result = await homeRepo.searchAgents('Searchable');
+
+      expect(result).toHaveLength(3);
+      expect(result.map((a) => a.id)).toContain('search-pinned');
+      expect(result.map((a) => a.id)).toContain('search-unpinned');
+      expect(result.map((a) => a.id)).toContain('search-standalone');
+    });
+
     it('should search agents by title and return correct pinned status', async () => {
       const result = await homeRepo.searchAgents('Searchable Pinned');
 
@@ -407,15 +515,19 @@ describe('HomeRepository', () => {
     it('should return multiple matching agents with correct pinned status', async () => {
       const result = await homeRepo.searchAgents('Searchable');
 
-      expect(result).toHaveLength(2);
+      // 3 agents: search-pinned, search-unpinned, search-standalone
+      expect(result).toHaveLength(3);
 
       const pinnedAgent = result.find((a) => a.id === 'search-pinned');
       const unpinnedAgent = result.find((a) => a.id === 'search-unpinned');
+      const standaloneAgent = result.find((a) => a.id === 'search-standalone');
 
       expect(pinnedAgent).toBeDefined();
       expect(pinnedAgent!.pinned).toBe(true);
       expect(unpinnedAgent).toBeDefined();
       expect(unpinnedAgent!.pinned).toBe(false);
+      expect(standaloneAgent).toBeDefined();
+      expect(standaloneAgent!.pinned).toBe(false);
     });
 
     it('should not return virtual agents in search', async () => {

package/packages/database/src/repositories/home/index.ts

@@ -1,6 +1,6 @@
 import { SidebarAgentItem, SidebarAgentListResponse, SidebarGroup } from '@lobechat/types';
 import { cleanObject } from '@lobechat/utils';
-import { and, desc, eq, ilike, inArray, or } from 'drizzle-orm';
+import { and, desc, eq, ilike, inArray, not, or } from 'drizzle-orm';
 
 import {
   agents,
@@ -36,11 +36,7 @@ export class HomeRepository {
    * Get sidebar agent list with pinned, grouped, and ungrouped items
    */
   async getSidebarAgentList(): Promise<SidebarAgentListResponse> {
-    // 1. Query all agents (non-virtual) with their session info
-    // Note: We query both agents.pinned and sessions.pinned for backward compatibility
-    // agents.pinned takes priority, falling back to sessions.pinned for legacy data
-    // Note: We query both agents.sessionGroupId and sessions.groupId for backward compatibility
-    // agents.sessionGroupId takes priority, falling back to sessions.groupId for legacy data
+    // 1. Query all agents (non-virtual) with their session info (if exists)
     const agentList = await this.db
       .select({
         agentSessionGroupId: agents.sessionGroupId,
@@ -55,9 +51,9 @@ export class HomeRepository {
         updatedAt: agents.updatedAt,
       })
       .from(agents)
-      .innerJoin(agentsToSessions, eq(agents.id, agentsToSessions.agentId))
-      .innerJoin(sessions, eq(agentsToSessions.sessionId, sessions.id))
-      .where(and(eq(agents.userId, this.userId), eq(agents.virtual, false)))
+      .leftJoin(agentsToSessions, eq(agents.id, agentsToSessions.agentId))
+      .leftJoin(sessions, eq(agentsToSessions.sessionId, sessions.id))
+      .where(and(eq(agents.userId, this.userId), not(eq(agents.virtual, true))))
       .orderBy(desc(agents.updatedAt));
 
     // 2. Query all chatGroups (group chats)
@@ -75,32 +71,7 @@ export class HomeRepository {
       .orderBy(desc(chatGroups.updatedAt));
 
     // 2.1 Query member avatars for each chat group
-    const chatGroupIds = chatGroupList.map((g) => g.id);
-    const memberAvatarsMap = new Map<string, Array<{ avatar: string; background?: string }>>();
-
-    if (chatGroupIds.length > 0) {
-      const memberAvatars = await this.db
-        .select({
-          avatar: agents.avatar,
-          backgroundColor: agents.backgroundColor,
-          chatGroupId: chatGroupsAgents.chatGroupId,
-        })
-        .from(chatGroupsAgents)
-        .innerJoin(agents, eq(chatGroupsAgents.agentId, agents.id))
-        .where(inArray(chatGroupsAgents.chatGroupId, chatGroupIds))
-        .orderBy(chatGroupsAgents.order);
-
-      for (const member of memberAvatars) {
-        const existing = memberAvatarsMap.get(member.chatGroupId) || [];
-        if (member.avatar) {
-          existing.push({
-            avatar: member.avatar,
-            background: member.backgroundColor ?? undefined,
-          });
-        }
-        memberAvatarsMap.set(member.chatGroupId, existing);
-      }
-    }
+    const memberAvatarsMap = await this.getChatGroupMemberAvatars(chatGroupList.map((g) => g.id));
 
     // 3. Query all sessionGroups (user-defined folders)
     const groupList = await this.db
@@ -125,7 +96,7 @@ export class HomeRepository {
       id: string;
       pinned: boolean | null;
       sessionGroupId: string | null;
-      sessionId: string;
+      sessionId: string | null;
       sessionPinned: boolean | null;
       title: string | null;
       updatedAt: Date;
@@ -217,7 +188,6 @@ export class HomeRepository {
     const searchPattern = `%${keyword.toLowerCase()}%`;
 
     // 1. Search agents by title or description
-    // Note: We query both agents.pinned and sessions.pinned for backward compatibility
     const agentResults = await this.db
       .select({
         avatar: agents.avatar,
@@ -230,12 +200,12 @@ export class HomeRepository {
         updatedAt: agents.updatedAt,
       })
       .from(agents)
-      .innerJoin(agentsToSessions, eq(agents.id, agentsToSessions.agentId))
-      .innerJoin(sessions, eq(agentsToSessions.sessionId, sessions.id))
+      .leftJoin(agentsToSessions, eq(agents.id, agentsToSessions.agentId))
+      .leftJoin(sessions, eq(agentsToSessions.sessionId, sessions.id))
       .where(
         and(
           eq(agents.userId, this.userId),
-          eq(agents.virtual, false),
+          not(eq(agents.virtual, true)),
           or(ilike(agents.title, searchPattern), ilike(agents.description, searchPattern)),
         ),
       )
@@ -260,35 +230,11 @@ export class HomeRepository {
       .orderBy(desc(chatGroups.updatedAt));
 
     // 2.1 Query member avatars for matching chat groups
-    const chatGroupIds = chatGroupResults.map((g) => g.id);
-    const memberAvatarsMap = new Map<string, Array<{ avatar: string; background?: string }>>();
-
-    if (chatGroupIds.length > 0) {
-      const memberAvatars = await this.db
-        .select({
-          avatar: agents.avatar,
-          backgroundColor: agents.backgroundColor,
-          chatGroupId: chatGroupsAgents.chatGroupId,
-        })
-        .from(chatGroupsAgents)
-        .innerJoin(agents, eq(chatGroupsAgents.agentId, agents.id))
-        .where(inArray(chatGroupsAgents.chatGroupId, chatGroupIds))
-        .orderBy(chatGroupsAgents.order);
-
-      for (const member of memberAvatars) {
-        const existing = memberAvatarsMap.get(member.chatGroupId) || [];
-        if (member.avatar) {
-          existing.push({
-            avatar: member.avatar,
-            background: member.backgroundColor ?? undefined,
-          });
-        }
-        memberAvatarsMap.set(member.chatGroupId, existing);
-      }
-    }
+    const memberAvatarsMap = await this.getChatGroupMemberAvatars(
+      chatGroupResults.map((g) => g.id),
+    );
 
     // 3. Combine and format results
-    // For pinned status: agents.pinned takes priority, fallback to sessions.pinned for backward compatibility
     const results: SidebarAgentItem[] = [
       ...agentResults.map((a) =>
         cleanObject({
@@ -320,4 +266,39 @@ export class HomeRepository {
 
     return results;
   }
+
+  /**
+   * Query member avatars for chat groups
+   */
+  private async getChatGroupMemberAvatars(
+    chatGroupIds: string[],
+  ): Promise<Map<string, Array<{ avatar: string; background?: string }>>> {
+    const memberAvatarsMap = new Map<string, Array<{ avatar: string; background?: string }>>();
+
+    if (chatGroupIds.length === 0) return memberAvatarsMap;
+
+    const memberAvatars = await this.db
+      .select({
+        avatar: agents.avatar,
+        backgroundColor: agents.backgroundColor,
+        chatGroupId: chatGroupsAgents.chatGroupId,
+      })
+      .from(chatGroupsAgents)
+      .innerJoin(agents, eq(chatGroupsAgents.agentId, agents.id))
+      .where(inArray(chatGroupsAgents.chatGroupId, chatGroupIds))
+      .orderBy(chatGroupsAgents.order);
+
+    for (const member of memberAvatars) {
+      const existing = memberAvatarsMap.get(member.chatGroupId) || [];
+      if (member.avatar) {
+        existing.push({
+          avatar: member.avatar,
+          background: member.backgroundColor ?? undefined,
+        });
+      }
+      memberAvatarsMap.set(member.chatGroupId, existing);
+    }
+
+    return memberAvatarsMap;
+  }
 }

package/pnpm-workspace.yaml

@@ -6,6 +6,7 @@ packages:
 
 onlyBuiltDependencies:
   - '@vercel/speed-insights'
+  - '@lobehub/editor'
 
 overrides:
   '@lobehub/chat-plugin-sdk>swagger-client': 3.36.0

package/src/app/[variants]/(main)/agent/features/Conversation/MainChatInput/index.tsx

@@ -11,10 +11,10 @@ import { useSendMenuItems } from './useSendMenuItems';
 const leftActions: ActionKeys[] = [
   'model',
   'search',
-  'typo',
   'fileUpload',
+  'tools',
   '---',
-  ['tools', 'params', 'clear'],
+  ['typo', 'params', 'clear'],
   'mainToken',
 ];
 

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

@@ -13,8 +13,8 @@ import { useGlobalStore } from '@/store/global';
 import { useHomeStore } from '@/store/home';
 
 import Actions from '../Item/Actions';
-import { useDropdownMenu } from '../Item/useDropdownMenu';
 import Editing from './Editing';
+import { useGroupDropdownMenu } from './useDropdownMenu';
 
 interface GroupItemProps {
   className?: string;
@@ -85,13 +85,9 @@ const GroupItem = memo<GroupItemProps>(({ item, style, className }) => {
     return <GroupAvatar avatars={(avatar as any) || []} size={22} />;
   }, [isUpdating, avatar]);
 
-  const dropdownMenu = useDropdownMenu({
-    group: undefined,
+  const dropdownMenu = useGroupDropdownMenu({
     id,
-    openCreateGroupModal: () => {}, // Groups don't need this
-    parentType: 'group',
     pinned: pinned ?? false,
-    sessionType: 'group',
     toggleEditing,
   });
 

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

@@ -0,0 +1,100 @@
+import { Icon, type MenuProps } from '@lobehub/ui';
+import { App } from 'antd';
+import { LucideCopy, Pen, PictureInPicture2Icon, Pin, PinOff, Trash } from 'lucide-react';
+import { useMemo } from 'react';
+import { useTranslation } from 'react-i18next';
+
+import { useGlobalStore } from '@/store/global';
+import { useHomeStore } from '@/store/home';
+
+interface UseGroupDropdownMenuParams {
+  id: string;
+  pinned: boolean;
+  toggleEditing: (visible?: boolean) => void;
+}
+
+export const useGroupDropdownMenu = ({
+  id,
+  pinned,
+  toggleEditing,
+}: UseGroupDropdownMenuParams): (() => MenuProps['items']) => {
+  const { t } = useTranslation('chat');
+  const { modal, message } = App.useApp();
+
+  const openAgentInNewWindow = useGlobalStore((s) => s.openAgentInNewWindow);
+  const [pinAgentGroup, duplicateAgentGroup, removeAgentGroup] = useHomeStore((s) => [
+    s.pinAgentGroup,
+    s.duplicateAgentGroup,
+    s.removeAgentGroup,
+  ]);
+
+  return useMemo(
+    () => () =>
+      [
+        {
+          icon: <Icon icon={pinned ? PinOff : Pin} />,
+          key: 'pin',
+          label: t(pinned ? 'pinOff' : 'pin'),
+          onClick: () => pinAgentGroup(id, !pinned),
+        },
+        {
+          icon: <Icon icon={Pen} />,
+          key: 'rename',
+          label: t('rename', { ns: 'common' }),
+          onClick: (info: any) => {
+            info.domEvent?.stopPropagation();
+            toggleEditing(true);
+          },
+        },
+        {
+          icon: <Icon icon={LucideCopy} />,
+          key: 'duplicate',
+          label: t('duplicate', { ns: 'common' }),
+          onClick: ({ domEvent }: any) => {
+            domEvent.stopPropagation();
+            duplicateAgentGroup(id);
+          },
+        },
+        {
+          icon: <Icon icon={PictureInPicture2Icon} />,
+          key: 'openInNewWindow',
+          label: t('openInNewWindow'),
+          onClick: ({ domEvent }: any) => {
+            domEvent.stopPropagation();
+            openAgentInNewWindow(id);
+          },
+        },
+        { type: 'divider' },
+        {
+          danger: true,
+          icon: <Icon icon={Trash} />,
+          key: 'delete',
+          label: t('delete', { ns: 'common' }),
+          onClick: ({ domEvent }: any) => {
+            domEvent.stopPropagation();
+            modal.confirm({
+              centered: true,
+              okButtonProps: { danger: true },
+              onOk: async () => {
+                await removeAgentGroup(id);
+                message.success(t('confirmRemoveGroupSuccess'));
+              },
+              title: t('confirmRemoveChatGroupItemAlert'),
+            });
+          },
+        },
+      ] as MenuProps['items'],
+    [
+      t,
+      pinned,
+      pinAgentGroup,
+      id,
+      toggleEditing,
+      duplicateAgentGroup,
+      openAgentInNewWindow,
+      modal,
+      removeAgentGroup,
+      message,
+    ],
+  );
+};

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

@@ -15,9 +15,9 @@ import { useHomeStore } from '@/store/home';
 
 import { useAgentModal } from '../../ModalProvider';
 import Actions from '../Item/Actions';
-import { useDropdownMenu } from '../Item/useDropdownMenu';
 import Avatar from './Avatar';
 import Editing from './Editing';
+import { useAgentDropdownMenu } from './useDropdownMenu';
 
 interface AgentItemProps {
   className?: string;
@@ -96,13 +96,11 @@ const AgentItem = memo<AgentItemProps>(({ item, style, className }) => {
     return <Avatar avatar={typeof avatar === 'string' ? avatar : undefined} />;
   }, [isUpdating, avatar]);
 
-  const dropdownMenu = useDropdownMenu({
+  const dropdownMenu = useAgentDropdownMenu({
     group: undefined, // TODO: pass group from parent if needed
     id,
     openCreateGroupModal: handleOpenCreateGroupModal,
-    parentType: 'agent',
     pinned: pinned ?? false,
-    sessionType: 'agent',
     toggleEditing,
   });
 

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

@@ -0,0 +1,149 @@
+import { SessionDefaultGroup } from '@lobechat/types';
+import { Icon, type MenuProps } from '@lobehub/ui';
+import { App } from 'antd';
+import isEqual from 'fast-deep-equal';
+import {
+  Check,
+  FolderInputIcon,
+  LucideCopy,
+  LucidePlus,
+  Pen,
+  PictureInPicture2Icon,
+  Pin,
+  PinOff,
+  Trash,
+} from 'lucide-react';
+import { useMemo } from 'react';
+import { useTranslation } from 'react-i18next';
+
+import { useGlobalStore } from '@/store/global';
+import { useHomeStore } from '@/store/home';
+import { homeAgentListSelectors } from '@/store/home/selectors';
+
+interface UseAgentDropdownMenuParams {
+  group: string | undefined;
+  id: string;
+  openCreateGroupModal: () => void;
+  pinned: boolean;
+  toggleEditing: (visible?: boolean) => void;
+}
+
+export const useAgentDropdownMenu = ({
+  group,
+  id,
+  openCreateGroupModal,
+  pinned,
+  toggleEditing,
+}: UseAgentDropdownMenuParams): (() => MenuProps['items']) => {
+  const { t } = useTranslation('chat');
+  const { modal, message } = App.useApp();
+
+  const openAgentInNewWindow = useGlobalStore((s) => s.openAgentInNewWindow);
+  const sessionCustomGroups = useHomeStore(homeAgentListSelectors.agentGroups, isEqual);
+  const [pinAgent, duplicateAgent, updateAgentGroup, removeAgent] = useHomeStore((s) => [
+    s.pinAgent,
+    s.duplicateAgent,
+    s.updateAgentGroup,
+    s.removeAgent,
+  ]);
+
+  const isDefault = group === SessionDefaultGroup.Default;
+
+  return useMemo(
+    () => () =>
+      [
+        {
+          icon: <Icon icon={pinned ? PinOff : Pin} />,
+          key: 'pin',
+          label: t(pinned ? 'pinOff' : 'pin'),
+          onClick: () => pinAgent(id, !pinned),
+        },
+        {
+          icon: <Icon icon={Pen} />,
+          key: 'rename',
+          label: t('rename', { ns: 'common' }),
+          onClick: (info: any) => {
+            info.domEvent?.stopPropagation();
+            toggleEditing(true);
+          },
+        },
+        {
+          icon: <Icon icon={LucideCopy} />,
+          key: 'duplicate',
+          label: t('duplicate', { ns: 'common' }),
+          onClick: ({ domEvent }: any) => {
+            domEvent.stopPropagation();
+            duplicateAgent(id);
+          },
+        },
+        {
+          icon: <Icon icon={PictureInPicture2Icon} />,
+          key: 'openInNewWindow',
+          label: t('openInNewWindow'),
+          onClick: ({ domEvent }: any) => {
+            domEvent.stopPropagation();
+            openAgentInNewWindow(id);
+          },
+        },
+        { type: 'divider' },
+        {
+          children: [
+            ...sessionCustomGroups.map(({ id: groupId, name }) => ({
+              icon: group === groupId ? <Icon icon={Check} /> : <div />,
+              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();
+                openCreateGroupModal();
+              },
+            },
+          ],
+          icon: <Icon icon={FolderInputIcon} />,
+          key: 'moveGroup',
+          label: t('sessionGroup.moveGroup'),
+        },
+        { type: 'divider' },
+        {
+          danger: true,
+          icon: <Icon icon={Trash} />,
+          key: 'delete',
+          label: t('delete', { ns: 'common' }),
+          onClick: ({ domEvent }: any) => {
+            domEvent.stopPropagation();
+            modal.confirm({
+              centered: true,
+              okButtonProps: { danger: true },
+              onOk: async () => {
+                await removeAgent(id);
+                message.success(t('confirmRemoveSessionSuccess'));
+              },
+              title: t('confirmRemoveSessionItemAlert'),
+            });
+          },
+        },
+      ] as MenuProps['items'],
+    [
+      pinned,
+      id,
+      toggleEditing,
+      sessionCustomGroups,
+      group,
+      isDefault,
+      openCreateGroupModal,
+      message,
+    ],
+  );
+};

package/src/app/[variants]/(main)/home/_layout/hooks/index.ts

@@ -1,4 +1,3 @@
 export { useCreateMenuItems } from './useCreateMenuItems';
 export { useProjectMenuItems } from './useProjectMenuItems';
 export { useSessionGroupMenuItems } from './useSessionGroupMenuItems';
-export { useSessionItemMenuItems } from './useSessionItemMenuItems';

package/src/app/[variants]/(main)/home/features/InputArea/index.tsx

@@ -12,7 +12,7 @@ import ModeHeader from './ModeHeader';
 import StarterList from './StarterList';
 import { useSend } from './useSend';
 
-const leftActions: ActionKeys[] = ['model', 'search', 'fileUpload'];
+const leftActions: ActionKeys[] = ['model', 'search', 'fileUpload', 'tools'];
 
 const InputArea = () => {
   const { loading, send, inboxAgentId } = useSend();

package/src/features/ChatInput/InputEditor/index.tsx

@@ -120,6 +120,7 @@ const InputEditor = memo<{ defaultRows?: number }>(({ defaultRows = 2 }) => {
       className={className}
       content={''}
       editor={editor}
+      pasteAsPlainText
       {...richRenderProps}
       mentionOption={
         enableMention

package/src/features/EditorCanvas/DiffAllToolbar.tsx

@@ -36,7 +36,7 @@ const styles = createStaticStyles(({ css }) => ({
 }));
 
 const useIsEditorInit = (editor: IEditor) => {
-  const [isEditInit, setEditInit] = useState<boolean>(!!editor.getLexicalEditor());
+  const [isEditInit, setEditInit] = useState<boolean>(!!editor?.getLexicalEditor());
 
   useEffect(() => {
     if (!editor) return;