@lobehub/chat 1.11.8 → 1.12.0

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

@@ -0,0 +1,164 @@
+import { t } from 'i18next';
+import { sha256 } from 'js-sha256';
+import { StateCreator } from 'zustand/vanilla';
+
+import { message } from '@/components/AntdStaticMethods';
+import { isServerMode } from '@/const/version';
+import { fileService } from '@/services/file';
+import { ServerService } from '@/services/file/server';
+import { uploadService } from '@/services/upload';
+import { FileMetadata, UploadFileItem } from '@/types/files';
+
+import { FileStore } from '../../store';
+
+const serverFileService = new ServerService();
+
+interface UploadWithProgressParams {
+  file: File;
+  knowledgeBaseId?: string;
+  onStatusUpdate: (
+    data:
+      | {
+          id: string;
+          type: 'updateFile';
+          value: Partial<UploadFileItem>;
+        }
+      | {
+          id: string;
+          type: 'removeFile';
+        },
+  ) => void;
+}
+
+interface UploadWithProgressResult {
+  id: string;
+  url: string;
+}
+
+export interface FileUploadAction {
+  internal_uploadToClientDB: (
+    params: Omit<UploadWithProgressParams, 'knowledgeBaseId'>,
+  ) => Promise<UploadWithProgressResult | undefined>;
+  internal_uploadToServer: (params: UploadWithProgressParams) => Promise<UploadWithProgressResult>;
+  uploadWithProgress: (
+    params: UploadWithProgressParams,
+  ) => Promise<UploadWithProgressResult | undefined>;
+}
+
+export const createFileUploadSlice: StateCreator<
+  FileStore,
+  [['zustand/devtools', never]],
+  [],
+  FileUploadAction
+> = (set, get) => ({
+  internal_uploadToClientDB: async ({ file, onStatusUpdate }) => {
+    if (!file.type.startsWith('image')) {
+      onStatusUpdate({ id: file.name, type: 'removeFile' });
+      message.info({
+        content: t('upload.fileOnlySupportInServerMode', {
+          ext: file.name.split('.').pop(),
+          ns: 'error',
+        }),
+        duration: 5,
+      });
+      return;
+    }
+
+    const fileArrayBuffer = await file.arrayBuffer();
+
+    const hash = sha256(fileArrayBuffer);
+
+    const data = await uploadService.uploadToClientDB(
+      { fileType: file.type, hash, name: file.name, saveMode: 'local', size: file.size },
+      file,
+    );
+
+    onStatusUpdate({
+      id: file.name,
+      type: 'updateFile',
+      value: {
+        fileUrl: data.url,
+        id: data.id,
+        status: 'success',
+        uploadState: { progress: 100, restTime: 0, speed: 0 },
+      },
+    });
+
+    return data;
+  },
+
+  internal_uploadToServer: async ({ file, onStatusUpdate, knowledgeBaseId }) => {
+    const fileArrayBuffer = await file.arrayBuffer();
+
+    // 1. check file hash
+    const hash = sha256(fileArrayBuffer);
+
+    const checkStatus = await serverFileService.checkFileHash(hash);
+    let metadata: FileMetadata;
+
+    // 2. if file exist, just skip upload
+    if (checkStatus.isExist) {
+      metadata = checkStatus.metadata as FileMetadata;
+      onStatusUpdate({
+        id: file.name,
+        type: 'updateFile',
+        value: { status: 'processing', uploadState: { progress: 100, restTime: 0, speed: 0 } },
+      });
+    } else {
+      // 2. if file don't exist, need upload files
+      metadata = await uploadService.uploadWithProgress(file, (status, upload) => {
+        onStatusUpdate({
+          id: file.name,
+          type: 'updateFile',
+          value: { status: status === 'success' ? 'processing' : status, uploadState: upload },
+        });
+      });
+    }
+
+    // 3. use more powerful file type detector to get file type
+    let fileType = file.type;
+
+    if (!file.type) {
+      const { fileTypeFromBuffer } = await import('file-type');
+
+      const type = await fileTypeFromBuffer(fileArrayBuffer);
+      fileType = type?.mime || 'text/plain';
+    }
+
+    // 4. create file to db
+    const data = await fileService.createFile(
+      {
+        createdAt: Date.now(),
+        fileType,
+        hash,
+        metadata,
+        name: file.name,
+        saveMode: 'url',
+        size: file.size,
+        url: metadata.path,
+      },
+      knowledgeBaseId,
+    );
+
+    onStatusUpdate({
+      id: file.name,
+      type: 'updateFile',
+      value: {
+        fileUrl: data.url,
+        id: data.id,
+        status: 'success',
+        uploadState: { progress: 100, restTime: 0, speed: 0 },
+      },
+    });
+
+    return data;
+  },
+
+  uploadWithProgress: async ({ file, onStatusUpdate, knowledgeBaseId }) => {
+    const { internal_uploadToServer, internal_uploadToClientDB } = get();
+
+    if (isServerMode) return internal_uploadToServer({ file, knowledgeBaseId, onStatusUpdate });
+
+    return internal_uploadToClientDB({ file, onStatusUpdate });
+  },
+});

