@lobehub/chat 1.11.1 → 1.11.3

package/src/libs/unstructured/__tests__/index.test.ts

@@ -0,0 +1,165 @@
+// @vitest-environment node
+import { UnstructuredClient } from 'unstructured-client';
+import { Strategy } from 'unstructured-client/sdk/models/shared';
+import { ChunkingStrategy } from 'unstructured-client/sdk/models/shared/partitionparameters';
+import { PartitionResponse } from 'unstructured-client/src/sdk/models/operations';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { Unstructured } from '../index';
+import AutoWithChunkingOutput from './fixtures/table-parse/auto-partition-basic-output.json';
+import AutoWithChunkingRaw from './fixtures/table-parse/auto-partition-basic-raw.json';
+import AutoWithoutChunking from './fixtures/table-parse/auto-partition-raw.json';
+import FastWithoutChunkingRaw from './fixtures/table-parse/fast-partition-raw.json';
+
+// Mock the external dependencies
+let UNSTRUCTURED_API_KEY = 'test-api-key';
+
+vi.mock('@/config/knowledge', () => ({
+  knowledgeEnv: {
+    get UNSTRUCTURED_API_KEY() {
+      return UNSTRUCTURED_API_KEY;
+    },
+
+    UNSTRUCTURED_SERVER_URL: 'http://test-server.com',
+  },
+}));
+
+let client: Unstructured;
+
+beforeEach(() => {
+  client = new Unstructured();
+});
+
+afterEach(() => {
+  vi.clearAllMocks();
+});
+
+const mockPartitionResponse = (elements: any[]) =>
+  ({
+    statusCode: 200,
+    elements,
+    rawResponse: new Response(),
+    contentType: 'application/json',
+  }) as PartitionResponse;
+
+describe('Unstructured', () => {
+  describe('init', () => {
+    it('should create an instance with API key from environment', () => {
+      expect(client).toBeInstanceOf(Unstructured);
+    });
+
+    it('should create an instance with provided API key', () => {
+      const customUnstructured = new Unstructured('custom-api-key');
+      expect(customUnstructured).toBeInstanceOf(Unstructured);
+    });
+
+    it('should throw an error if no API key is provided or in environment', () => {
+      let defaultKey = UNSTRUCTURED_API_KEY;
+      UNSTRUCTURED_API_KEY = '';
+
+      expect(() => new Unstructured()).toThrow(
+        '"UNSTRUCTURED_API_KEY" variables are not set completely, please check your env',
+      );
+      UNSTRUCTURED_API_KEY = defaultKey;
+    });
+  });
+
+  describe('basic partition', () => {
+    it('should return empty arrays if partition response is not successful', async () => {
+      vi.spyOn(UnstructuredClient.prototype.general, 'partition').mockResolvedValue({
+        statusCode: 400,
+      } as any);
+
+      const result = await client.partition({
+        fileContent: new Uint8Array(),
+        filename: 'test.txt',
+      });
+
+      expect(result.compositeElements).toEqual([]);
+      expect(result.originElements).toEqual([]);
+    });
+
+    it('should partition content successfully with default strategy', async () => {
+      vi.spyOn(UnstructuredClient.prototype.general, 'partition').mockResolvedValue(
+        mockPartitionResponse(AutoWithoutChunking),
+      );
+
+      const result = await client.partition({
+        fileContent: new Uint8Array(),
+        filename: 'test.txt',
+      });
+
+      expect(result.compositeElements).toHaveLength(0);
+      expect(result.originElements).toHaveLength(12);
+
+      expect(result.originElements[0].text).toBe('Multiple Sclerosis Journal 29(6)');
+      expect(result.originElements[2].type).toBe('Table');
+    });
+
+    it('should partition content successfully with fast strategy', async () => {
+      vi.spyOn(UnstructuredClient.prototype.general, 'partition').mockResolvedValue(
+        mockPartitionResponse(FastWithoutChunkingRaw),
+      );
+
+      const result = await client.partition({
+        fileContent: new Uint8Array(),
+        filename: 'test.txt',
+        strategy: Strategy.Fast,
+      });
+
+      expect(result.compositeElements).toHaveLength(0);
+      expect(result.originElements).toHaveLength(82);
+
+      expect(result.originElements[0].text).toBe('Multiple Sclerosis Journal 29(6)');
+      expect(result.originElements.every((item) => item.text !== 'Table')).toBeTruthy();
+    });
+  });
+
+  describe('partition with chunk strategy', () => {
+    it('should use provided chunking strategy with Table', async () => {
+      vi.spyOn(UnstructuredClient.prototype.general, 'partition').mockResolvedValue(
+        mockPartitionResponse(AutoWithChunkingRaw),
+      );
+
+      const result = await client.partition({
+        fileContent: new Uint8Array(),
+        filename: 'test.txt',
+        chunkingStrategy: ChunkingStrategy.Basic,
+      });
+
+      expect(result.compositeElements).toHaveLength(6);
+      expect(result.originElements).toHaveLength(12);
+
+      expect(result.originElements).toEqual(AutoWithChunkingOutput.originElements);
+      expect(result.originElements).toEqual(AutoWithChunkingOutput.originElements);
+    });
+
+    it.skip('should error', async () => {
+      vi.spyOn(UnstructuredClient.prototype.general, 'partition').mockResolvedValue(
+        mockPartitionResponse([
+          {
+            type: 'CompositeElement',
+            element_id: '32855cf6-5605-4a8e-97a3-3ac0b509b725',
+            text: 'abc',
+            metadata: {
+              filetype: 'application/pdf',
+              languages: ['eng'],
+              page_number: 1,
+              orig_elements: 'e==',
+              filename: 'table-parse.pdf',
+            },
+          },
+        ]),
+      );
+      try {
+        await client.partition({
+          fileContent: new Uint8Array(),
+          filename: 'test.txt',
+          chunkingStrategy: ChunkingStrategy.Basic,
+        });
+      } catch (e) {
+        expect(e).toThrowError('unexpected end of file');
+      }
+    });
+  });
+});

