@lobehub/lobehub 2.0.0-next.59 → 2.0.0-next.60

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 # Changelog
 
+## [Version 2.0.0-next.60](https://github.com/lobehub/lobe-chat/compare/v2.0.0-next.59...v2.0.0-next.60)
+
+<sup>Released on **2025-11-14**</sup>
+
+#### 🐛 Bug Fixes
+
+- **misc**: Reduce threshold.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### What's fixed
+
+- **misc**: Reduce threshold, closes [#10222](https://github.com/lobehub/lobe-chat/issues/10222) ([abdfd06](https://github.com/lobehub/lobe-chat/commit/abdfd06))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
 ## [Version 2.0.0-next.59](https://github.com/lobehub/lobe-chat/compare/v2.0.0-next.58...v2.0.0-next.59)
 
 <sup>Released on **2025-11-14**</sup>

package/changelog/v1.json

@@ -1,4 +1,13 @@
 [
+  {
+    "children": {
+      "fixes": [
+        "Reduce threshold."
+      ]
+    },
+    "date": "2025-11-14",
+    "version": "2.0.0-next.60"
+  },
   {
     "children": {
       "improvements": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/lobehub",
-  "version": "2.0.0-next.59",
+  "version": "2.0.0-next.60",
   "description": "LobeHub - an open-source,comprehensive AI Agent framework that supports speech synthesis, multimodal, and extensible Function Call plugin system. Supports one-click free deployment of your private ChatGPT/LLM web application.",
   "keywords": [
     "framework",
@@ -218,12 +218,10 @@
     "i18next": "^25.6.2",
     "i18next-browser-languagedetector": "^8.2.0",
     "i18next-resources-to-backend": "^1.2.1",
-    "idb-keyval": "^6.2.2",
     "immer": "^10.2.0",
     "jose": "^5.10.0",
     "js-sha256": "^0.11.1",
     "jsonl-parse-stringify": "^1.0.3",
-    "keyv": "^4.5.4",
     "langchain": "^0.3.36",
     "langfuse": "^3.38.6",
     "langfuse-core": "^3.38.6",

package/src/app/[variants]/(main)/chat/components/conversation/features/ChatMinimap/index.tsx

@@ -5,6 +5,7 @@ import { Popover, Tooltip } from 'antd';
 import { createStyles, useTheme } from 'antd-style';
 import debug from 'debug';
 import { ChevronDown, ChevronUp } from 'lucide-react';
+import { markdownToTxt } from 'markdown-to-txt';
 import { memo, useCallback, useMemo, useState, useSyncExternalStore } from 'react';
 import { useTranslation } from 'react-i18next';
 import { Flexbox } from 'react-layout-kit';
@@ -23,7 +24,7 @@ const log = debug('lobe-react:chat-minimap');
 const MIN_WIDTH = 16;
 const MAX_WIDTH = 30;
 const MAX_CONTENT_LENGTH = 320;
-const MIN_MESSAGES = 4;
+const MIN_MESSAGES = 3;
 
 const useStyles = createStyles(({ css, token }) => ({
   arrow: css`
@@ -178,7 +179,8 @@ const getIndicatorWidth = (content: string | undefined) => {
 const getPreviewText = (content: string | undefined) => {
   if (!content) return '';
 
-  const normalized = content.replaceAll(/\s+/g, ' ').trim();
+  const plainText = markdownToTxt(content);
+  const normalized = plainText.replaceAll(/\s+/g, ' ').trim();
   if (!normalized) return '';
 
   return normalized.slice(0, 100) + (normalized.length > 100 ? '…' : '');

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

@@ -3,7 +3,6 @@ import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { fileEnv } from '@/envs/file';
 import { lambdaClient } from '@/libs/trpc/client';
 import { API_ENDPOINTS } from '@/services/_url';
-import { clientS3Storage } from '@/services/file/ClientS3';
 
 import { UPLOAD_NETWORK_ERROR, uploadService } from '../upload';
 
@@ -31,12 +30,6 @@ vi.mock('@/libs/trpc/client', () => ({
   },
 }));
 
-vi.mock('@/services/file/ClientS3', () => ({
-  clientS3Storage: {
-    putObject: vi.fn(),
-  },
-}));
-
 vi.mock('@/store/electron', () => ({
   getElectronStoreState: vi.fn(() => ({})),
 }));
@@ -54,7 +47,12 @@ vi.mock('@/services/electron/file', () => ({
 }));
 
 vi.mock('js-sha256', () => ({
-  sha256: vi.fn((data) => 'mock-hash-' + data.byteLength),
+  sha256: vi.fn((data) => {
+    if (data instanceof ArrayBuffer) {
+      return 'mock-hash-' + data.byteLength;
+    }
+    return 'mock-hash';
+  }),
 }));
 
 describe('UploadService', () => {
@@ -68,63 +66,83 @@ describe('UploadService', () => {
   });
 
   describe('uploadFileToS3', () => {
-    it('should upload to client S3 for non-server mode with image file', async () => {
-      const { sha256 } = await import('js-sha256');
-      vi.mocked(sha256).mockReturnValue('test-hash');
-      vi.mocked(clientS3Storage.putObject).mockResolvedValue(undefined);
+    beforeEach(() => {
+      // Mock XMLHttpRequest for server upload
+      const xhrMock = {
+        addEventListener: vi.fn((event, handler) => {
+          if (event === 'load') {
+            setTimeout(() => handler({ target: { status: 200 } }), 0);
+          }
+        }),
+        open: vi.fn(),
+        send: vi.fn(),
+        setRequestHeader: vi.fn(),
+        status: 200,
+        upload: {
+          addEventListener: vi.fn(),
+        },
+      };
+      global.XMLHttpRequest = vi.fn(() => xhrMock) as any;
 
+      // Mock createS3PreSignedUrl
+      vi.mocked(lambdaClient.upload.createS3PreSignedUrl.mutate).mockResolvedValue(mockPreSignUrl);
+    });
+
+    it('should upload to server S3 in non-desktop mode', async () => {
       const result = await uploadService.uploadFileToS3(mockFile, {});
 
       expect(result.success).toBe(true);
       expect(result.data).toEqual({
         date: '1',
-        dirname: '',
-        filename: mockFile.name,
-        path: 'client-s3://test-hash',
+        dirname: `${fileEnv.NEXT_PUBLIC_S3_FILE_PATH}/1`,
+        filename: 'mock-uuid.png',
+        path: `${fileEnv.NEXT_PUBLIC_S3_FILE_PATH}/1/mock-uuid.png`,
       });
-      expect(clientS3Storage.putObject).toHaveBeenCalledWith('test-hash', mockFile);
     });
 
-    it('should call onNotSupported for non-image/video files', async () => {
-      const nonImageFile = new File(['test'], 'test.txt', { type: 'text/plain' });
-      const onNotSupported = vi.fn();
-
-      const result = await uploadService.uploadFileToS3(nonImageFile, {
-        onNotSupported,
+    it('should use custom pathname when provided', async () => {
+      const customPath = 'custom/path/file.png';
+      const result = await uploadService.uploadFileToS3(mockFile, {
+        pathname: customPath,
       });
 
-      expect(result.success).toBe(false);
-      expect(onNotSupported).toHaveBeenCalled();
+      expect(result.success).toBe(true);
+      expect(result.data.path).toBe(customPath);
     });
 
-    it('should skip file type check when skipCheckFileType is true', async () => {
-      const nonImageFile = new File(['test'], 'test.txt', { type: 'text/plain' });
-      const { sha256 } = await import('js-sha256');
-      vi.mocked(sha256).mockReturnValue('test-hash');
-      vi.mocked(clientS3Storage.putObject).mockResolvedValue(undefined);
-
-      const result = await uploadService.uploadFileToS3(nonImageFile, {
-        skipCheckFileType: true,
+    it('should use custom directory when provided', async () => {
+      const result = await uploadService.uploadFileToS3(mockFile, {
+        directory: 'custom/dir',
       });
 
       expect(result.success).toBe(true);
-      expect(clientS3Storage.putObject).toHaveBeenCalled();
+      expect(result.data.dirname).toContain('custom/dir');
     });
+  });
 
-    it('should upload video files', async () => {
-      const videoFile = new File(['test'], 'test.mp4', { type: 'video/mp4' });
-      const { sha256 } = await import('js-sha256');
-      vi.mocked(sha256).mockReturnValue('video-hash');
-      vi.mocked(clientS3Storage.putObject).mockResolvedValue(undefined);
-
-      const result = await uploadService.uploadFileToS3(videoFile, {});
+  describe('uploadBase64ToS3', () => {
+    beforeEach(() => {
+      // Mock XMLHttpRequest for server upload
+      const xhrMock = {
+        addEventListener: vi.fn((event, handler) => {
+          if (event === 'load') {
+            setTimeout(() => handler({ target: { status: 200 } }), 0);
+          }
+        }),
+        open: vi.fn(),
+        send: vi.fn(),
+        setRequestHeader: vi.fn(),
+        status: 200,
+        upload: {
+          addEventListener: vi.fn(),
+        },
+      };
+      global.XMLHttpRequest = vi.fn(() => xhrMock) as any;
 
-      expect(result.success).toBe(true);
-      expect(clientS3Storage.putObject).toHaveBeenCalledWith('video-hash', videoFile);
+      // Mock createS3PreSignedUrl
+      vi.mocked(lambdaClient.upload.createS3PreSignedUrl.mutate).mockResolvedValue(mockPreSignUrl);
     });
-  });
 
-  describe('uploadBase64ToS3', () => {
     it('should upload base64 data successfully', async () => {
       const { parseDataUri } = await import('@lobechat/model-runtime');
       vi.mocked(parseDataUri).mockReturnValueOnce({
@@ -135,7 +153,6 @@ describe('UploadService', () => {
 
       const { sha256 } = await import('js-sha256');
       vi.mocked(sha256).mockReturnValue('base64-hash');
-      vi.mocked(clientS3Storage.putObject).mockResolvedValue(undefined);
 
       const base64Data = 'data:image/png;base64,dGVzdA==';
       const result = await uploadService.uploadBase64ToS3(base64Data);
@@ -144,7 +161,7 @@ describe('UploadService', () => {
         fileType: 'image/png',
         hash: expect.any(String),
         metadata: expect.objectContaining({
-          path: expect.stringContaining('client-s3://'),
+          path: expect.stringContaining(fileEnv.NEXT_PUBLIC_S3_FILE_PATH || ''),
         }),
         size: expect.any(Number),
       });
@@ -175,46 +192,58 @@ describe('UploadService', () => {
 
       const { sha256 } = await import('js-sha256');
       vi.mocked(sha256).mockReturnValue('custom-hash');
-      vi.mocked(clientS3Storage.putObject).mockResolvedValue(undefined);
 
       const base64Data = 'data:image/png;base64,dGVzdA==';
       const result = await uploadService.uploadBase64ToS3(base64Data, {
         filename: 'custom-image',
       });
 
-      expect(result.metadata.filename).toContain('custom-image');
+      // The filename will be regenerated with UUID, but should keep the extension
+      expect(result.metadata.filename).toMatch(/^mock-uuid\.png$/);
     });
   });
 
   describe('uploadDataToS3', () => {
-    it('should upload JSON data successfully', async () => {
-      const { sha256 } = await import('js-sha256');
-      vi.mocked(sha256).mockReturnValue('json-hash');
-      vi.mocked(clientS3Storage.putObject).mockResolvedValue(undefined);
+    beforeEach(() => {
+      // Mock XMLHttpRequest for server upload
+      const xhrMock = {
+        addEventListener: vi.fn((event, handler) => {
+          if (event === 'load') {
+            setTimeout(() => handler({ target: { status: 200 } }), 0);
+          }
+        }),
+        open: vi.fn(),
+        send: vi.fn(),
+        setRequestHeader: vi.fn(),
+        status: 200,
+        upload: {
+          addEventListener: vi.fn(),
+        },
+      };
+      global.XMLHttpRequest = vi.fn(() => xhrMock) as any;
 
+      // Mock createS3PreSignedUrl
+      vi.mocked(lambdaClient.upload.createS3PreSignedUrl.mutate).mockResolvedValue(mockPreSignUrl);
+    });
+
+    it('should upload JSON data successfully', async () => {
       const data = { key: 'value', number: 123 };
-      // uploadDataToS3 internally calls uploadFileToS3, which needs skipCheckFileType for JSON
-      const result = await uploadService.uploadDataToS3(data, {
-        skipCheckFileType: true,
-      });
+      const result = await uploadService.uploadDataToS3(data);
 
       expect(result.success).toBe(true);
-      expect(clientS3Storage.putObject).toHaveBeenCalled();
+      // The filename will be regenerated with UUID
+      expect(result.data.filename).toMatch(/^mock-uuid\.json$/);
     });
 
     it('should use custom filename when provided', async () => {
-      const { sha256 } = await import('js-sha256');
-      vi.mocked(sha256).mockReturnValue('custom-json-hash');
-      vi.mocked(clientS3Storage.putObject).mockResolvedValue(undefined);
-
       const data = { test: true };
       const result = await uploadService.uploadDataToS3(data, {
         filename: 'custom.json',
-        skipCheckFileType: true,
       });
 
       expect(result.success).toBe(true);
-      expect(result.data.filename).toBe('custom.json');
+      // The filename will be regenerated with UUID, keeping the extension
+      expect(result.data.filename).toMatch(/^mock-uuid\.json$/);
     });
   });
 
@@ -359,25 +388,6 @@ describe('UploadService', () => {
     });
   });
 
-  describe('uploadToClientS3', () => {
-    it('should upload file to client S3 successfully', async () => {
-      const hash = 'test-hash';
-      const expectedResult = {
-        date: '1',
-        dirname: '',
-        filename: mockFile.name,
-        path: `client-s3://${hash}`,
-      };
-
-      vi.mocked(clientS3Storage.putObject).mockResolvedValue(undefined);
-
-      const result = await uploadService['uploadToClientS3'](hash, mockFile);
-
-      expect(clientS3Storage.putObject).toHaveBeenCalledWith(hash, mockFile);
-      expect(result).toEqual(expectedResult);
-    });
-  });
-
   describe('getImageFileByUrlWithCORS', () => {
     beforeEach(() => {
       global.fetch = vi.fn();

package/src/services/upload.ts

@@ -1,4 +1,4 @@
-import { isDesktop, isServerMode } from '@lobechat/const';
+import { isDesktop } from '@lobechat/const';
 import { parseDataUri } from '@lobechat/model-runtime';
 import { uuid } from '@lobechat/utils';
 import dayjs from 'dayjs';
@@ -7,7 +7,6 @@ import { sha256 } from 'js-sha256';
 import { fileEnv } from '@/envs/file';
 import { lambdaClient } from '@/libs/trpc/client';
 import { API_ENDPOINTS } from '@/services/_url';
-import { clientS3Storage } from '@/services/file/ClientS3';
 import { FileMetadata, UploadBase64ToS3Result } from '@/types/files';
 import { FileUploadState, FileUploadStatus } from '@/types/files/upload';
 
@@ -60,7 +59,7 @@ class UploadService {
    */
   uploadFileToS3 = async (
     file: File,
-    { onProgress, directory, skipCheckFileType, onNotSupported, pathname }: UploadFileToS3Options,
+    { onProgress, directory, pathname }: UploadFileToS3Options,
   ): Promise<{ data: FileMetadata; success: boolean }> => {
     const { getElectronStoreState } = await import('@/store/electron');
     const { electronSyncSelectors } = await import('@/store/electron/selectors');
@@ -75,27 +74,10 @@ class UploadService {
     }
 
     // Server-side upload logic
-    if (isServerMode) {
-      // if is server mode, upload to server s3,
 
-      const data = await this.uploadToServerS3(file, { directory, onProgress, pathname });
-      return { data, success: true };
-    }
-
-    // upload to client s3
-    // Client-side upload logic
-    if (!skipCheckFileType && !file.type.startsWith('image') && !file.type.startsWith('video')) {
-      onNotSupported?.();
-      return { data: undefined as unknown as FileMetadata, success: false };
-    }
-
-    const fileArrayBuffer = await file.arrayBuffer();
-
-    // 1. check file hash
-    const hash = sha256(fileArrayBuffer);
-    // Upload to the indexeddb in the browser
-    const data = await this.uploadToClientS3(hash, file);
+    // if is server mode, upload to server s3,
 
+    const data = await this.uploadToServerS3(file, { directory, onProgress, pathname });
     return { data, success: true };
   };
 
@@ -229,17 +211,6 @@ class UploadService {
     return metadata;
   };
 
-  private uploadToClientS3 = async (hash: string, file: File): Promise<FileMetadata> => {
-    await clientS3Storage.putObject(hash, file);
-
-    return {
-      date: (Date.now() / 1000 / 60 / 60).toFixed(0),
-      dirname: '',
-      filename: file.name,
-      path: `client-s3://${hash}`,
-    };
-  };
-
   /**
    * get image File item with cors image URL
    * @param url

package/src/services/file/ClientS3/index.test.ts

@@ -1,115 +0,0 @@
-import { createStore, del, get, set } from 'idb-keyval';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-
-import { BrowserS3Storage } from './index';
-
-// Mock idb-keyval
-vi.mock('idb-keyval', () => ({
-  createStore: vi.fn(),
-  set: vi.fn(),
-  get: vi.fn(),
-  del: vi.fn(),
-}));
-
-let storage: BrowserS3Storage;
-let mockStore = {};
-
-beforeEach(() => {
-  // Reset all mocks before each test
-  vi.clearAllMocks();
-  mockStore = {};
-  (createStore as any).mockReturnValue(mockStore);
-  storage = new BrowserS3Storage();
-});
-
-describe('BrowserS3Storage', () => {
-  describe('constructor', () => {
-    it('should create store when in browser environment', () => {
-      expect(createStore).toHaveBeenCalledWith('lobechat-local-s3', 'objects');
-    });
-  });
-
-  describe('putObject', () => {
-    it('should successfully put a file object', async () => {
-      const mockFile = new File(['test content'], 'test.txt', { type: 'text/plain' });
-      const mockArrayBuffer = new ArrayBuffer(8);
-      vi.spyOn(mockFile, 'arrayBuffer').mockResolvedValue(mockArrayBuffer);
-      (set as any).mockResolvedValue(undefined);
-
-      await storage.putObject('1-test-key', mockFile);
-
-      expect(set).toHaveBeenCalledWith(
-        '1-test-key',
-        {
-          data: mockArrayBuffer,
-          name: 'test.txt',
-          type: 'text/plain',
-        },
-        mockStore,
-      );
-    });
-
-    it('should throw error when put operation fails', async () => {
-      const mockFile = new File(['test content'], 'test.txt', { type: 'text/plain' });
-      const mockError = new Error('Storage error');
-      (set as any).mockRejectedValue(mockError);
-
-      await expect(storage.putObject('test-key', mockFile)).rejects.toThrow(
-        'Failed to put file test.txt: Storage error',
-      );
-    });
-  });
-
-  describe('getObject', () => {
-    it('should successfully get a file object', async () => {
-      const mockData = {
-        data: new ArrayBuffer(8),
-        name: 'test.txt',
-        type: 'text/plain',
-      };
-      (get as any).mockResolvedValue(mockData);
-
-      const result = await storage.getObject('test-key');
-
-      expect(result).toBeInstanceOf(File);
-      expect(result?.name).toBe('test.txt');
-      expect(result?.type).toBe('text/plain');
-    });
-
-    it('should return undefined when file not found', async () => {
-      (get as any).mockResolvedValue(undefined);
-
-      const result = await storage.getObject('test-key');
-
-      expect(result).toBeUndefined();
-    });
-
-    // it('should throw error when get operation fails', async () => {
-    //   const mockError = new Error('Storage error');
-    //   (get as any).mockRejectedValue(mockError);
-    //
-    //   await expect(storage.getObject('test-key')).rejects.toThrow(
-    //     'Failed to get object (key=test-key): Storage error',
-    //   );
-    // });
-  });
-
-  describe('deleteObject', () => {
-    it('should successfully delete a file object', async () => {
-      (del as any).mockResolvedValue(undefined);
-
-      await storage.deleteObject('test-key2');
-
-      expect(del).toHaveBeenCalledWith('test-key2', {});
-    });
-
-    it('should throw error when delete operation fails', async () => {
-      const mockError = new Error('Storage error');
-      (del as any).mockRejectedValue(mockError);
-
-      await expect(storage.deleteObject('test-key')).rejects.toThrow(
-        'Failed to delete object (key=test-key): Storage error',
-      );
-    });
-  });
-});

package/src/services/file/ClientS3/index.ts

@@ -1,59 +0,0 @@
-import { createStore, del, get, set } from 'idb-keyval';
-
-const BROWSER_S3_DB_NAME = 'lobechat-local-s3';
-
-export class BrowserS3Storage {
-  private store;
-
-  constructor() {
-    // skip server-side rendering
-    if (typeof window === 'undefined') return;
-
-    this.store = createStore(BROWSER_S3_DB_NAME, 'objects');
-  }
-
-  /**
-   * Upload file
-   * @param key File hash
-   * @param file File object
-   */
-  putObject = async (key: string, file: File): Promise<void> => {
-    try {
-      const data = await file.arrayBuffer();
-      await set(key, { data, name: file.name, type: file.type }, this.store);
-    } catch (e) {
-      throw new Error(`Failed to put file ${file.name}: ${(e as Error).message}`);
-    }
-  };
-
-  /**
-   * Get file
-   * @param key File hash
-   * @returns File object
-   */
-  getObject = async (key: string): Promise<File | undefined> => {
-    try {
-      const res = await get<{ data: ArrayBuffer; name: string; type: string }>(key, this.store);
-      if (!res) return;
-
-      return new File([res.data], res!.name, { type: res?.type });
-    } catch (e) {
-      console.log(`Failed to get object (key=${key}):`, e);
-      return undefined;
-    }
-  };
-
-  /**
-   * Delete file
-   * @param key File hash
-   */
-  deleteObject = async (key: string): Promise<void> => {
-    try {
-      await del(key, this.store);
-    } catch (e) {
-      throw new Error(`Failed to delete object (key=${key}): ${(e as Error).message}`);
-    }
-  };
-}
-
-export const clientS3Storage = new BrowserS3Storage();