package/src/store/file/store.ts

@@ -5,16 +5,27 @@ import { StateCreator } from 'zustand/vanilla';
 import { createDevtools } from '../middleware/createDevtools';
 import { FilesStoreState, initialState } from './initialState';
 import { FileAction, createFileSlice } from './slices/chat';
+import { FileChunkAction, createFileChunkSlice } from './slices/chunk';
+import { FileManageAction, createFileManageSlice } from './slices/fileManager';
 import { TTSFileAction, createTTSFileSlice } from './slices/tts';
+import { FileUploadAction, createFileUploadSlice } from './slices/upload/action';
 
 //  ===============  聚合 createStoreFn ============ //
 
-export type FileStore = FilesStoreState & FileAction & TTSFileAction;
+export type FileStore = FilesStoreState &
+  FileAction &
+  TTSFileAction &
+  FileManageAction &
+  FileChunkAction &
+  FileUploadAction;
 
 const createStore: StateCreator<FileStore, [['zustand/devtools', never]]> = (...parameters) => ({
   ...initialState,
   ...createFileSlice(...parameters),
+  ...createFileManageSlice(...parameters),
   ...createTTSFileSlice(...parameters),
+  ...createFileChunkSlice(...parameters),
+  ...createFileUploadSlice(...parameters),
 });
 
 //  ===============  实装 useStore ============ //

package/src/store/knowledgeBase/index.ts

@@ -0,0 +1,2 @@
+export * from './selectors';
+export { useKnowledgeBaseStore } from './store';

package/src/store/knowledgeBase/initialState.ts

@@ -0,0 +1,7 @@
+import { KnowledgeBaseState, initialKnowledgeBaseState } from '../knowledgeBase/slices/crud';
+
+export type KnowledgeBaseStoreState = KnowledgeBaseState;
+
+export const initialState: KnowledgeBaseStoreState = {
+  ...initialKnowledgeBaseState,
+};

package/src/store/knowledgeBase/selectors.ts

@@ -0,0 +1 @@
+export * from './slices/crud/selectors';

package/src/store/knowledgeBase/slices/content/action.ts

@@ -0,0 +1,27 @@
+import { StateCreator } from 'zustand/vanilla';
+
+import { knowledgeBaseService } from '@/services/knowledgeBase';
+import { useFileStore } from '@/store/file';
+import { KnowledgeBaseStore } from '@/store/knowledgeBase/store';
+
+export interface KnowledgeBaseContentAction {
+  addFilesToKnowledgeBase: (knowledgeBaseId: string, ids: string[]) => Promise<void>;
+  removeFilesFromKnowledgeBase: (knowledgeBaseId: string, ids: string[]) => Promise<void>;
+}
+
+export const createContentSlice: StateCreator<
+  KnowledgeBaseStore,
+  [['zustand/devtools', never]],
+  [],
+  KnowledgeBaseContentAction
+> = () => ({
+  addFilesToKnowledgeBase: async (knowledgeBaseId, ids) => {
+    await knowledgeBaseService.addFilesToKnowledgeBase(knowledgeBaseId, ids);
+    await useFileStore.getState().refreshFileList();
+  },
+
+  removeFilesFromKnowledgeBase: async (knowledgeBaseId, ids) => {
+    await knowledgeBaseService.removeFilesFromKnowledgeBase(knowledgeBaseId, ids);
+    await useFileStore.getState().refreshFileList();
+  },
+});