package/src/libs/unstructured/index.ts

@@ -0,0 +1,166 @@
+import zlib from 'node:zlib';
+import pMap from 'p-map';
+import { UnstructuredClient } from 'unstructured-client';
+import { Strategy } from 'unstructured-client/sdk/models/shared';
+import { PartitionResponse } from 'unstructured-client/src/sdk/models/operations';
+
+import { knowledgeEnv } from '@/config/knowledge';
+
+export enum ChunkingStrategy {
+  Basic = 'basic',
+  ByPage = 'by_page',
+  BySimilarity = 'by_similarity',
+  ByTitle = 'by_title',
+}
+
+export interface UnstructuredPartitionElement {
+  compositeId?: string;
+  element_id: string;
+  metadata: Metadata;
+  text: string;
+  type: string;
+}
+
+export interface Metadata {
+  coordinates: Coordinates;
+  filename: string;
+  filetype: string;
+  image_base64?: string;
+  image_mime_type?: string;
+  is_continuation?: boolean;
+  languages: string[];
+  orig_elements?: string;
+  page_name?: string;
+  page_number: number;
+  parent_id?: string;
+  text_as_html?: string;
+}
+
+export interface Coordinates {
+  layout_height: number;
+  layout_width: number;
+  points: number[][];
+  system: string;
+}
+
+class UnstructuredError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'Unstructured';
+  }
+}
+
+interface PartitionParameters {
+  chunkingStrategy?: ChunkingStrategy;
+  fileContent: Uint8Array;
+  filename: string;
+  maxCharacters?: number;
+  onResponse?: (response: PartitionResponse) => void;
+  strategy?: Strategy;
+}
+
+export class Unstructured {
+  private client: UnstructuredClient;
+
+  constructor(apikey?: string) {
+    if (!apikey && !knowledgeEnv.UNSTRUCTURED_API_KEY)
+      throw new UnstructuredError(
+        `"UNSTRUCTURED_API_KEY" variables are not set completely, please check your env`,
+      );
+
+    this.client = new UnstructuredClient({
+      security: { apiKeyAuth: apikey || knowledgeEnv.UNSTRUCTURED_API_KEY! },
+      serverURL: knowledgeEnv.UNSTRUCTURED_SERVER_URL,
+    });
+  }
+
+  async partition(params: PartitionParameters): Promise<{
+    compositeElements: UnstructuredPartitionElement[];
+    originElements: UnstructuredPartitionElement[];
+  }> {
+    const hasChunkingStrategy = !!params.chunkingStrategy;
+    const response = await this.client.general.partition({
+      partitionParameters: {
+        chunkingStrategy: params.chunkingStrategy,
+        coordinates: true,
+        // extractImageBlockTypes: ['Image'],
+        files: { content: params.fileContent, fileName: params.filename },
+
+        includeOrigElements: true,
+        maxCharacters: params.maxCharacters || 800,
+        strategy: params.strategy,
+        uniqueElementIds: true,
+      },
+    });
+
+    if (response.statusCode === 200) {
+      // after finish partition, we need to filter out some elements
+      const elements = response.elements as UnstructuredPartitionElement[];
+
+      params.onResponse?.(response);
+
+      let originElements: UnstructuredPartitionElement[] = [];
+      let compositeElements: UnstructuredPartitionElement[] = [];
+
+      if (hasChunkingStrategy) {
+        await pMap(elements, async (element) => {
+          // Your Base64 encoded string
+          const base64EncodedString = element.metadata.orig_elements as string;
+          delete element.metadata.orig_elements;
+
+          if (!base64EncodedString) return;
+
+          // Step 1: Decode the Base64 encoded string to binary
+          const binaryBuffer = Buffer.from(base64EncodedString, 'base64');
+
+          // Step 2: Decompress the binary data
+          const elements = await this.decompressGzip(binaryBuffer);
+
+          // if element is Table type then get the origin
+          if (element.type === 'Table') {
+            // skip continuation table due to being split by chunk strategy
+            if (element.metadata.is_continuation) {
+              return;
+            }
+
+            compositeElements = [...compositeElements, elements[0]];
+            originElements = [...originElements, elements[0]];
+            return;
+          }
+
+          compositeElements = [...compositeElements, element];
+
+          originElements = originElements.concat(
+            elements.map(
+              (e) => ({ ...e, compositeId: element.element_id }) as UnstructuredPartitionElement,
+            ),
+          );
+        });
+      } else {
+        originElements = elements;
+      }
+
+      return { compositeElements, originElements };
+    } else {
+      return { compositeElements: [], originElements: [] };
+    }
+  }
+
+  private async decompressGzip(data: Buffer): Promise<UnstructuredPartitionElement[]> {
+    return new Promise((resolve, reject) => {
+      zlib.inflate(data, (err, decompressedBuffer) => {
+        if (err) {
+          reject(err);
+        }
+
+        // Step 3: Convert the decompressed buffer to a string
+        let decompressedString = decompressedBuffer.toString('utf8');
+
+        // Step 4: Parse the JSON string
+        let jsonObject = JSON.parse(decompressedString);
+
+        resolve(jsonObject);
+      });
+    });
+  }
+}

