@lobehub/chat 1.11.9 → 1.12.0

package/src/store/chat/slices/message/action.test.ts

@@ -14,6 +14,7 @@ import { agentSelectors } from '@/store/agent/selectors';
 import { chatSelectors } from '@/store/chat/selectors';
 import { messageMapKey } from '@/store/chat/slices/message/utils';
 import { sessionMetaSelectors } from '@/store/session/selectors';
+import { UploadFileItem } from '@/types/files/upload';
 import { ChatMessage } from '@/types/message';
 
 import { useChatStore } from '../../store';
@@ -426,7 +427,7 @@ describe('chatMessage actions', () => {
     it('should create message and call internal_coreProcessMessage if message or files are provided', async () => {
       const { result } = renderHook(() => useChatStore());
       const message = 'Test message';
-      const files = [{ id: 'file-id', url: 'file-url' }];
+      const files = [{ id: 'file-id' } as UploadFileItem];
 
       // Mock messageService.create to resolve with a message id
       (messageService.createMessage as Mock).mockResolvedValue('new-message-id');

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

@@ -7,11 +7,13 @@ import { template } from 'lodash-es';
 import { SWRResponse, mutate } from 'swr';
 import { StateCreator } from 'zustand/vanilla';
 
+import { chainAnswerWithContext } from '@/chains/answerWithContext';
 import { LOADING_FLAT, MESSAGE_CANCEL_FLAT } from '@/const/message';
 import { TraceEventType, TraceNameMap } from '@/const/trace';
+import { isServerMode } from '@/const/version';
 import { useClientDataSWR } from '@/libs/swr';
 import { chatService } from '@/services/chat';
-import { CreateMessageParams, messageService } from '@/services/message';
+import { messageService } from '@/services/message';
 import { topicService } from '@/services/topic';
 import { traceService } from '@/services/trace';
 import { useAgentStore } from '@/store/agent';
@@ -20,7 +22,14 @@ import { chatHelpers } from '@/store/chat/helpers';
 import { messageMapKey } from '@/store/chat/slices/message/utils';
 import { ChatStore } from '@/store/chat/store';
 import { useSessionStore } from '@/store/session';
-import { ChatMessage, ChatMessageError, MessageToolCall } from '@/types/message';
+import { UploadFileItem } from '@/types/files/upload';
+import {
+  ChatMessage,
+  ChatMessageError,
+  CreateMessageParams,
+  MessageToolCall,
+} from '@/types/message';
+import { MessageSemanticSearchChunk } from '@/types/rag';
 import { TraceEventPayloads } from '@/types/trace';
 import { setNamespace } from '@/utils/storeDebug';
 import { nanoid } from '@/utils/uuid';
@@ -28,6 +37,7 @@ import { nanoid } from '@/utils/uuid';
 import type { ChatStoreState } from '../../initialState';
 import { chatSelectors, topicSelectors } from '../../selectors';
 import { preventLeavingFn, toggleBooleanList } from '../../utils';
+import { ChatRAGAction, chatRag } from './actions/rag';
 import { MessageDispatch, messagesReducer } from './reducer';
 
 const n = setNamespace('m');
@@ -36,7 +46,7 @@ const SWR_USE_FETCH_MESSAGES = 'SWR_USE_FETCH_MESSAGES';
 
 export interface SendMessageParams {
   message: string;
-  files?: { id: string; url: string }[];
+  files?: UploadFileItem[];
   onlyAddUserMessage?: boolean;
   /**
    *
@@ -48,9 +58,13 @@ export interface SendMessageParams {
 interface ProcessMessageParams {
   traceId?: string;
   isWelcomeQuestion?: boolean;
+  /**
+   * the RAG query content, should be embedding and used in the semantic search
+   */
+  ragQuery?: string;
 }
 
-export interface ChatMessageAction {
+export interface ChatMessageAction extends ChatRAGAction {
   // create
   sendMessage: (params: SendMessageParams) => Promise<void>;
   addAIMessage: () => Promise<void>;
@@ -174,13 +188,16 @@ export interface ChatMessageAction {
 
 const getAgentConfig = () => agentSelectors.currentAgentConfig(useAgentStore.getState());
 const getAgentChatConfig = () => agentSelectors.currentAgentChatConfig(useAgentStore.getState());
+const getAgentKnowledge = () => agentSelectors.currentEnabledKnowledge(useAgentStore.getState());
 
 export const chatMessage: StateCreator<
   ChatStore,
   [['zustand/devtools', never]],
   [],
   ChatMessageAction
-> = (set, get) => ({
+> = (set, get, ...rest) => ({
+  ...chatRag(set, get, ...rest),
+
   deleteMessage: async (id) => {
     const message = chatSelectors.getMessageById(id)(get());
     if (!message) return;
@@ -261,10 +278,11 @@ export const chatMessage: StateCreator<
 
     const fileIdList = files?.map((f) => f.id);
 
-    const isNoFile = !fileIdList || fileIdList.length === 0;
+    const hasFile = !!fileIdList && fileIdList.length > 0;
 
     // if message is empty or no files, then stop
-    if (!message && isNoFile) return;
+    if (!message && !hasFile) return;
+
     set({ isCreatingMessage: true }, false, 'creatingMessage/start');
 
     const newMessage: CreateMessageParams = {
@@ -347,26 +365,43 @@ export const chatMessage: StateCreator<
 
     // Get the current messages to generate AI response
     const messages = chatSelectors.currentChats(get());
-    await internal_coreProcessMessage(messages, id, { isWelcomeQuestion });
+    const userFiles = chatSelectors.currentUserFiles(get()).map((f) => f.id);
+
+    await internal_coreProcessMessage(messages, id, {
+      isWelcomeQuestion,
+      ragQuery: get().internal_shouldUseRAG() ? message : undefined,
+    });
 
     set({ isCreatingMessage: false }, false, 'creatingMessage/stop');
 
-    // if autoCreateTopic is false, then stop
-    if (!agentConfig.enableAutoCreateTopic) return;
+    const summaryTitle = async () => {
+      // if autoCreateTopic is false, then stop
+      if (!agentConfig.enableAutoCreateTopic) return;
 
-    // check activeTopic and then auto update topic title
-    if (newTopicId) {
-      const chats = chatSelectors.currentChats(get());
-      await get().summaryTopicTitle(newTopicId, chats);
-      return;
-    }
+      // check activeTopic and then auto update topic title
+      if (newTopicId) {
+        const chats = chatSelectors.currentChats(get());
+        await get().summaryTopicTitle(newTopicId, chats);
+        return;
+      }
 
-    const topic = topicSelectors.currentActiveTopic(get());
+      const topic = topicSelectors.currentActiveTopic(get());
 
-    if (topic && !topic.title) {
-      const chats = chatSelectors.currentChats(get());
-      await get().summaryTopicTitle(topic.id, chats);
-    }
+      if (topic && !topic.title) {
+        const chats = chatSelectors.currentChats(get());
+        await get().summaryTopicTitle(topic.id, chats);
+      }
+    };
+
+    // if there is relative files, then add files to agent
+    // only available in server mode
+    const addFilesToAgent = async () => {
+      if (userFiles.length === 0 || !isServerMode) return;
+
+      await useAgentStore.getState().addFilesToAgent(userFiles, false);
+    };
+
+    await Promise.all([summaryTitle(), addFilesToAgent()]);
   },
   addAIMessage: async () => {
     const { internal_createMessage, updateInputMessage, activeTopicId, activeId, inputMessage } =
@@ -446,12 +481,48 @@ export const chatMessage: StateCreator<
   },
 
   // the internal process method of the AI message
-  internal_coreProcessMessage: async (messages, userMessageId, params) => {
+  internal_coreProcessMessage: async (originalMessages, userMessageId, params) => {
     const { internal_fetchAIChatMessage, triggerToolCalls, refreshMessages, activeTopicId } = get();
 
+    // create a new array to avoid the original messages array change
+    const messages = [...originalMessages];
+
     const { model, provider } = getAgentConfig();
 
-    // 1. Add an empty message to place the AI response
+    let fileChunks: MessageSemanticSearchChunk[] | undefined;
+    let ragQueryId;
+    // go into RAG flow if there is ragQuery flag
+    if (params?.ragQuery) {
+      // 1. get the relative chunks from semantic search
+      const { chunks, queryId } = await get().internal_retrieveChunks(
+        userMessageId,
+        params?.ragQuery,
+        // should skip the last content
+        messages.map((m) => m.content).slice(0, messages.length - 1),
+      );
+
+      ragQueryId = queryId;
+
+      console.log('召回 chunks', chunks);
+
+      // 2. build the retrieve context messages
+      const retrieveContext = chainAnswerWithContext({
+        context: chunks.map((c) => c.text as string),
+        question: params?.ragQuery,
+        knowledge: getAgentKnowledge().map((knowledge) => knowledge.name),
+      });
+
+      // 3. add the retrieve context messages to the messages history
+      if (retrieveContext.messages && retrieveContext.messages?.length > 0) {
+        // remove the last message due to the query is in the retrieveContext
+        messages.pop();
+        retrieveContext.messages?.forEach((m) => messages.push(m as ChatMessage));
+      }
+
+      fileChunks = chunks.map((c) => ({ id: c.id, similarity: c.similarity }));
+    }
+
+    // 2. Add an empty message to place the AI response
     const assistantMessage: CreateMessageParams = {
       role: 'assistant',
       content: LOADING_FLAT,
@@ -461,14 +532,16 @@ export const chatMessage: StateCreator<
       parentId: userMessageId,
       sessionId: get().activeId,
       topicId: activeTopicId, // if there is activeTopicId，then add it to topicId
+      fileChunks,
+      ragQueryId,
     };
 
     const assistantId = await get().internal_createMessage(assistantMessage);
 
-    // 2. fetch the AI response
+    // 3. fetch the AI response
     const { isFunctionCall } = await internal_fetchAIChatMessage(messages, assistantId, params);
 
-    // 3. if it's the function call message, trigger the function method
+    // 4. if it's the function call message, trigger the function method
     if (isFunctionCall) {
       await refreshMessages();
       await triggerToolCalls(assistantId);
@@ -661,7 +734,10 @@ export const chatMessage: StateCreator<
 
     if (!latestMsg) return;
 
-    await internal_coreProcessMessage(contextMessages, latestMsg.id, { traceId });
+    await internal_coreProcessMessage(contextMessages, latestMsg.id, {
+      traceId,
+      ragQuery: get().internal_shouldUseRAG() ? currentMessage.content : undefined,
+    });
   },
 
   internal_updateMessageError: async (id, error) => {

package/src/store/chat/slices/message/actions/rag.ts

@@ -0,0 +1,148 @@
+import { StateCreator } from 'zustand/vanilla';
+
+import { chainRewriteQuery } from '@/chains/rewriteQuery';
+import { chatService } from '@/services/chat';
+import { ragService } from '@/services/rag';
+import { useAgentStore } from '@/store/agent';
+import { agentSelectors } from '@/store/agent/selectors';
+import { ChatStore } from '@/store/chat';
+import { chatSelectors } from '@/store/chat/selectors';
+import { toggleBooleanList } from '@/store/chat/utils';
+import { useUserStore } from '@/store/user';
+import { systemAgentSelectors } from '@/store/user/selectors';
+import { ChatSemanticSearchChunk } from '@/types/chunk';
+import { merge } from '@/utils/merge';
+
+export interface ChatRAGAction {
+  deleteUserMessageRagQuery: (id: string) => Promise<void>;
+  /**
+   * Retrieve chunks from semantic search
+   */
+  internal_retrieveChunks: (
+    id: string,
+    userQuery: string,
+    messages: string[],
+  ) => Promise<{ chunks: ChatSemanticSearchChunk[]; queryId: string }>;
+  /**
+   * Rewrite user content to better RAG query
+   */
+  internal_rewriteQuery: (id: string, content: string, messages: string[]) => Promise<string>;
+
+  /**
+   * Check if we should use RAG
+   */
+  internal_shouldUseRAG: () => boolean;
+  internal_toggleMessageRAGLoading: (loading: boolean, id: string) => void;
+  rewriteQuery: (id: string) => Promise<void>;
+}
+
+const knowledgeIds = () => agentSelectors.currentKnowledgeIds(useAgentStore.getState());
+const hasEnabledKnowledge = () => agentSelectors.hasEnabledKnowledge(useAgentStore.getState());
+
+export const chatRag: StateCreator<ChatStore, [['zustand/devtools', never]], [], ChatRAGAction> = (
+  set,
+  get,
+) => ({
+  deleteUserMessageRagQuery: async (id) => {
+    const message = chatSelectors.getMessageById(id)(get());
+
+    if (!message || !message.ragQueryId) return;
+
+    // optimistic update the message's ragQuery
+    get().internal_dispatchMessage({
+      id,
+      type: 'updateMessage',
+      value: { ragQuery: null },
+    });
+
+    await ragService.deleteMessageRagQuery(message.ragQueryId);
+    await get().refreshMessages();
+  },
+
+  internal_retrieveChunks: async (id, userQuery, messages) => {
+    get().internal_toggleMessageRAGLoading(true, id);
+
+    const message = chatSelectors.getMessageById(id)(get());
+
+    // 1. get the rewrite query
+    let rewriteQuery = message?.ragQuery || userQuery;
+
+    // if there is no ragQuery and there is a chat history
+    // we need to rewrite the user message to get better results
+    if (!message?.ragQuery && messages.length > 0) {
+      rewriteQuery = await get().internal_rewriteQuery(id, userQuery, messages);
+    }
+
+    // 2. retrieve chunks from semantic search
+    const files = chatSelectors.currentUserFiles(get()).map((f) => f.id);
+    const { chunks, queryId } = await ragService.semanticSearchForChat({
+      fileIds: knowledgeIds().fileIds.concat(files),
+      knowledgeIds: knowledgeIds().knowledgeBaseIds,
+      messageId: id,
+      rewriteQuery,
+      userQuery,
+    });
+
+    get().internal_toggleMessageRAGLoading(false, id);
+
+    return { chunks, queryId };
+  },
+  internal_rewriteQuery: async (id, content, messages) => {
+    let rewriteQuery = content;
+
+    const queryRewriteConfig = systemAgentSelectors.queryRewrite(useUserStore.getState());
+    const rewriteQueryParams = merge(queryRewriteConfig, chainRewriteQuery(content, messages));
+
+    let ragQuery = '';
+    await chatService.fetchPresetTaskResult({
+      onFinish: async (text) => {
+        rewriteQuery = text;
+      },
+
+      onMessageHandle: (chunk) => {
+        if (chunk.type !== 'text') return;
+        ragQuery += chunk.text;
+
+        get().internal_dispatchMessage({
+          id,
+          type: 'updateMessage',
+          value: { ragQuery },
+        });
+      },
+      params: rewriteQueryParams,
+    });
+
+    return rewriteQuery;
+  },
+  internal_shouldUseRAG: () => {
+    const userFiles = chatSelectors.currentUserFiles(get()).map((f) => f.id);
+    //  if there is relative files or enabled knowledge, try with ragQuery
+    return hasEnabledKnowledge() || userFiles.length > 0;
+  },
+
+  internal_toggleMessageRAGLoading: (loading, id) => {
+    set(
+      {
+        messageRAGLoadingIds: toggleBooleanList(get().messageRAGLoadingIds, id, loading),
+      },
+      false,
+      'internal_toggleMessageLoading',
+    );
+  },
+
+  rewriteQuery: async (id) => {
+    const message = chatSelectors.getMessageById(id)(get());
+    if (!message) return;
+
+    // delete the current ragQuery
+    await get().deleteUserMessageRagQuery(id);
+
+    const chats = chatSelectors.currentChatsWithHistoryConfig(get());
+
+    await get().internal_rewriteQuery(
+      id,
+      message.content,
+      chats.map((m) => m.content),
+    );
+  },
+});

package/src/store/chat/slices/message/initialState.ts

@@ -11,6 +11,7 @@ export interface ChatMessageState {
    * is the AI message is generating
    */
   chatLoadingIds: string[];
+  inputFiles: File[];
   inputMessage: string;
   isCreatingMessage: boolean;
   /**
@@ -21,6 +22,10 @@ export interface ChatMessageState {
    * is the message is creating or updating in the service
    */
   messageLoadingIds: string[];
+  /**
+   * is the message is in RAG flow
+   */
+  messageRAGLoadingIds: string[];
   /**
    * whether messages have fetched
    */
@@ -36,10 +41,12 @@ export interface ChatMessageState {
 export const initialMessageState: ChatMessageState = {
   activeId: 'inbox',
   chatLoadingIds: [],
+  inputFiles: [],
   inputMessage: '',
   isCreatingMessage: false,
   messageEditingIds: [],
   messageLoadingIds: [],
+  messageRAGLoadingIds: [],
   messagesInit: false,
   messagesMap: {},
   pluginApiLoadingIds: [],

package/src/store/chat/slices/message/reducer.ts

@@ -1,8 +1,12 @@
 import isEqual from 'fast-deep-equal';
 import { produce } from 'immer';
 
-import { CreateMessageParams } from '@/services/message';
-import { ChatMessage, ChatPluginPayload, ChatToolPayload } from '@/types/message';
+import {
+  ChatMessage,
+  ChatPluginPayload,
+  ChatToolPayload,
+  CreateMessageParams,
+} from '@/types/message';
 import { merge } from '@/utils/merge';
 
 interface UpdateMessages {

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

@@ -11,7 +11,7 @@ import { useSessionStore } from '@/store/session';
 import { sessionMetaSelectors } from '@/store/session/selectors';
 import { useUserStore } from '@/store/user';
 import { userProfileSelectors } from '@/store/user/selectors';
-import { ChatMessage } from '@/types/message';
+import { ChatFileItem, ChatMessage } from '@/types/message';
 import { MetaData } from '@/types/meta';
 import { merge } from '@/utils/merge';
 
@@ -53,6 +53,21 @@ const currentToolMessages = (s: ChatStore) => {
   return messages.filter((m) => m.role === 'tool');
 };
 
+const currentUserMessages = (s: ChatStore) => {
+  const messages = currentChats(s);
+
+  return messages.filter((m) => m.role === 'user');
+};
+
+const currentUserFiles = (s: ChatStore) => {
+  const userMessages = currentUserMessages(s);
+
+  return userMessages
+    .filter((m) => m.fileList && m.fileList?.length > 0)
+    .flatMap((m) => m.fileList)
+    .filter(Boolean) as ChatFileItem[];
+};
+
 const initTime = Date.now();
 
 const showInboxWelcome = (s: ChatStore): boolean => {
@@ -140,10 +155,9 @@ const isCurrentChatLoaded = (s: ChatStore) => !!s.messagesMap[currentChatKey(s)]
 
 const isMessageEditing = (id: string) => (s: ChatStore) => s.messageEditingIds.includes(id);
 const isMessageLoading = (id: string) => (s: ChatStore) => s.messageLoadingIds.includes(id);
-const isHasMessageLoading = (s: ChatStore) => s.messageLoadingIds.length > 0;
-const isCreatingMessage = (s: ChatStore) => s.isCreatingMessage;
 
 const isMessageGenerating = (id: string) => (s: ChatStore) => s.chatLoadingIds.includes(id);
+const isMessageInRAGFlow = (id: string) => (s: ChatStore) => s.messageRAGLoadingIds.includes(id);
 const isPluginApiInvoking = (id: string) => (s: ChatStore) => s.pluginApiLoadingIds.includes(id);
 
 const isToolCallStreaming = (id: string, index: number) => (s: ChatStore) => {
@@ -153,7 +167,25 @@ const isToolCallStreaming = (id: string, index: number) => (s: ChatStore) => {
 
   return isLoading[index];
 };
+
 const isAIGenerating = (s: ChatStore) => s.chatLoadingIds.length > 0;
+const isInRAGFlow = (s: ChatStore) => s.messageRAGLoadingIds.length > 0;
+const isCreatingMessage = (s: ChatStore) => s.isCreatingMessage;
+const isHasMessageLoading = (s: ChatStore) => s.messageLoadingIds.length > 0;
+
+/**
+ * this function is used to determine whether the send button should be disabled
+ * @param s
+ */
+const isSendButtonDisabledByMessage = (s: ChatStore) =>
+  // 1. when there is message loading
+  isHasMessageLoading(s) ||
+  // 2. when is creating the topic
+  s.creatingTopic ||
+  // 3. when is creating the message
+  isCreatingMessage(s) ||
+  // 4. when the message is in RAG flow
+  isInRAGFlow(s);
 
 export const chatSelectors = {
   chatsMessageString,
@@ -164,6 +196,7 @@ export const chatSelectors = {
   currentChatsWithGuideMessage,
   currentChatsWithHistoryConfig,
   currentToolMessages,
+  currentUserFiles,
   getMessageById,
   getMessageByToolCallId,
   getTraceIdByMessageId,
@@ -173,8 +206,10 @@ export const chatSelectors = {
   isHasMessageLoading,
   isMessageEditing,
   isMessageGenerating,
+  isMessageInRAGFlow,
   isMessageLoading,
   isPluginApiInvoking,
+  isSendButtonDisabledByMessage,
   isToolCallStreaming,
   latestMessage,
   showInboxWelcome,

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

@@ -8,13 +8,19 @@ import { StateCreator } from 'zustand/vanilla';
 import { LOADING_FLAT } from '@/const/message';
 import { PLUGIN_SCHEMA_API_MD5_PREFIX, PLUGIN_SCHEMA_SEPARATOR } from '@/const/plugin';
 import { chatService } from '@/services/chat';
-import { CreateMessageParams, messageService } from '@/services/message';
+import { messageService } from '@/services/message';
 import { ChatStore } from '@/store/chat/store';
 import { useToolStore } from '@/store/tool';
 import { pluginSelectors } from '@/store/tool/selectors';
 import { builtinTools } from '@/tools';
 import { ChatErrorType } from '@/types/fetch';
-import { ChatMessage, ChatMessageError, ChatToolPayload, MessageToolCall } from '@/types/message';
+import {
+  ChatMessage,
+  ChatMessageError,
+  ChatToolPayload,
+  CreateMessageParams,
+  MessageToolCall,
+} from '@/types/message';
 import { merge } from '@/utils/merge';
 import { safeParseJSON } from '@/utils/safeParseJSON';
 import { setNamespace } from '@/utils/storeDebug';

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

@@ -4,6 +4,7 @@ import { ChatStore } from '@/store/chat/store';
 
 export interface ChatPortalAction {
   closeToolUI: () => void;
+  openFilePreview: (fileId: string) => void;
   openToolUI: (messageId: string, identifier: string) => void;
   togglePortal: (open?: boolean) => void;
 }
@@ -17,6 +18,13 @@ export const chatPortalSlice: StateCreator<
   closeToolUI: () => {
     set({ portalToolMessage: undefined }, false, 'openToolUI');
   },
+  openFilePreview: (fileId) => {
+    if (!get().showPortal) {
+      get().togglePortal(true);
+    }
+
+    set({ portalFile: { fileId } }, false, 'openFilePreview');
+  },
   openToolUI: (id, identifier) => {
     if (!get().showPortal) {
       get().togglePortal(true);

package/src/store/chat/slices/portal/initialState.ts

@@ -1,4 +1,7 @@
 export interface ChatPortalState {
+  portalFile?: {
+    fileId: string;
+  };
   portalToolMessage?: { id: string; identifier: string };
   showPortal: boolean;
 }

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

@@ -6,10 +6,16 @@ const showPortal = (s: ChatStoreState) => s.showPortal;
 const isArtifactMessageUIOpen = (id: string) => (s: ChatStoreState) =>
   artifactMessageId(s) === id && showPortal(s);
 
+const showArtifactUI = (s: ChatStoreState) => !!s.portalToolMessage;
+const showFilePreview = (s: ChatStoreState) => !!s.portalFile;
+const previewFileId = (s: ChatStoreState) => s.portalFile?.fileId;
+
 export const chatPortalSelectors = {
   artifactMessageId,
   isArtifactMessageUIOpen,
-  showArtifactUI: (state: ChatStoreState) => !!state.portalToolMessage,
+  previewFileId,
+  showArtifactUI,
+  showFilePreview,
   showPortal,
-  toolUIIdentifier: (state: ChatStoreState) => state.portalToolMessage?.identifier,
+  toolUIIdentifier: (s: ChatStoreState) => s.portalToolMessage?.identifier,
 };

package/src/store/file/initialState.ts

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