package/src/store/knowledgeBase/slices/content/index.ts

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

package/src/store/knowledgeBase/slices/crud/action.ts

@@ -0,0 +1,78 @@
+import { SWRResponse, mutate } from 'swr';
+import { StateCreator } from 'zustand/vanilla';
+
+import { useClientDataSWR } from '@/libs/swr';
+import { knowledgeBaseService } from '@/services/knowledgeBase';
+import { KnowledgeBaseStore } from '@/store/knowledgeBase/store';
+import { CreateKnowledgeBaseParams, KnowledgeBaseItem } from '@/types/knowledgeBase';
+
+const FETCH_KNOWLEDGE_BASE_LIST_KEY = 'FETCH_KNOWLEDGE_BASE';
+const FETCH_KNOWLEDGE_BASE_ITEM_KEY = 'FETCH_KNOWLEDGE_BASE_ITEM';
+
+export interface KnowledgeBaseCrudAction {
+  createNewKnowledgeBase: (params: CreateKnowledgeBaseParams) => Promise<void>;
+  internal_toggleKnowledgeBaseLoading: (id: string, loading: boolean) => void;
+  refreshKnowledgeBaseList: () => Promise<void>;
+
+  removeKnowledgeBase: (id: string) => Promise<void>;
+  updateKnowledgeBase: (id: string, value: CreateKnowledgeBaseParams) => Promise<void>;
+
+  useFetchKnowledgeBaseItem: (id: string) => SWRResponse<KnowledgeBaseItem | undefined>;
+  useFetchKnowledgeBaseList: (params?: { suspense?: boolean }) => SWRResponse<KnowledgeBaseItem[]>;
+}
+
+export const createCrudSlice: StateCreator<
+  KnowledgeBaseStore,
+  [['zustand/devtools', never]],
+  [],
+  KnowledgeBaseCrudAction
+> = (set, get) => ({
+  createNewKnowledgeBase: async (params) => {
+    await knowledgeBaseService.createKnowledgeBase(params);
+    await get().refreshKnowledgeBaseList();
+  },
+  internal_toggleKnowledgeBaseLoading: (id, loading) => {
+    set(
+      (state) => {
+        if (loading) return { knowledgeBaseLoadingIds: [...state.knowledgeBaseLoadingIds, id] };
+
+        return { knowledgeBaseLoadingIds: state.knowledgeBaseLoadingIds.filter((i) => i !== id) };
+      },
+      false,
+      'toggleKnowledgeBaseLoading',
+    );
+  },
+  refreshKnowledgeBaseList: async () => {
+    await mutate(FETCH_KNOWLEDGE_BASE_LIST_KEY);
+  },
+  removeKnowledgeBase: async (id) => {
+    await knowledgeBaseService.deleteKnowledgeBase(id);
+    await get().refreshKnowledgeBaseList();
+  },
+  updateKnowledgeBase: async (id, value) => {
+    get().internal_toggleKnowledgeBaseLoading(id, true);
+    await knowledgeBaseService.updateKnowledgeBaseList(id, value);
+    await get().refreshKnowledgeBaseList();
+
+    get().internal_toggleKnowledgeBaseLoading(id, false);
+  },
+
+  useFetchKnowledgeBaseItem: (id) =>
+    useClientDataSWR<KnowledgeBaseItem | undefined>([FETCH_KNOWLEDGE_BASE_ITEM_KEY, id], () =>
+      knowledgeBaseService.getKnowledgeBaseById(id),
+    ),
+
+  useFetchKnowledgeBaseList: (params = {}) =>
+    useClientDataSWR<KnowledgeBaseItem[]>(
+      FETCH_KNOWLEDGE_BASE_LIST_KEY,
+      () => knowledgeBaseService.getKnowledgeBaseList(),
+      {
+        fallbackData: [],
+        onSuccess: () => {
+          if (!get().initKnowledgeBaseList)
+            set({ initKnowledgeBaseList: true }, false, 'useFetchKnowledgeBaseList/init');
+        },
+        suspense: params.suspense,
+      },
+    ),
+});