package/src/locales/default/common.ts

@@ -14,6 +14,7 @@ export default {
   autoGenerate: '自动补全',
   autoGenerateTooltip: '基于提示词自动补全助手描述',
   autoGenerateTooltipDisabled: '请填写提示词后使用自动补全功能',
+  batchDelete: '批量删除',
   blog: '产品博客',
   cancel: '取消',
   changelog: '更新日志',
@@ -32,6 +33,7 @@ export default {
   defaultSession: '自定义助手',
   delete: '删除',
   document: '使用文档',
+  download: '下载',
   duplicate: '创建副本',
   edit: '编辑',
   export: '导出配置',
@@ -185,6 +187,7 @@ export default {
   },
   tab: {
     chat: '会话',
+    files: '文件',
     market: '发现',
     me: '我',
     setting: '设置',

package/src/locales/default/components.ts

@@ -5,6 +5,68 @@ export default {
     dragFileTitle: '上传文件',
     dragTitle: '上传图片',
   },
+  FileManager: {
+    actions: {
+      addToKnowledgeBase: '添加到知识库',
+      addToOtherKnowledgeBase: '添加到其他知识库',
+      batchChunking: '批量分块',
+      chunking: '分块',
+      chunkingTooltip: '将文件拆分为多个文本块并向量化后，可用于语义检索和文件对话',
+      confirmDelete: '即将删除该文件，删除后该将无法找回，请确认你的操作',
+      confirmDeleteMultiFiles:
+        '即将删除选中的 {{count}} 个文件，删除后该将无法找回，请确认你的操作',
+      confirmRemoveFromKnowledgeBase:
+        '即将从知识库中移除选中的 {{count}} 个文件，移除后文件仍然可以在全部文件中查看，请确认你的操作',
+      copyUrl: '复制链接',
+      copyUrlSuccess: '文件地址复制成功',
+      createChunkingTask: '准备中...',
+      deleteSuccess: '文件删除成功',
+      downloading: '文件下载中...',
+      removeFromKnowledgeBase: '从知识库中移除',
+      removeFromKnowledgeBaseSuccess: '文件移除成功',
+    },
+    bottom: '已经到底啦',
+    config: {
+      showFilesInKnowledgeBase: '显示知识库中内容',
+    },
+    emptyStatus: {
+      actions: {
+        file: '上传文件',
+        folder: '上传文件夹',
+        knowledgeBase: '新建知识库',
+      },
+      or: '或者',
+      title: '将文件或文件夹拖到这里',
+    },
+    title: {
+      createdAt: '创建时间',
+      size: '大小',
+      title: '文件',
+    },
+    total: {
+      fileCount: '共 {{count}} 项',
+      selectedCount: '已选 {{count}} 项',
+    },
+  },
+  FileParsingStatus: {
+    chunks: {
+      embeddingStatus: {
+        empty: '文本块尚未完全向量化，将导致语义检索功能不可用，为提升检索质量，请对文本块向量化',
+        processing: '文本块正在向量化，请耐心等待',
+        success: '当前文本块均已向量化',
+      },
+      embeddings: '向量化',
+      status: {
+        error: '分块失败',
+        errorResult: '分块失败，请检查后重试。失败原因：',
+        processing: '分块中',
+        processingTip: '服务端正在拆分文本块，关闭页面不影响分块进度',
+      },
+    },
+  },
+  GoBack: {
+    back: '返回',
+  },
   ModelSelect: {
     featureTag: {
       custom: '自定义模型，默认设定同时支持函数调用与视觉识别，请根据实际情况验证上述能力的可用性',

package/src/locales/default/setting.ts

@@ -375,6 +375,11 @@ export default {
       modelDesc: '指定用于生成助理名称、描述、头像、标签的模型',
       title: '自动生成助理信息',
     },
+    queryRewrite: {
+      label: '提问重写模型',
+      modelDesc: '指定用于优化用户提问的模型',
+      title: '知识库',
+    },
     title: '系统助手',
     topic: {
       label: '话题命名模型',

package/src/store/file/initialState.ts

@@ -1,4 +1,4 @@
-import { ImageFileState, initialImageFileState } from './slices/images';
+import { ImageFileState, initialImageFileState } from './slices/chat';
 
 export type FilesStoreState = ImageFileState;
 

package/src/store/file/selectors.ts

@@ -1,4 +1,4 @@
-import { filesSelectors as imageFilesSelectors } from './slices/images';
+import { filesSelectors as imageFilesSelectors } from './slices/chat';
 import { ttsFilesSelectors } from './slices/tts';
 
 export const filesSelectors = {

package/src/store/file/store.ts

@@ -4,7 +4,7 @@ import { StateCreator } from 'zustand/vanilla';
 
 import { createDevtools } from '../middleware/createDevtools';
 import { FilesStoreState, initialState } from './initialState';
-import { FileAction, createFileSlice } from './slices/images';
+import { FileAction, createFileSlice } from './slices/chat';
 import { TTSFileAction, createTTSFileSlice } from './slices/tts';
 
 //  ===============  聚合 createStoreFn ============ //

package/src/store/global/initialState.ts

@@ -5,6 +5,7 @@ import { AsyncLocalStorage } from '@/utils/localStorage';
 
 export enum SidebarTabKey {
   Chat = 'chat',
+  Files = 'files',
   Market = 'market',
   Me = 'me',
   Setting = 'settings',
@@ -32,12 +33,14 @@ export enum SettingsTabs {
 export interface SystemStatus {
   // which sessionGroup should expand
   expandSessionGroupKeys: string[];
+  filePanelWidth: number;
   hidePWAInstaller?: boolean;
   inputHeight: number;
   mobileShowPortal?: boolean;
   mobileShowTopic?: boolean;
   sessionsWidth: number;
   showChatSideBar?: boolean;
+  showFilePanel?: boolean;
   showSessionPanel?: boolean;
   showSystemRole?: boolean;
 }
@@ -55,11 +58,13 @@ export interface GlobalState {
 
 export const INITIAL_STATUS = {
   expandSessionGroupKeys: [SessionDefaultGroup.Pinned, SessionDefaultGroup.Default],
+  filePanelWidth: 320,
   hidePWAInstaller: false,
   inputHeight: 200,
   mobileShowTopic: false,
   sessionsWidth: 320,
   showChatSideBar: true,
+  showFilePanel: true,
   showSessionPanel: true,
   showSystemRole: false,
 } satisfies SystemStatus;

package/src/store/global/selectors.ts

@@ -10,12 +10,15 @@ const mobileShowTopic = (s: GlobalStore) => s.status.mobileShowTopic;
 const mobileShowPortal = (s: GlobalStore) => s.status.mobileShowPortal;
 const showChatSideBar = (s: GlobalStore) => s.status.showChatSideBar;
 const showSessionPanel = (s: GlobalStore) => s.status.showSessionPanel;
+const showFilePanel = (s: GlobalStore) => s.status.showFilePanel;
 const hidePWAInstaller = (s: GlobalStore) => s.status.hidePWAInstaller;
 
 const sessionWidth = (s: GlobalStore) => s.status.sessionsWidth;
+const filePanelWidth = (s: GlobalStore) => s.status.filePanelWidth;
 const inputHeight = (s: GlobalStore) => s.status.inputHeight;
 
 export const systemStatusSelectors = {
+  filePanelWidth,
   hidePWAInstaller,
   inputHeight,
   mobileShowPortal,
@@ -23,6 +26,7 @@ export const systemStatusSelectors = {
   sessionGroupKeys,
   sessionWidth,
   showChatSideBar,
+  showFilePanel,
   showSessionPanel,
   showSystemRole,
 };

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

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

package/src/types/user/index.ts

@@ -1,4 +1,5 @@
 import { DeepPartial } from 'utility-types';
+import { z } from 'zod';
 
 import { UserSettings } from '@/types/user/settings';
 
@@ -12,17 +13,24 @@ export interface LobeUser {
   username?: string | null;
 }
 
-export interface UserGuide {
+export const UserGuideSchema = z.object({
   /**
    * Move the settings button to the avatar dropdown
    */
-  moveSettingsToAvatar?: boolean;
+  moveSettingsToAvatar: z.boolean().optional(),
 
   /**
    * Topic Guide
    */
-  topic?: boolean;
-}
+  topic: z.boolean().optional(),
+
+  /**
+   * tell user that uploaded files can be found in knowledge base
+   */
+  uploadFileInKnowledgeBase: z.boolean().optional(),
+});
+
+export type UserGuide = z.infer<typeof UserGuideSchema>;
 
 export interface UserPreference {
   guide?: UserGuide;

package/src/types/user/settings/systemAgent.ts

@@ -5,6 +5,7 @@ export interface SystemAgentItem {
 
 export interface UserSystemAgentConfig {
   agentMeta: SystemAgentItem;
+  queryRewrite: SystemAgentItem;
   topic: SystemAgentItem;
   translation: SystemAgentItem;
 }

package/src/utils/colorUtils.ts

@@ -0,0 +1,19 @@
+import chroma from 'chroma-js';
+
+export const convertAlphaToSolid = (foreground: string, background: string): string => {
+  const fgColor = chroma(foreground);
+  const bgColor = chroma(background);
+
+  const alpha = fgColor.alpha();
+  const alphaComplement = 1 - alpha;
+
+  const mixedColor = [
+    fgColor.get('rgb.r') * alpha + bgColor.get('rgb.r') * alphaComplement,
+    fgColor.get('rgb.g') * alpha + bgColor.get('rgb.g') * alphaComplement,
+    fgColor.get('rgb.b') * alpha + bgColor.get('rgb.b') * alphaComplement,
+  ];
+
+  const resultColor = chroma(mixedColor);
+
+  return resultColor.hex();
+};

package/src/utils/sleep.ts

@@ -0,0 +1,4 @@
+export const sleep = async (ms: number) =>
+  await new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });