@lobehub/chat 0.100.5 → 0.101.0

package/src/database/core/__tests__/db.test.ts

@@ -0,0 +1,77 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
+import { DBModel } from '@/types/database/db';
+import { LocalFile } from '@/types/database/files';
+
+import { LocalDB } from '../db';
+
+describe('LocalDB', () => {
+  let db: LocalDB;
+
+  beforeEach(() => {
+    db = new LocalDB();
+  });
+
+  afterEach(async () => {
+    await db.delete();
+    db.close();
+  });
+
+  it('should be instantiated with the correct schema', () => {
+    const filesTable = db.files;
+
+    expect(filesTable).toBeDefined();
+  });
+
+  it('should allow adding a file', async () => {
+    const file: DBModel<LocalFile> = {
+      id: 'file1',
+      name: 'testfile.txt',
+      data: new ArrayBuffer(3),
+      saveMode: 'local',
+      fileType: 'plain/text',
+      size: 3,
+      createdAt: Date.now(),
+    };
+
+    await db.files.add(file);
+
+    expect(await db.files.get(file.id)).toEqual(file);
+  });
+
+  it('should allow updating a file', async () => {
+    const file: DBModel<LocalFile> = {
+      id: 'file1',
+      name: 'testfile.txt',
+      data: new ArrayBuffer(3),
+      saveMode: 'local',
+      fileType: 'plain/text',
+      size: 3,
+      createdAt: Date.now(),
+    };
+    await db.files.add(file);
+
+    // Act
+    await db.files.update(file.id, { name: 'update.txt' });
+
+    // Assert
+    expect(await db.files.get(file.id)).toHaveProperty('name', 'update.txt');
+  });
+
+  it('should allow deleting a file', async () => {
+    const file: DBModel<LocalFile> = {
+      id: 'file1',
+      name: 'testfile.txt',
+      data: new ArrayBuffer(3),
+      saveMode: 'local',
+      fileType: 'plain/text',
+      size: 3,
+      createdAt: Date.now(),
+    };
+    await db.files.add(file);
+
+    await db.files.delete(file.id);
+
+    expect(await db.files.get(file.id)).toBeUndefined();
+  });
+});

package/src/database/core/__tests__/model.test.ts

@@ -0,0 +1,55 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { ZodSchema, z } from 'zod';
+
+import { BaseModel } from '../model';
+
+// Define a mock schema for testing
+const mockSchema = z.object({
+  name: z.string(),
+  content: z.string(),
+});
+
+// Define a mock table name
+const mockTableName = 'files';
+
+describe('BaseModel', () => {
+  let baseModel: BaseModel<typeof mockTableName>;
+
+  beforeEach(() => {
+    baseModel = new BaseModel(mockTableName, mockSchema);
+    // Mock the console.error to test error logging
+    vi.spyOn(console, 'error').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    // console.error = originalConsoleError;
+  });
+
+  it('should have a table property', () => {
+    expect(baseModel.table).toBeDefined();
+  });
+
+  describe('add method', () => {
+    it('should add a valid record to the database', async () => {
+      const validData = {
+        name: 'testfile.txt',
+        content: 'Hello, World!',
+      };
+
+      const result = await baseModel['add'](validData);
+
+      expect(result).toHaveProperty('id');
+      expect(console.error).not.toHaveBeenCalled();
+    });
+
+    it('should throw an error and log to console when adding an invalid record', async () => {
+      const invalidData = {
+        name: 123, // Invalid type, should be a string
+        content: 'Hello, World!',
+      };
+
+      await expect(baseModel['add'](invalidData)).rejects.toThrow(TypeError);
+    });
+  });
+});

package/src/database/core/db.ts

@@ -0,0 +1,25 @@
+import Dexie from 'dexie';
+
+import { LobeDBSchemaMap as SchemaMap, lobeDBSchema } from '@/database/core/schema';
+import { DBModel } from '@/types/database/db';
+
+export type LocalDBSchema = {
+  [t in keyof SchemaMap]: {
+    model: SchemaMap[t];
+    table: Dexie.Table<DBModel<SchemaMap[t]>, string>;
+  };
+};
+
+// Define a local DB
+export class LocalDB extends Dexie {
+  public files: LocalDBSchema['files']['table'];
+
+  constructor() {
+    super('LOBE_CHAT_DB');
+    this.version(1).stores(lobeDBSchema);
+
+    this.files = this.table('files');
+  }
+}
+
+export const LocalDBInstance = new LocalDB();

package/src/database/core/index.ts

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

package/src/database/core/model.ts

@@ -0,0 +1,49 @@
+import { ZodSchema } from 'zod';
+
+import { DBModel } from '@/types/database/db';
+import { LocalFile } from '@/types/database/files';
+import { nanoid } from '@/utils/uuid';
+
+import { LocalDB, LocalDBInstance, LocalDBSchema } from './db';
+
+export class BaseModel<N extends keyof LocalDBSchema = any> {
+  private readonly db: LocalDB;
+  private readonly schema: ZodSchema;
+  private readonly _tableName: keyof LocalDBSchema;
+
+  constructor(table: N, schema: ZodSchema, db = LocalDBInstance) {
+    this.db = db;
+    this.schema = schema;
+    this._tableName = table;
+  }
+
+  get table() {
+    return this.db[this._tableName];
+  }
+
+  /**
+   * create a new record
+   * @param data
+   * @param id
+   */
+  protected async add<T = LocalDBSchema[N]['model']>(data: T, id: string | number = nanoid()) {
+    const result = this.schema.safeParse(data);
+
+    if (!result.success) {
+      const errorMsg = `[${this.db.name}][${this._tableName}] Failed to create new record. Error: ${result.error}`;
+
+      const newError = new TypeError(errorMsg);
+      // make this error show on console to help debug
+      console.error(newError);
+      throw newError;
+    }
+
+    const tableName = this._tableName;
+
+    const record: DBModel<LocalFile> = { ...result.data, createdAt: Date.now(), id };
+
+    const newId = await this.db[tableName].add(record);
+
+    return { id: newId };
+  }
+}

package/src/database/core/schema.ts

@@ -0,0 +1,9 @@
+import { LocalFile } from '@/types/database/files';
+
+export const lobeDBSchema = {
+  files: '&id, name, fileType, saveMode',
+};
+
+export interface LobeDBSchemaMap {
+  files: LocalFile;
+}

package/src/database/models/file.test.ts

@@ -0,0 +1,71 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { LocalFile } from '@/types/database/files';
+
+import { LocalDB } from '../core/db';
+import { FileModel } from './file';
+
+// Assuming LocalDB is already mocked or using an in-memory database
+// and LocalFileSchema has been imported correctly.
+
+describe('_FileModel', () => {
+  let fileData: LocalFile;
+
+  beforeEach(() => {
+    // Set up file data with the correct structure according to LocalFileSchema
+    fileData = {
+      data: new ArrayBuffer(10),
+      fileType: 'image/png',
+      name: 'test.png',
+      saveMode: 'local',
+      size: 10,
+      // url is optional, only needed if saveMode is 'url'
+    };
+  });
+
+  afterEach(async () => {
+    // Clean up the database after each test
+    const db = new LocalDB();
+    await db.files.clear();
+    db.close();
+  });
+
+  it('should create a file record', async () => {
+    // First, create a file to test the create method
+    const fileData: LocalFile = {
+      data: new ArrayBuffer(10),
+      fileType: 'image/png',
+      name: 'test.png',
+      saveMode: 'local',
+      size: 10,
+    };
+
+    const result = await FileModel.create(fileData);
+
+    expect(result).toHaveProperty('id');
+    expect(result.id).toMatch(/^file-/);
+
+    // Verify that the file has been added to the database
+    const fileInDb = await FileModel.findById(result.id);
+
+    expect(fileInDb).toEqual(expect.objectContaining(fileData));
+  });
+
+  it('should find a file by id', async () => {
+    // First, create a file to test the findById method
+    const createdFile = await FileModel.create(fileData);
+    const foundFile = await FileModel.findById(createdFile.id);
+
+    expect(foundFile).toEqual(expect.objectContaining(fileData));
+  });
+
+  it('should delete a file by id', async () => {
+    // First, create a file to test the delete method
+    const createdFile = await FileModel.create(fileData);
+    await FileModel.delete(createdFile.id);
+
+    // Verify that the file has been removed from the database
+    const fileInDb = await FileModel.findById(createdFile.id);
+    expect(fileInDb).toBeUndefined();
+  });
+});

package/src/database/models/file.ts

@@ -0,0 +1,26 @@
+import { LocalFile, LocalFileSchema } from '@/types/database/files';
+import { nanoid } from '@/utils/uuid';
+
+import { BaseModel } from '../core';
+
+class _FileModel extends BaseModel {
+  constructor() {
+    super('files', LocalFileSchema);
+  }
+
+  async create(file: LocalFile) {
+    const id = nanoid();
+
+    return this.add(file, `file-${id}`);
+  }
+
+  async findById(id: string) {
+    return this.table.get(id);
+  }
+
+  async delete(id: string) {
+    return this.table.delete(id);
+  }
+}
+
+export const FileModel = new _FileModel();

package/src/locales/default/chat.ts

@@ -62,5 +62,10 @@ export default {
   },
   translateTo: '翻译',
   updateAgent: '更新助理信息',
+  upload: {
+    actionTooltip: '上传图片',
+    dragDesc: '拖拽文件到这里，支持上传多个图片。按住 Shift 直接发送图片',
+    dragTitle: '上传图片',
+  },
   warp: '换行',
 };

package/src/services/__tests__/file.test.ts

@@ -0,0 +1,88 @@
+import { Mock, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { FileModel } from '@/database/models/file';
+import { LocalFile } from '@/types/database/files';
+
+import { fileService } from '../file';
+
+// Mocks for the FileModel
+vi.mock('@/database/models/file', () => ({
+  FileModel: {
+    create: vi.fn(),
+    delete: vi.fn(),
+    findById: vi.fn(),
+  },
+}));
+
+// Mocks for the URL and Blob objects
+global.URL.createObjectURL = vi.fn();
+global.Blob = vi.fn();
+
+describe('FileService', () => {
+  beforeEach(() => {
+    // Reset all mocks before each test
+    vi.resetAllMocks();
+  });
+
+  it('uploadFile should save the file to the database', async () => {
+    const localFile: LocalFile = {
+      name: 'test',
+      data: new ArrayBuffer(1),
+      fileType: 'image/png',
+      saveMode: 'local',
+      size: 1,
+    };
+
+    (FileModel.create as Mock).mockResolvedValue(localFile);
+
+    const result = await fileService.uploadFile(localFile);
+
+    expect(FileModel.create).toHaveBeenCalledWith(localFile);
+    expect(result).toEqual(localFile);
+  });
+
+  it('removeFile should delete the file from the database', async () => {
+    const fileId = '1';
+    (FileModel.delete as Mock).mockResolvedValue(true);
+
+    const result = await fileService.removeFile(fileId);
+
+    expect(FileModel.delete).toHaveBeenCalledWith(fileId);
+    expect(result).toBe(true);
+  });
+
+  it('getFile should retrieve and convert file info to FilePreview', async () => {
+    const fileId = '1';
+    const fileData: LocalFile = {
+      name: 'test',
+      data: new ArrayBuffer(1),
+      fileType: 'image/png',
+      saveMode: 'local',
+      size: 1,
+    };
+
+    (FileModel.findById as Mock).mockResolvedValue(fileData);
+    (global.URL.createObjectURL as Mock).mockReturnValue('blob:test');
+    (global.Blob as Mock).mockImplementation(() => ['test']);
+
+    const result = await fileService.getFile(fileId);
+
+    expect(FileModel.findById).toHaveBeenCalledWith(fileId);
+    expect(result).toEqual({
+      base64Url: 'data:image/png;base64,AA==',
+      fileType: 'image/png',
+      name: 'test',
+      saveMode: 'local',
+      url: 'blob:test',
+    });
+  });
+
+  it('getFile should throw an error when the file is not found', async () => {
+    const fileId = 'non-existent';
+    (FileModel.findById as Mock).mockResolvedValue(null);
+
+    const getFilePromise = fileService.getFile(fileId);
+
+    await expect(getFilePromise).rejects.toThrow('file not found');
+  });
+});

package/src/services/chatModel.ts

@@ -1,8 +1,9 @@
 import { merge } from 'lodash-es';
 
+import { VISION_MODEL_WHITE_LIST } from '@/const/llm';
 import { pluginSelectors, usePluginStore } from '@/store/plugin';
 import { initialLobeAgentConfig } from '@/store/session/initialState';
-import type { ChatCompletionFunctions, OpenAIChatStreamPayload } from '@/types/openai/chat';
+import type { OpenAIChatStreamPayload } from '@/types/openai/chat';
 
 import { createHeaderWithOpenAI } from './_header';
 import { OPENAI_URLS } from './_url';
@@ -26,13 +27,17 @@ export const fetchChatModel = (
     },
     params,
   );