package/src/store/knowledgeBase/slices/crud/index.ts

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

package/src/store/knowledgeBase/slices/crud/initialState.ts

@@ -0,0 +1,12 @@
+export interface KnowledgeBaseState {
+  activeKnowledgeBaseId: string | null;
+  initKnowledgeBaseList: boolean;
+  knowledgeBaseLoadingIds: string[];
+  knowledgeBaseRenamingId?: string | null;
+}
+
+export const initialKnowledgeBaseState: KnowledgeBaseState = {
+  activeKnowledgeBaseId: null,
+  initKnowledgeBaseList: false,
+  knowledgeBaseLoadingIds: [],
+};

package/src/store/knowledgeBase/slices/crud/selectors.ts

@@ -0,0 +1,7 @@
+import { KnowledgeBaseStoreState } from '@/store/knowledgeBase/initialState';
+
+const activeKnowledgeBaseId = (s: KnowledgeBaseStoreState) => s.activeKnowledgeBaseId;
+
+export const knowledgeBaseSelectors = {
+  activeKnowledgeBaseId,
+};

package/src/store/knowledgeBase/store.ts

@@ -0,0 +1,30 @@
+import { shallow } from 'zustand/shallow';
+import { createWithEqualityFn } from 'zustand/traditional';
+import { StateCreator } from 'zustand/vanilla';
+
+import { createDevtools } from '../middleware/createDevtools';
+import { KnowledgeBaseStoreState, initialState } from './initialState';
+import { KnowledgeBaseContentAction, createContentSlice } from './slices/content';
+import { KnowledgeBaseCrudAction, createCrudSlice } from './slices/crud';
+
+//  ===============  聚合 createStoreFn ============ //
+
+export type KnowledgeBaseStore = KnowledgeBaseStoreState &
+  KnowledgeBaseCrudAction &
+  KnowledgeBaseContentAction;
+
+const createStore: StateCreator<KnowledgeBaseStore, [['zustand/devtools', never]]> = (
+  ...parameters
+) => ({
+  ...initialState,
+  ...createCrudSlice(...parameters),
+  ...createContentSlice(...parameters),
+});
+
+//  ===============  实装 useStore ============ //
+const devtools = createDevtools('knowledgeBase');
+
+export const useKnowledgeBaseStore = createWithEqualityFn<KnowledgeBaseStore>()(
+  devtools(createStore),
+  shallow,
+);

package/src/store/serverConfig/selectors.test.ts

