@lobehub/lobehub 2.0.0-next.54 → 2.0.0-next.56

package/src/store/file/initialState.ts

@@ -1,11 +1,16 @@
 import { ImageFileState, initialImageFileState } from './slices/chat';
 import { FileChunkState, initialFileChunkState } from './slices/chunk';
+import { DocumentState, initialDocumentState } from './slices/document';
 import { FileManagerState, initialFileManagerState } from './slices/fileManager';
 
-export type FilesStoreState = ImageFileState & FileManagerState & FileChunkState;
+export type FilesStoreState = ImageFileState &
+  DocumentState &
+  FileManagerState &
+  FileChunkState;
 
 export const initialState: FilesStoreState = {
   ...initialImageFileState,
+  ...initialDocumentState,
   ...initialFileManagerState,
   ...initialFileChunkState,
 };

package/src/store/file/slices/chat/action.ts

@@ -23,14 +23,12 @@ const n = setNamespace('chat');
 export interface FileAction {
   clearChatUploadFileList: () => void;
   dispatchChatUploadFileList: (payload: UploadFileListDispatch) => void;
-
   removeChatUploadFile: (id: string) => Promise<void>;
   startAsyncTask: (
     fileId: string,
     runner: (id: string) => Promise<string>,
     onFileItemChange: (fileItem: FileListItem) => void,
   ) => Promise<void>;
-
   uploadChatFiles: (files: File[]) => Promise<void>;
 }
 
@@ -43,12 +41,14 @@ export const createFileSlice: StateCreator<
   clearChatUploadFileList: () => {
     set({ chatUploadFileList: [] }, false, n('clearChatUploadFileList'));
   },
+
   dispatchChatUploadFileList: (payload) => {
     const nextValue = uploadFileListReducer(get().chatUploadFileList, payload);
     if (nextValue === get().chatUploadFileList) return;
 
     set({ chatUploadFileList: nextValue }, false, `dispatchChatFileList/${payload.type}`);
   },
+
   removeChatUploadFile: async (id) => {
     const { dispatchChatUploadFileList } = get();
 
@@ -68,7 +68,7 @@ export const createFileSlice: StateCreator<
       let fileItem: FileListItem | undefined = undefined;
 
       try {
-        fileItem = await fileService.getFileItem(id);
+        fileItem = await fileService.getKnowledgeItem(id);
       } catch (e) {
         console.error('getFileItem Error:', e);
         continue;

package/src/store/file/slices/document/action.ts

@@ -0,0 +1,359 @@
+import { StateCreator } from 'zustand/vanilla';
+
+import { documentService } from '@/services/document';
+import { DocumentSourceType, LobeDocument } from '@/types/document';
+import { setNamespace } from '@/utils/storeDebug';
+
+import { FileStore } from '../../store';
+
+const n = setNamespace('document');
+
+const ALLOWED_DOCUMENT_SOURCE_TYPES = new Set(['editor', 'file', 'api']);
+const ALLOWED_DOCUMENT_FILE_TYPES = new Set(['custom/document', 'application/pdf']);
+const EDITOR_DOCUMENT_FILE_TYPE = 'custom/document';
+
+/**
+ * Check if a document should be displayed in the document list
+ */
+const isAllowedDocument = (document: { fileType: string; sourceType: string }) => {
+  return (
+    ALLOWED_DOCUMENT_SOURCE_TYPES.has(document.sourceType) &&
+    ALLOWED_DOCUMENT_FILE_TYPES.has(document.fileType)
+  );
+};
+
+export interface DocumentAction {
+  /**
+   * Create a new document with markdown content (not optimistic, waits for server response)
+   * Returns the created document
+   */
+  createDocument: (params: {
+    content: string;
+    knowledgeBaseId?: string;
+    title: string;
+  }) => Promise<{ [key: string]: any; id: string }>;
+  /**
+   * Create a new optimistic document immediately in local map
+   * Returns the temporary ID for the new document
+   */
+  createOptimisticDocument: (title?: string) => string;
+  /**
+   * Duplicate an existing document
+   * Returns the created document
+   */
+  duplicateDocument: (documentId: string) => Promise<{ [key: string]: any; id: string }>;
+  /**
+   * Fetch all documents from the server
+   */
+  fetchDocuments: () => Promise<void>;
+  /**
+   * Get documents from local optimistic map merged with server data
+   */
+  getOptimisticDocuments: () => LobeDocument[];
+  /**
+   * Remove a document (deletes from documents table)
+   */
+  removeDocument: (documentId: string) => Promise<void>;
+  /**
+   * Remove a temp document from local map
+   */
+  removeTempDocument: (tempId: string) => void;
+  /**
+   * Replace a temp document with real document data (for smooth UX when creating documents)
+   */
+  replaceTempDocumentWithReal: (tempId: string, realDocument: LobeDocument) => void;
+  /**
+   * Optimistically update document in local map and queue for DB sync
+   */
+  updateDocumentOptimistically: (
+    documentId: string,
+    updates: Partial<LobeDocument>,
+  ) => Promise<void>;
+}
+
+export const createDocumentSlice: StateCreator<
+  FileStore,
+  [['zustand/devtools', never]],
+  [],
+  DocumentAction
+> = (set, get) => ({
+  createDocument: async ({ title, content, knowledgeBaseId }) => {
+    const now = Date.now();
+
+    // Create document with markdown content, leave editorData as empty JSON object
+    const newDoc = await documentService.createDocument({
+      content,
+      editorData: '{}', // Empty JSON object instead of empty string
+      fileType: EDITOR_DOCUMENT_FILE_TYPE,
+      knowledgeBaseId,
+      metadata: {
+        createdAt: now,
+      },
+      title,
+    });
+
+    // Don't refresh documents here - the caller will handle replacing the temp document
+    // with the real one via replaceTempDocumentWithReal, which provides a smooth UX
+    // without triggering the loading skeleton
+
+    return newDoc;
+  },
+
+  createOptimisticDocument: (title = 'Untitled') => {
+    const { localDocumentMap } = get();
+
+    // Generate temporary ID with prefix to identify optimistic documents
+    const tempId = `temp-document-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+    const now = new Date();
+
+    const newDocument: LobeDocument = {
+      content: null,
+      createdAt: now,
+      editorData: null,
+      fileType: EDITOR_DOCUMENT_FILE_TYPE,
+      filename: title,
+      id: tempId,
+      metadata: {},
+      source: 'document',
+      sourceType: DocumentSourceType.EDITOR,
+      title: title,
+      totalCharCount: 0,
+      totalLineCount: 0,
+      updatedAt: now,
+    };
+
+    // Add to local map
+    const newMap = new Map(localDocumentMap);
+    newMap.set(tempId, newDocument);
+    set({ localDocumentMap: newMap }, false, n('createOptimisticDocument'));
+
+    return tempId;
+  },
+
+  duplicateDocument: async (documentId) => {
+    // Fetch the source document
+    const sourceDoc = await documentService.getDocumentById(documentId);
+
+    if (!sourceDoc) {
+      throw new Error(`Document with ID ${documentId} not found`);
+    }
+
+    // Create a new document with copied properties
+    const newDoc = await documentService.createDocument({
+      content: sourceDoc.content || '',
+      editorData: sourceDoc.editorData
+        ? typeof sourceDoc.editorData === 'string'
+          ? sourceDoc.editorData
+          : JSON.stringify(sourceDoc.editorData)
+        : '{}',
+      fileType: sourceDoc.fileType,
+      metadata: {
+        ...sourceDoc.metadata,
+        createdAt: Date.now(),
+        duplicatedFrom: documentId,
+      },
+      title: `${sourceDoc.title} (Copy)`,
+    });
+
+    // Add the new document to local map immediately for instant UI update
+    const { localDocumentMap } = get();
+    const newMap = new Map(localDocumentMap);
+    const editorDoc: LobeDocument = {
+      content: newDoc.content || null,
+      createdAt: newDoc.createdAt ? new Date(newDoc.createdAt) : new Date(),
+      editorData:
+        typeof newDoc.editorData === 'string'
+          ? JSON.parse(newDoc.editorData)
+          : newDoc.editorData || null,
+      fileType: newDoc.fileType,
+      filename: newDoc.title || newDoc.filename || '',
+      id: newDoc.id,
+      metadata: newDoc.metadata || {},
+      source: 'document',
+      sourceType: DocumentSourceType.EDITOR,
+      title: newDoc.title || '',
+      totalCharCount: newDoc.content?.length || 0,
+      totalLineCount: 0,
+      updatedAt: newDoc.updatedAt ? new Date(newDoc.updatedAt) : new Date(),
+    };
+    newMap.set(newDoc.id, editorDoc);
+    set({ localDocumentMap: newMap }, false, n('duplicateDocument'));
+
+    // Don't refresh documents here - we've already added it to the local map
+    // This prevents the loading skeleton from appearing
+
+    return newDoc;
+  },
+
+  fetchDocuments: async () => {
+    set({ isDocumentListLoading: true }, false, n('fetchDocuments/start'));
+
+    try {
+      const documentItems = await documentService.queryDocuments();
+      const documents = documentItems.filter(isAllowedDocument).map((doc) => ({
+        ...doc,
+        filename: doc.filename ?? doc.title ?? 'Untitled',
+      })) as LobeDocument[];
+      set({ documents, isDocumentListLoading: false }, false, n('fetchDocuments/success'));
+
+      // Sync with local map: remove temp documents that now exist on server
+      const { localDocumentMap } = get();
+      const newMap = new Map(localDocumentMap);
+
+      for (const [id] of localDocumentMap.entries()) {
+        if (id.startsWith('temp-document-')) {
+          newMap.delete(id);
+        }
+      }
+
+      set({ localDocumentMap: newMap }, false, n('fetchDocuments/syncLocalMap'));
+    } catch (error) {
+      console.error('Failed to fetch documents:', error);
+      set({ isDocumentListLoading: false }, false, n('fetchDocuments/error'));
+      throw error;
+    }
+  },
+
+  getOptimisticDocuments: () => {
+    const { localDocumentMap, documents } = get();
+
+    // Track which documents we've added
+    const addedIds = new Set<string>();
+
+    // Create result array - start with server documents
+    const result: LobeDocument[] = documents.map((document) => {
+      addedIds.add(document.id);
+      // Check if we have a local optimistic update for this document
+      const localUpdate = localDocumentMap.get(document.id);
+      // If local update exists and is newer, use it; otherwise use server version
+      if (localUpdate && new Date(localUpdate.updatedAt) >= new Date(document.updatedAt)) {
+        return localUpdate;
+      }
+      return document;
+    });
+
+    // Add any optimistic documents that aren't in server list yet (e.g., newly created temp documents)
+    for (const [id, document] of localDocumentMap.entries()) {
+      if (!addedIds.has(id)) {
+        result.unshift(document); // Add new documents to the beginning
+      }
+    }
+
+    return result;
+  },
+
+  removeDocument: async (documentId) => {
+    // Remove from local optimistic map first (optimistic update)
+    const { localDocumentMap, documents } = get();
+    const newMap = new Map(localDocumentMap);
+    newMap.delete(documentId);
+
+    // Also remove from documents array to update the list immediately
+    const newDocuments = documents.filter((doc) => doc.id !== documentId);
+
+    set(
+      { documents: newDocuments, localDocumentMap: newMap },
+      false,
+      n('removeDocument/optimistic'),
+    );
+
+    try {
+      // Delete from documents table
+      await documentService.deleteDocument(documentId);
+      // No need to call fetchDocuments() - optimistic update is enough
+    } catch (error) {
+      console.error('Failed to delete document:', error);
+      // Restore the document in local map and documents array on error
+      const restoredMap = new Map(localDocumentMap);
+      set({ documents, localDocumentMap: restoredMap }, false, n('removeDocument/restore'));
+      throw error;
+    }
+  },
+
+  removeTempDocument: (tempId) => {
+    const { localDocumentMap } = get();
+    const newMap = new Map(localDocumentMap);
+    newMap.delete(tempId);
+    set({ localDocumentMap: newMap }, false, n('removeTempDocument'));
+  },
+
+  replaceTempDocumentWithReal: (tempId, realDocument) => {
+    const { localDocumentMap } = get();
+    const newMap = new Map(localDocumentMap);
+
+    // Remove temp document
+    newMap.delete(tempId);
+
+    // Add real document with same position
+    newMap.set(realDocument.id, realDocument);
+
+    set({ localDocumentMap: newMap }, false, n('replaceTempDocumentWithReal'));
+  },
+
+  updateDocumentOptimistically: async (documentId, updates) => {
+    const { localDocumentMap, documents } = get();
+
+    // Find the document either in local map or documents state
+    let existingDocument = localDocumentMap.get(documentId);
+    if (!existingDocument) {
+      existingDocument = documents.find((doc) => doc.id === documentId);
+    }
+
+    if (!existingDocument) {
+      console.warn('[updateDocumentOptimistically] Document not found:', documentId);
+      return;
+    }
+
+    // Create updated document with new timestamp
+    // Merge metadata if both exist, otherwise use the update's metadata or preserve existing
+    const mergedMetadata =
+      updates.metadata !== undefined
+        ? { ...existingDocument.metadata, ...updates.metadata }
+        : existingDocument.metadata;
+
+    // Clean up undefined values from metadata
+    const cleanedMetadata = mergedMetadata
+      ? Object.fromEntries(Object.entries(mergedMetadata).filter(([, v]) => v !== undefined))
+      : {};
+
+    const updatedDocument: LobeDocument = {
+      ...existingDocument,
+      ...updates,
+      metadata: cleanedMetadata,
+      title: updates.title || existingDocument.title,
+      updatedAt: new Date(),
+    };
+
+    // Update local map immediately for optimistic UI
+    const newMap = new Map(localDocumentMap);
+    newMap.set(documentId, updatedDocument);
+    set({ localDocumentMap: newMap }, false, n('updateDocumentOptimistically'));
+
+    // Queue background sync to DB
+    try {
+      await documentService.updateDocument({
+        content: updatedDocument.content || '',
+        editorData:
+          typeof updatedDocument.editorData === 'string'
+            ? updatedDocument.editorData
+            : JSON.stringify(updatedDocument.editorData || {}),
+        id: documentId,
+        metadata: updatedDocument.metadata || {},
+        title: updatedDocument.title || updatedDocument.filename,
+      });
+
+      // After successful sync, refresh file list to get server state
+      // This will eventually sync back to the map via syncDocumentMapWithServer
+    } catch (error) {
+      console.error('[updateDocumentOptimistically] Failed to sync to DB:', error);
+      // On error, revert the optimistic update
+      const revertMap = new Map(localDocumentMap);
+      if (existingDocument) {
+        revertMap.set(documentId, existingDocument);
+      } else {
+        revertMap.delete(documentId);
+      }
+      set({ localDocumentMap: revertMap }, false, n('revertOptimisticUpdate'));
+    }
+  },
+});

package/src/store/file/slices/document/index.ts

@@ -0,0 +1,3 @@
+export * from './action';
+export * from './initialState';
+export * from './selectors';

package/src/store/file/slices/document/initialState.ts

@@ -0,0 +1,22 @@
+import { LobeDocument } from '@/types/document';
+
+export interface DocumentState {
+  /**
+   * Server documents fetched from document service
+   */
+  documents: LobeDocument[];
+  /**
+   * Loading state for document fetching
+   */
+  isDocumentListLoading: boolean;
+  /**
+   * Local optimistic document map for immediate UI updates
+   */
+  localDocumentMap: Map<string, LobeDocument>;
+}
+
+export const initialDocumentState: DocumentState = {
+  documents: [],
+  isDocumentListLoading: false,
+  localDocumentMap: new Map(),
+};

package/src/store/file/slices/document/selectors.ts

@@ -0,0 +1,25 @@
+import { FilesStoreState } from '../../initialState';
+
+const getDocumentById = (documentId: string | undefined) => (s: FilesStoreState) => {
+  if (!documentId) return undefined;
+
+  // First check local optimistic map
+  const localDocument = s.localDocumentMap.get(documentId);
+
+  // Then check server documents
+  const serverDocument = s.documents.find((doc) => doc.id === documentId);
+
+  // If both exist, prefer the local update if it's newer
+  if (localDocument && serverDocument) {
+    return new Date(localDocument.updatedAt) >= new Date(serverDocument.updatedAt)
+      ? localDocument
+      : serverDocument;
+  }
+
+  // Return whichever exists, or undefined if neither exists
+  return localDocument || serverDocument;
+};
+
+export const documentSelectors = {
+  getDocumentById,
+};

package/src/store/file/slices/fileManager/action.test.ts

@@ -61,6 +61,7 @@ vi.mock('@/libs/trpc/client', () => ({
     file: {
       getFileItemById: { query: vi.fn() },
       getFiles: { query: vi.fn() },
+      getKnowledgeItems: { query: vi.fn() },
       removeFileAsyncTask: { mutate: vi.fn() },
     },
   },
@@ -610,7 +611,7 @@ describe('FileManagerActions', () => {
         await result.current.refreshFileList();
       });
 
-      expect(mutate).toHaveBeenCalledWith(['useFetchFileManage', params]);
+      expect(mutate).toHaveBeenCalledWith(['useFetchKnowledgeItems', params]);
     });
 
     it('should call mutate with undefined params', async () => {
@@ -620,7 +621,7 @@ describe('FileManagerActions', () => {
         await result.current.refreshFileList();
       });
 
-      expect(mutate).toHaveBeenCalledWith(['useFetchFileManage', undefined]);
+      expect(mutate).toHaveBeenCalledWith(['useFetchKnowledgeItems', undefined]);
     });
   });
 
@@ -802,7 +803,7 @@ describe('FileManagerActions', () => {
     it('should not fetch when id is undefined', () => {
       const { result } = renderHook(() => useStore());
 
-      renderHook(() => result.current.useFetchFileItem(undefined));
+      renderHook(() => result.current.useFetchKnowledgeItem(undefined));
 
       expect(lambdaClient.file.getFileItemById.query).not.toHaveBeenCalled();
     });
@@ -820,13 +821,16 @@ describe('FileManagerActions', () => {
         id: 'file-1',
         name: 'test.txt',
         size: 100,
+        sourceType: 'file',
         updatedAt: new Date(),
         url: 'http://example.com/test.txt',
       };
 
       vi.mocked(lambdaClient.file.getFileItemById.query).mockResolvedValue(mockFile);
 
-      const { result: swrResult } = renderHook(() => result.current.useFetchFileItem('file-1'));
+      const { result: swrResult } = renderHook(() =>
+        result.current.useFetchKnowledgeItem('file-1'),
+      );
 
       await waitFor(() => {
         expect(swrResult.current.data).toEqual(mockFile);
@@ -834,7 +838,7 @@ describe('FileManagerActions', () => {
     });
   });
 
-  describe('useFetchFileManage', () => {
+  describe('useFetchKnowledgeItems', () => {
     it('should fetch file list with params', async () => {
       const { result } = renderHook(() => useStore());
 
@@ -849,6 +853,7 @@ describe('FileManagerActions', () => {
           id: 'file-1',
           name: 'test1.txt',
           size: 100,
+          sourceType: 'file',
           updatedAt: new Date(),
           url: 'http://example.com/test1.txt',
         },
@@ -862,15 +867,16 @@ describe('FileManagerActions', () => {
           id: 'file-2',
           name: 'test2.txt',
           size: 200,
+          sourceType: 'file',
           updatedAt: new Date(),
           url: 'http://example.com/test2.txt',
         },
       ];
 
-      vi.mocked(lambdaClient.file.getFiles.query).mockResolvedValue(mockFiles);
+      vi.mocked(lambdaClient.file.getKnowledgeItems.query).mockResolvedValue(mockFiles);
 
       const params = { category: 'all' as any };
-      const { result: swrResult } = renderHook(() => result.current.useFetchFileManage(params));
+      const { result: swrResult } = renderHook(() => result.current.useFetchKnowledgeItems(params));
 
       await waitFor(() => {
         expect(swrResult.current.data).toEqual(mockFiles);
@@ -891,15 +897,16 @@ describe('FileManagerActions', () => {
           id: 'file-1',
           name: 'test.txt',
           size: 100,
+          sourceType: 'file',
           updatedAt: new Date(),
           url: 'http://example.com/test.txt',
         },
       ];
 
-      vi.mocked(lambdaClient.file.getFiles.query).mockResolvedValue(mockFiles);
+      vi.mocked(lambdaClient.file.getKnowledgeItems.query).mockResolvedValue(mockFiles);
 
       const params = { category: 'all' as any };
-      renderHook(() => result.current.useFetchFileManage(params));
+      renderHook(() => result.current.useFetchKnowledgeItems(params));
 
       await waitFor(() => {
         expect(result.current.fileList).toEqual(mockFiles);

package/src/store/file/slices/fileManager/action.ts

@@ -4,7 +4,7 @@ import { StateCreator } from 'zustand/vanilla';
 
 import { FILE_UPLOAD_BLACKLIST, MAX_UPLOAD_FILE_COUNT } from '@/const/file';
 import { useClientDataSWR } from '@/libs/swr';
-import { fileService , FileService } from '@/services/file';
+import { FileService, fileService } from '@/services/file';
 import { ragService } from '@/services/rag';
 import {
   UploadFileListDispatch,
@@ -35,11 +35,11 @@ export interface FileManageAction {
   toggleEmbeddingIds: (ids: string[], loading?: boolean) => void;
   toggleParsingIds: (ids: string[], loading?: boolean) => void;
 
-  useFetchFileItem: (id?: string) => SWRResponse<FileListItem | undefined>;
-  useFetchFileManage: (params: QueryFileListParams) => SWRResponse<FileListItem[]>;
+  useFetchKnowledgeItem: (id?: string) => SWRResponse<FileListItem | undefined>;
+  useFetchKnowledgeItems: (params: QueryFileListParams) => SWRResponse<FileListItem[]>;
 }
 
-const FETCH_FILE_LIST_KEY = 'useFetchFileManage';
+const FETCH_ALL_KNOWLEDGE_KEY = 'useFetchKnowledgeItems';
 
 export const createFileManageSlice: StateCreator<
   FileStore,
@@ -171,7 +171,7 @@ export const createFileManageSlice: StateCreator<
     get().toggleParsingIds([id], false);
   },
   refreshFileList: async () => {
-    await mutate([FETCH_FILE_LIST_KEY, get().queryListParams]);
+    await mutate([FETCH_ALL_KNOWLEDGE_KEY, get().queryListParams]);
   },
   removeAllFiles: async () => {
     await fileService.removeAllFiles();
@@ -220,15 +220,15 @@ export const createFileManageSlice: StateCreator<
     });
   },
 
-  useFetchFileItem: (id) =>
-    useClientDataSWR<FileListItem | undefined>(!id ? null : ['useFetchFileItem', id], () =>
-      serverFileService.getFileItem(id!),
+  useFetchKnowledgeItem: (id) =>
+    useClientDataSWR<FileListItem | undefined>(!id ? null : ['useFetchKnowledgeItem', id], () =>
+      serverFileService.getKnowledgeItem(id!),
     ),
 
-  useFetchFileManage: (params) =>
+  useFetchKnowledgeItems: (params) =>
     useClientDataSWR<FileListItem[]>(
-      [FETCH_FILE_LIST_KEY, params],
-      () => serverFileService.getFiles(params),
+      [FETCH_ALL_KNOWLEDGE_KEY, params],
+      () => serverFileService.getKnowledgeItems(params),
       {
         onSuccess: (data) => {
           set({ fileList: data, queryListParams: params });

package/src/store/file/store.ts

@@ -6,6 +6,7 @@ import { createDevtools } from '../middleware/createDevtools';
 import { FilesStoreState, initialState } from './initialState';
 import { FileAction, createFileSlice } from './slices/chat';
 import { FileChunkAction, createFileChunkSlice } from './slices/chunk';
+import { DocumentAction, createDocumentSlice } from './slices/document';
 import { FileManageAction, createFileManageSlice } from './slices/fileManager';
 import { TTSFileAction, createTTSFileSlice } from './slices/tts';
 import { FileUploadAction, createFileUploadSlice } from './slices/upload/action';
@@ -14,6 +15,7 @@ import { FileUploadAction, createFileUploadSlice } from './slices/upload/action'
 
 export type FileStore = FilesStoreState &
   FileAction &
+  DocumentAction &
   TTSFileAction &
   FileManageAction &
   FileChunkAction &
@@ -22,6 +24,7 @@ export type FileStore = FilesStoreState &
 const createStore: StateCreator<FileStore, [['zustand/devtools', never]]> = (...parameters) => ({
   ...initialState,
   ...createFileSlice(...parameters),
+  ...createDocumentSlice(...parameters),
   ...createFileManageSlice(...parameters),
   ...createTTSFileSlice(...parameters),
   ...createFileChunkSlice(...parameters),

package/src/store/global/initialState.ts

@@ -9,7 +9,7 @@ import { AsyncLocalStorage } from '@/utils/localStorage';
 export enum SidebarTabKey {
   Chat = 'chat',
   Discover = 'discover',
-  Files = 'files',
+  Files = 'knowledge',
   Image = 'image',
   Me = 'me',
   Setting = 'settings',
@@ -72,6 +72,7 @@ export interface SystemStatus {
    */
   isEnablePglite?: boolean;
   isShowCredit?: boolean;
+  knowledgeBaseModalViewMode?: 'list' | 'masonry';
   language?: LocaleMode;
   /**
    * 记住用户最后选择的图像生成模型
@@ -142,6 +143,7 @@ export const INITIAL_STATUS = {
   hideThreadLimitAlert: false,
   imagePanelWidth: 320,
   imageTopicPanelWidth: 80,
+  knowledgeBaseModalViewMode: 'list' as const,
   mobileShowTopic: false,
   noWideScreen: true,
   portalWidth: 400,