-  // ============  1. 前置处理 functions   ============ //
+  // ============   preprocess tools   ============ //
 
-  const filterFunctions: ChatCompletionFunctions[] = pluginSelectors.enabledSchema(enabledPlugins)(
-    usePluginStore.getState(),
-  );
+  const filterTools = pluginSelectors.enabledSchema(enabledPlugins)(usePluginStore.getState());
+
+  // the rule that model can use tools:
+  // 1. tools is not empty
+  // 2. model is not in vision white list, because vision model can't use tools
+  // TODO: we need to find some method to let vision model use tools
+  const shouldUseTools = filterTools.length > 0 && !VISION_MODEL_WHITE_LIST.includes(payload.model);
 
-  const functions = filterFunctions.length === 0 ? undefined : filterFunctions;
+  const functions = shouldUseTools ? filterTools : undefined;
 
   return fetch(OPENAI_URLS.chat, {
     body: JSON.stringify({ ...payload, functions }),

package/src/services/file.ts

@@ -0,0 +1,36 @@
+import { FileModel } from '@/database/models/file';
+import { LocalFile } from '@/types/database/files';
+import { FilePreview } from '@/types/files';
+
+class FileService {
+  async uploadFile(file: LocalFile) {
+    // save to local storage
+    // we may want to save to a remote server later
+    return FileModel.create(file);
+  }
+
+  async removeFile(id: string) {
+    return FileModel.delete(id);
+  }
+
+  async getFile(id: string): Promise<FilePreview> {
+    const item = await FileModel.findById(id);
+    if (!item) {
+      throw new Error('file not found');
+    }
+
+    // arrayBuffer to url
+    const url = URL.createObjectURL(new Blob([item.data]));
+    const base64 = Buffer.from(item.data).toString('base64');
+
+    return {
+      base64Url: `data:${item.fileType};base64,${base64}`,
+      fileType: item.fileType,
+      name: item.name,
+      saveMode: 'local',
+      url,
+    };
+  }
+}
+
+export const fileService = new FileService();

package/src/store/files/index.ts

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

package/src/store/files/initialState.ts

@@ -0,0 +1,7 @@
+import { ImageFileState, initialImageFileState } from './slices/images';
+
+export type FilesStoreState = ImageFileState;
+
+export const initialState: FilesStoreState = {
+  ...initialImageFileState,
+};

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

@@ -0,0 +1,75 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+
+import { FilesStoreState } from './initialState';
+import { filesSelectors } from './selectors';
+
+describe('filesSelectors', () => {
+  let state: FilesStoreState;
+
+  beforeEach(() => {
+    // 创建并初始化 state 的模拟实例
+    state = {
+      imagesMap: {
+        '1': {
+          name: 'a',
+          fileType: 'image/png',
+          saveMode: 'local',
+          base64Url: 'base64string1',
+          url: 'blob:abc',
+        },
+        '2': {
+          name: 'b',
+          fileType: 'image/png',
+          saveMode: 'url',
+          base64Url: 'base64string2',
+          url: 'url2',
+        },
+      },
+      // 假设 '3' 是不存在的 ID
+      inputFilesList: ['1', '2', '3'],
+    };
+  });
+
+  it('getImageDetailByList should return details for the provided list of image IDs', () => {
+    const list = ['1', '2'];
+    const details = filesSelectors.getImageDetailByList(list)(state);
+    expect(details.length).toBe(2);
+    expect(details[0].name).toBe('a');
+    expect(details[1].name).toBe('b');
+  });
+
+  it('imageDetailList should return details for the images in the inputFilesList', () => {
+    const details = filesSelectors.imageDetailList(state);
+    // '3' should be filtered due to not exist in map
+    expect(details.length).toBe(2);
+  });
+
+  it('getImageUrlOrBase64ById should return the correct URL or Base64 based on saveMode', () => {
+    const localImage = filesSelectors.getImageUrlOrBase64ById('1')(state);
+    expect(localImage).toEqual({ id: '1', url: 'base64string1' });
+
+    const serverImage = filesSelectors.getImageUrlOrBase64ById('2')(state);
+    expect(serverImage).toEqual({ id: '2', url: 'url2' });
+
+    const nonExistentImage = filesSelectors.getImageUrlOrBase64ById('3')(state);
+    expect(nonExistentImage).toBeUndefined();
+  });
+
+  it('getImageUrlOrBase64ByList should return the correct list of URLs or Base64 strings', () => {
+    const list = ['1', '2', '3'];
+    const urlsOrBase64s = filesSelectors.getImageUrlOrBase64ByList(list)(state);
+    expect(urlsOrBase64s.length).toBe(2); // '3' 应该被过滤掉，因为它不存在
+    expect(urlsOrBase64s[0].url).toBe('base64string1');
+    expect(urlsOrBase64s[1].url).toBe('url2');
+  });
+
+  it('imageUrlOrBase64List should return a list of image URLs or Base64 strings for all images in inputFilesList', () => {
+    const urlsOrBase64s = filesSelectors.imageUrlOrBase64List(state);
+    expect(urlsOrBase64s.length).toBe(2); // '3' 是不存在的 ID，所以应该被过滤掉
+
+    expect(urlsOrBase64s).toEqual([
+      { id: '1', url: 'base64string1' }, // 本地保存的图像应该使用 base64 URL
+      { id: '2', url: 'url2' }, // 服务器保存的图像应该使用普通 URL
+    ]);
+  });
+});

package/src/store/files/selectors.ts

@@ -0,0 +1,34 @@
+import { FilesStoreState } from './initialState';
+
+const getImageDetailByList = (list: string[]) => (s: FilesStoreState) =>
+  list.map((i) => s.imagesMap[i]).filter(Boolean);
+
+const imageDetailList = (s: FilesStoreState) => getImageDetailByList(s.inputFilesList)(s);
+
+const getImageUrlOrBase64ById =
+  (id: string) =>
+  (s: FilesStoreState): { id: string; url: string } | undefined => {
+    const preview = s.imagesMap[id];
+
+    if (!preview) return undefined;
+
+    const url = preview.saveMode === 'local' ? (preview.base64Url as string) : preview.url;
+
+    return { id, url: url };
+  };
+
+const getImageUrlOrBase64ByList = (idList: string[]) => (s: FilesStoreState) =>
+  idList.map((i) => getImageUrlOrBase64ById(i)(s)).filter(Boolean) as {
+    id: string;
+    url: string;
+  }[];
+
+const imageUrlOrBase64List = (s: FilesStoreState) => getImageUrlOrBase64ByList(s.inputFilesList)(s);
+
+export const filesSelectors = {
+  getImageDetailByList,
+  getImageUrlOrBase64ById,
+  getImageUrlOrBase64ByList,
+  imageDetailList,
+  imageUrlOrBase64List,
+};