@@ -21,7 +21,7 @@ describe('featureFlagsSelectors', () => {
       isAgentEditable: false,
       showCreateSession: true,
       showDalle: true,
-      enableKnowledgeBase: false,
+      enableKnowledgeBase: true,
       showLLM: false,
       showCloudPromotion: false,
       showOpenAIApiKey: true,

package/src/store/user/slices/preference/selectors.ts

@@ -8,12 +8,20 @@ const hideSyncAlert = (s: UserStore) => s.preference.hideSyncAlert;
 
 const hideSettingsMoveGuide = (s: UserStore) => s.preference.guide?.moveSettingsToAvatar;
 
+const showUploadFileInKnowledgeBaseTip = (s: UserStore) =>
+  s.preference.guide?.uploadFileInKnowledgeBase;
+
+const shouldTriggerFileInKnowledgeBaseTip = (s: UserStore) =>
+  !(typeof s.preference.guide?.moveSettingsToAvatar === 'boolean');
+
 const isPreferenceInit = (s: UserStore) => s.isUserStateInit;
 
 export const preferenceSelectors = {
   hideSettingsMoveGuide,
   hideSyncAlert,
   isPreferenceInit,
+  shouldTriggerFileInKnowledgeBaseTip,
+  showUploadFileInKnowledgeBaseTip,
   useCmdEnterToSend,
   userAllowTrace,
 };

package/src/store/user/slices/settings/selectors/systemAgent.ts

@@ -10,9 +10,11 @@ const currentSystemAgent = (s: UserStore) =>
 const translation = (s: UserStore) => currentSystemAgent(s).translation;
 const topic = (s: UserStore) => currentSystemAgent(s).topic;
 const agentMeta = (s: UserStore) => currentSystemAgent(s).agentMeta;
+const queryRewrite = (s: UserStore) => currentSystemAgent(s).queryRewrite;
 
 export const systemAgentSelectors = {
   agentMeta,
+  queryRewrite,
   topic,
   translation,
 };

package/src/tools/dalle/Render/Item/ImageFileItem.tsx

@@ -1,7 +1,6 @@
-import { ActionIcon, Image } from '@lobehub/ui';
+import { Image } from '@lobehub/ui';
 import { createStyles } from 'antd-style';
-import { Trash } from 'lucide-react';
-import { CSSProperties, memo, useCallback } from 'react';
+import { CSSProperties, memo } from 'react';
 
 import { usePlatform } from '@/hooks/usePlatform';
 import { useFileStore } from '@/store/file';
@@ -35,33 +34,14 @@ interface FileItemProps {
   style?: CSSProperties;
 }
 const ImageFileItem = memo<FileItemProps>(({ editable, id, alwaysShowClose }) => {
-  const [useFetchFile, removeFile] = useFileStore((s) => [s.useFetchFile, s.removeFile]);
+  const [useFetchFile] = useFileStore((s) => [s.useFetchFile]);
   const IMAGE_SIZE = editable ? MIN_IMAGE_SIZE : '100%';
   const { data, isLoading } = useFetchFile(id);
   const { styles, cx } = useStyles();
   const { isSafari } = usePlatform();
 
-  const handleRemoveFile = useCallback(
-    (e: any) => {
-      e.stopPropagation();
-      removeFile(id);
-    },
-    [id],
-  );
-
   return (
     <Image
-      actions={
-        editable && (
-          <ActionIcon
-            className={styles.deleteButton}
-            glass
-            icon={Trash}
-            onClick={handleRemoveFile}
-            size={'small'}
-          />
-        )
-      }
       alt={data?.name || id || ''}
       alwaysShowActions={alwaysShowClose}
       height={isSafari ? 'auto' : '100%'}

package/src/types/agent/index.ts

@@ -1,5 +1,7 @@
 import { z } from 'zod';
 
+import { FileItem } from '@/types/files';
+import { KnowledgeBaseItem } from '@/types/knowledgeBase';
 import { FewShots, LLMParams } from '@/types/llm';
 
 export type TTSServer = 'openai' | 'edge' | 'microsoft';
@@ -18,6 +20,12 @@ export interface LobeAgentTTSConfig {
 export interface LobeAgentConfig {
   chatConfig: LobeAgentChatConfig;
   fewShots?: FewShots;
+  files?: FileItem[];
+  id?: string;
+  /**
+   * knowledge bases
+   */
+  knowledgeBases?: KnowledgeBaseItem[];
   /**
    * 角色所使用的语言模型
    * @default gpt-4o-mini
@@ -39,6 +47,7 @@ export interface LobeAgentConfig {
    * 系统角色
    */
   systemRole: string;
+
   /**
    * 语音服务
    */

package/src/types/asyncTask.ts

@@ -0,0 +1,31 @@
+export enum AsyncTaskType {
+  Chunking = 'chunk',
+  Embedding = 'embedding',
+}
+
+export enum AsyncTaskStatus {
+  Error = 'error',
+  Pending = 'pending',
+  Processing = 'processing',
+  Success = 'success',
+}
+
+export enum AsyncTaskErrorType {
+  SDKError = 'SDKError',
+  ServerError = 'ServerError',
+  Timeout = 'TaskTimeout',
+}
+
+export interface AsyncTaskError {
+  body: string | { detail: string };
+  name: string;
+}
+
+export interface FileParsingTask {
+  chunkCount?: number | null;
+  chunkingError?: AsyncTaskError | null;
+  chunkingStatus?: AsyncTaskStatus | null;
+  embeddingError?: AsyncTaskError | null;
+  embeddingStatus?: AsyncTaskStatus | null;
+  finishEmbedding?: boolean;
+}

package/src/types/chunk/document.ts

@@ -0,0 +1,9 @@
+export interface ChunkDocument {
+  compositeId?: string;
+  id?: string;
+  index: number;
+  metadata: any;
+  parentId?: string;
+  text: string;
+  type: string;
+}

package/src/types/chunk/index.ts

@@ -0,0 +1,52 @@
+export enum ChunkStatus {
+  Error = 'error',
+  Processing = 'processing',
+  Success = 'success',
+}
+
+export interface Elements {
+  element_id: string;
+  metadata: ChunkMetadata;
+  text: string;
+  type: string;
+}
+
+export interface ChunkMetadata {
+  coordinates: Coordinates;
+  languages: string[];
+  pageNumber?: number;
+  parent_id?: string;
+  text_as_html?: string;
+}
+
+export interface Coordinates {
+  layout_height: number;
+  layout_width: number;
+  points: number[][];
+  system: string;
+}
+
+export interface FileChunk {
+  createdAt: Date;
+  id: string;
+  index: number;
+  metadata: ChunkMetadata | null;
+  pageNumber?: number;
+  parentId?: string | null;
+  text: string;
+  type: string;
+  updatedAt: Date;
+}
+
+export interface SemanticSearchChunk {
+  id: string;
+  metadata: ChunkMetadata | null;
+  pageNumber?: number | null;
+  similarity: number;
+  text: string | null;
+  type: string | null;
+}
+
+export type ChatSemanticSearchChunk = Omit<SemanticSearchChunk, 'metadata' | 'type'>;
+
+export * from './document';

package/src/types/files/index.ts

@@ -0,0 +1,35 @@
+export enum FilesTabs {
+  All = 'all',
+  Audios = 'audios',
+  Documents = 'documents',
+  Images = 'images',
+  Videos = 'videos',
+  Websites = 'websites',
+}
+
+/**
+ * @deprecated
+ */
+export interface FilePreview {
+  base64Url?: string;
+  data?: ArrayBuffer;
+  fileType: string;
+  id: string;
+  name: string;
+  saveMode: 'local' | 'url';
+  url: string;
+}
+
+export interface FileItem {
+  createdAt: Date;
+  enabled?: boolean;
+  id: string;
+  name: string;
+  size: number;
+  type: string;
+  updatedAt: Date;
+  url: string;
+}
+
+export * from './list';
+export * from './upload';

package/src/types/files/list.ts

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+
+import { AsyncTaskStatus } from '@/types/asyncTask';
+
+export interface FileListItem {
+  chunkCount: number | null;
+  chunkingError: any | null;
+  chunkingStatus?: AsyncTaskStatus | null;
+  createdAt: Date;
+  embeddingError: any | null;
+  embeddingStatus?: AsyncTaskStatus | null;
+  fileType: string;
+  finishEmbedding: boolean;
+  id: string;
+  name: string;
+  size: number;
+  updatedAt: Date;
+  url: string;
+}
+
+export enum SortType {
+  Asc = 'asc',
+  Desc = 'desc',
+}
+
+export const QueryFileListSchema = z.object({
+  category: z.string().optional(),
+  knowledgeBaseId: z.string().optional(),
+  q: z.string().nullable().optional(),
+  showFilesInKnowledgeBase: z.boolean().default(false),
+  sortType: z.enum(['desc', 'asc']).optional(),
+  sorter: z.enum(['createdAt', 'size']).optional(),
+});
+
+export type QueryFileListSchemaType = z.infer<typeof QueryFileListSchema>;
+
+export interface QueryFileListParams {
+  category?: string;
+  knowledgeBaseId?: string;
+  q?: string | null;
+  showFilesInKnowledgeBase?: boolean;
+  sortType?: string;
+  sorter?: string;
+}