@lobehub/lobehub 2.0.0-next.41 → 2.0.0-next.43

package/CHANGELOG.md

@@ -2,6 +2,56 @@
 
 # Changelog
 
+## [Version 2.0.0-next.43](https://github.com/lobehub/lobe-chat/compare/v2.0.0-next.42...v2.0.0-next.43)
+
+<sup>Released on **2025-11-09**</sup>
+
+#### 🐛 Bug Fixes
+
+- **misc**: Abnormal animation of tokens.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### What's fixed
+
+- **misc**: Abnormal animation of tokens, closes [#10106](https://github.com/lobehub/lobe-chat/issues/10106) ([129df7b](https://github.com/lobehub/lobe-chat/commit/129df7b))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
+## [Version 2.0.0-next.42](https://github.com/lobehub/lobe-chat/compare/v2.0.0-next.41...v2.0.0-next.42)
+
+<sup>Released on **2025-11-09**</sup>
+
+#### 🐛 Bug Fixes
+
+- **misc**: Fix missing messages when finish runtime.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### What's fixed
+
+- **misc**: Fix missing messages when finish runtime, closes [#10138](https://github.com/lobehub/lobe-chat/issues/10138) ([b94d477](https://github.com/lobehub/lobe-chat/commit/b94d477))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
 ## [Version 2.0.0-next.41](https://github.com/lobehub/lobe-chat/compare/v2.0.0-next.40...v2.0.0-next.41)
 
 <sup>Released on **2025-11-09**</sup>

package/changelog/v1.json

@@ -1,4 +1,22 @@
 [
+  {
+    "children": {
+      "fixes": [
+        "Abnormal animation of tokens."
+      ]
+    },
+    "date": "2025-11-09",
+    "version": "2.0.0-next.43"
+  },
+  {
+    "children": {
+      "fixes": [
+        "Fix missing messages when finish runtime."
+      ]
+    },
+    "date": "2025-11-09",
+    "version": "2.0.0-next.42"
+  },
   {
     "children": {
       "improvements": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/lobehub",
-  "version": "2.0.0-next.41",
+  "version": "2.0.0-next.43",
   "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",

package/packages/database/src/models/__tests__/messages/message.create.test.ts

@@ -5,6 +5,7 @@ import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 import { uuid } from '@/utils/uuid';
 
 import {
+  chatGroups,
   chunks,
   embeddings,
   files,
@@ -224,31 +225,53 @@ describe('MessageModel Create Tests', () => {
         expect(dbResult[0].id).toBe(customId);
       });
 
-      it.skip('should create a message with file chunks and RAG query ID', async () => {
-        // Create test data
+      it('should create a message with file chunks and RAG query ID', async () => {
+        // Create test data following proper order: message -> query -> message with chunks
         const chunkId1 = uuid();
         const chunkId2 = uuid();
-        const ragQueryId = uuid();
+        const firstMessageId = uuid();
+        const secondMessageId = uuid();
 
+        // 1. Create chunks first
         await serverDB.insert(chunks).values([
-          { id: chunkId1, text: 'chunk text 1' },
-          { id: chunkId2, text: 'chunk text 2' },
+          { id: chunkId1, text: 'chunk text 1', userId },
+          { id: chunkId2, text: 'chunk text 2', userId },
         ]);
 
-        // Call create method
-        const result = await messageModel.create({
-          role: 'assistant',
-          content: 'message with file chunks',
-          fileChunks: [
-            { id: chunkId1, similarity: 0.95 },
-            { id: chunkId2, similarity: 0.85 },
-          ],
-          ragQueryId,
+        // 2. Create first message (required for messageQuery FK)
+        await serverDB.insert(messages).values({
+          id: firstMessageId,
+          userId,
+          role: 'user',
+          content: 'user query',
           sessionId: '1',
         });
 
+        // 3. Create message query linked to first message
+        const messageQuery = await messageModel.createMessageQuery({
+          messageId: firstMessageId,
+          rewriteQuery: 'test query',
+          userQuery: 'original query',
+          embeddingsId,
+        });
+
+        // 4. Create second message with file chunks referencing the query
+        const result = await messageModel.create(
+          {
+            role: 'assistant',
+            content: 'message with file chunks',
+            fileChunks: [
+              { id: chunkId1, similarity: 0.95 },
+              { id: chunkId2, similarity: 0.85 },
+            ],
+            ragQueryId: messageQuery.id,
+            sessionId: '1',
+          },
+          secondMessageId,
+        );
+
         // Verify message created successfully
-        expect(result.id).toBeDefined();
+        expect(result.id).toBe(secondMessageId);
 
         // Verify message query chunk associations created successfully
         const queryChunks = await serverDB
@@ -258,10 +281,10 @@ describe('MessageModel Create Tests', () => {
 
         expect(queryChunks).toHaveLength(2);
         expect(queryChunks[0].chunkId).toBe(chunkId1);
-        expect(queryChunks[0].queryId).toBe(ragQueryId);
-        expect(queryChunks[0].similarity).toBe('0.95');
+        expect(queryChunks[0].queryId).toBe(messageQuery.id);
+        expect(queryChunks[0].similarity).toBe('0.95000');
         expect(queryChunks[1].chunkId).toBe(chunkId2);
-        expect(queryChunks[1].similarity).toBe('0.85');
+        expect(queryChunks[1].similarity).toBe('0.85000');
       });
 
       it('should create a message with files', async () => {
@@ -350,6 +373,40 @@ describe('MessageModel Create Tests', () => {
       expect(result[0].content).toBe('message 1');
       expect(result[1].content).toBe('message 2');
     });
+
+    it('should handle messages with and without groupId', async () => {
+      await serverDB.insert(sessions).values({ id: 'session1', userId });
+      await serverDB.insert(chatGroups).values({ id: 'group1', userId, title: 'Group 1' });
+
+      // Message without groupId - should keep sessionId
+      const msgWithoutGroup = await messageModel.create({
+        role: 'user',
+        content: 'message without group',
+        sessionId: 'session1',
+      });
+
+      // Message with groupId - sessionId should be set to null
+      const msgWithGroup = await messageModel.create({
+        role: 'user',
+        content: 'message with group',
+        sessionId: 'session1',
+        groupId: 'group1',
+      });
+
+      // Verify from database
+      const dbMsgWithoutGroup = await serverDB.query.messages.findFirst({
+        where: eq(messages.id, msgWithoutGroup.id),
+      });
+      const dbMsgWithGroup = await serverDB.query.messages.findFirst({
+        where: eq(messages.id, msgWithGroup.id),
+      });
+
+      expect(dbMsgWithoutGroup?.sessionId).toBe('session1');
+      expect(dbMsgWithoutGroup?.groupId).toBeNull();
+
+      expect(dbMsgWithGroup?.sessionId).toBeNull();
+      expect(dbMsgWithGroup?.groupId).toBe('group1');
+    });
   });
 
   describe('createMessageQuery', () => {

package/packages/database/src/models/__tests__/messages/message.query.test.ts

@@ -1,3 +1,4 @@
+import { INBOX_SESSION_ID } from '@lobechat/const';
 import dayjs from 'dayjs';
 import { eq } from 'drizzle-orm';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
@@ -8,6 +9,7 @@ import {
   agents,
   chatGroups,
   chunks,
+  documents,
   embeddings,
   fileChunks,
   files,
@@ -389,7 +391,7 @@ describe('MessageModel Query Tests', () => {
         expect(result[0].ragRawQuery).toBe('original query');
       });
 
-      it.skip('should handle multiple message queries for the same message', async () => {
+      it('should handle multiple message queries for the same message', async () => {
         // Create test data
         const messageId = 'msg-multi-query';
         const queryId1 = uuid();
@@ -402,7 +404,9 @@ describe('MessageModel Query Tests', () => {
           content: 'test message',
         });
 
-        // 创建两个查询，但查询结果应该只包含一个（最新的）
+        // 创建两个查询，查询结果应该只包含其中一个
+        // Note: 由于 messageQueries 表没有排序字段，返回哪个 query 是不确定的
+        // 但应该只返回一个
         await serverDB.insert(messageQueries).values([
           {
             id: queryId1,
@@ -423,12 +427,13 @@ describe('MessageModel Query Tests', () => {
         // Call query method
         const result = await messageModel.query();
 
-        // Assert result - 应该只包含最新的查询
+        // Assert result - 应该只包含一个查询（具体是哪个取决于数据库实现）
         expect(result).toHaveLength(1);
         expect(result[0].id).toBe(messageId);
-        expect(result[0].ragQueryId).toBe(queryId2);
-        expect(result[0].ragQuery).toBe('rewritten query 2');
-        expect(result[0].ragRawQuery).toBe('original query 2');
+        // 验证返回的是两个 query 中的一个
+        expect([queryId1, queryId2]).toContain(result[0].ragQueryId);
+        expect(['rewritten query 1', 'rewritten query 2']).toContain(result[0].ragQuery);
+        expect(['original query 1', 'original query 2']).toContain(result[0].ragRawQuery);
       });
     });
 
@@ -506,6 +511,64 @@ describe('MessageModel Query Tests', () => {
       });
     });
 
+    it('should handle null similarity in chunks and convert to number', async () => {
+      await serverDB.transaction(async (trx) => {
+        const chunk1Id = uuid();
+        const query1Id = uuid();
+
+        await trx.insert(messages).values({
+          id: 'msg1',
+          userId,
+          role: 'user',
+          content: 'test message',
+        });
+
+        await trx.insert(files).values({
+          id: 'file1',
+          userId,
+          name: 'test.txt',
+          url: 'test-url',
+          fileType: 'text/plain',
+          size: 100,
+        });
+
+        await trx.insert(chunks).values({
+          id: chunk1Id,
+          text: 'chunk content',
+        });
+
+        await trx.insert(fileChunks).values({
+          fileId: 'file1',
+          userId,
+          chunkId: chunk1Id,
+        });
+
+        await trx.insert(messageQueries).values({
+          id: query1Id,
+          messageId: 'msg1',
+          userId,
+          userQuery: 'query',
+          rewriteQuery: 'rewritten',
+        });
+
+        // Insert chunk with null similarity
+        await trx.insert(messageQueryChunks).values({
+          messageId: 'msg1',
+          queryId: query1Id,
+          chunkId: chunk1Id,
+          similarity: null as any,
+          userId,
+        });
+      });
+
+      const result = await messageModel.query();
+
+      expect(result).toHaveLength(1);
+      expect(result[0].chunksList).toHaveLength(1);
+      // null should be converted to undefined
+      expect(result[0].chunksList![0].similarity).toBeUndefined();
+    });
+
     it('should return empty arrays for files and chunks if none exist', async () => {
       await serverDB.insert(messages).values({
         id: 'msg1',
@@ -890,6 +953,44 @@ describe('MessageModel Query Tests', () => {
       expect(result).toHaveLength(1);
       expect(result[0].id).toBe('inbox-msg');
     });
+
+    it('should query inbox messages when sessionId is INBOX_SESSION_ID', async () => {
+      await serverDB.insert(sessions).values([{ id: 'session1', userId }]);
+
+      await serverDB.insert(messages).values([
+        {
+          id: 'inbox-msg-1',
+          userId,
+          sessionId: null,
+          role: 'user',
+          content: 'inbox message 1',
+          createdAt: new Date('2023-01-01'),
+        },
+        {
+          id: 'inbox-msg-2',
+          userId,
+          sessionId: null,
+          role: 'assistant',
+          content: 'inbox message 2',
+          createdAt: new Date('2023-01-02'),
+        },
+        {
+          id: 'session-msg',
+          userId,
+          sessionId: 'session1',
+          role: 'user',
+          content: 'session message',
+          createdAt: new Date('2023-01-03'),
+        },
+      ]);
+
+      // Query with INBOX_SESSION_ID should return only inbox messages
+      const result = await messageModel.queryBySessionId(INBOX_SESSION_ID);
+
+      expect(result).toHaveLength(2);
+      expect(result[0].id).toBe('inbox-msg-1');
+      expect(result[1].id).toBe('inbox-msg-2');
+    });
   });
 
   describe('queryByKeyWord', () => {
@@ -928,6 +1029,122 @@ describe('MessageModel Query Tests', () => {
     });
   });
 
+  describe('query with files edge cases', () => {
+    it('should handle files with empty fileType', async () => {
+      await serverDB.transaction(async (trx) => {
+        await trx.insert(sessions).values({ id: 'session1', userId });
+
+        // Create files with empty string fileType (tests the || '' branch)
+        await trx.insert(files).values([
+          {
+            id: 'file-empty-type',
+            userId,
+            url: 'unknown.bin',
+            name: 'unknown file',
+            fileType: '',
+            size: 1000,
+          },
+          {
+            id: 'file-image',
+            userId,
+            url: 'image.png',
+            name: 'test image',
+            fileType: 'image/png',
+            size: 2000,
+          },
+          {
+            id: 'file-video',
+            userId,
+            url: 'video.mp4',
+            name: 'test video',
+            fileType: 'video/mp4',
+            size: 3000,
+          },
+        ]);
+
+        const messageId = uuid();
+        await trx.insert(messages).values({
+          id: messageId,
+          userId,
+          role: 'user',
+          content: 'Message with various fileTypes',
+          sessionId: 'session1',
+        });
+
+        await trx.insert(messagesFiles).values([
+          { messageId, fileId: 'file-empty-type', userId },
+          { messageId, fileId: 'file-image', userId },
+          { messageId, fileId: 'file-video', userId },
+        ]);
+      });
+
+      const result = await messageModel.query({ sessionId: 'session1' });
+
+      expect(result).toHaveLength(1);
+      expect(result[0].fileList).toHaveLength(1); // empty fileType should go to fileList
+      expect(result[0].fileList![0].id).toBe('file-empty-type');
+      expect(result[0].imageList).toHaveLength(1);
+      expect(result[0].imageList![0].id).toBe('file-image');
+      expect(result[0].videoList).toHaveLength(1);
+      expect(result[0].videoList![0].id).toBe('file-video');
+    });
+  });
+
+  describe('query with documents', () => {
+    it('should include document content when files have associated documents', async () => {
+      // Create a file with an associated document
+      const fileId = uuid();
+
+      await serverDB.transaction(async (trx) => {
+        await trx.insert(sessions).values({ id: 'session1', userId });
+
+        await trx.insert(files).values({
+          id: fileId,
+          userId,
+          url: 'document.pdf',
+          name: 'test.pdf',
+          fileType: 'application/pdf',
+          size: 5000,
+        });
+
+        await trx.insert(documents).values({
+          fileId,
+          userId,
+          content: 'This is the document content for testing',
+          fileType: 'application/pdf',
+          sourceType: 'file',
+          source: 'document.pdf',
+          totalCharCount: 42,
+          totalLineCount: 1,
+        });
+
+        const messageId = uuid();
+        await trx.insert(messages).values({
+          id: messageId,
+          userId,
+          role: 'user',
+          content: 'Message with document',
+          sessionId: 'session1',
+        });
+
+        await trx.insert(messagesFiles).values({
+          messageId,
+          fileId,
+          userId,
+        });
+      });
+
+      // Query messages - this should trigger the documents processing code
+      const result = await messageModel.query({ sessionId: 'session1' });
+
+      expect(result).toHaveLength(1);
+      expect(result[0].fileList).toBeDefined();
+      expect(result[0].fileList).toHaveLength(1);
+      expect(result[0].fileList![0].id).toBe(fileId);
+      expect(result[0].fileList![0].content).toBe('This is the document content for testing');
+    });
+  });
+
   describe('findMessageQueriesById', () => {
     it('should return undefined for non-existent message query', async () => {
       const result = await messageModel.findMessageQueriesById('non-existent-id');

package/packages/database/src/models/__tests__/messages/message.stats.test.ts

@@ -223,6 +223,54 @@ describe('MessageModel Statistics Tests', () => {
       // Assert result
       expect(result).toEqual(0);
     });
+
+    it('should count words with startDate filter', async () => {
+      await serverDB.insert(messages).values([
+        {
+          id: '1',
+          userId,
+          role: 'user',
+          content: 'old message',
+          createdAt: new Date('2023-01-01'),
+        },
+        {
+          id: '2',
+          userId,
+          role: 'user',
+          content: 'new message',
+          createdAt: new Date('2023-03-01'),
+        },
+      ]);
+
+      const result = await messageModel.countWords({ startDate: '2023-02-01' });
+
+      // Only 'new message' should be counted = 11 characters
+      expect(result).toEqual(11);
+    });
+
+    it('should count words with endDate filter', async () => {
+      await serverDB.insert(messages).values([
+        {
+          id: '1',
+          userId,
+          role: 'user',
+          content: 'old message',
+          createdAt: new Date('2023-01-01'),
+        },
+        {
+          id: '2',
+          userId,
+          role: 'user',
+          content: 'new message',
+          createdAt: new Date('2023-03-01'),
+        },
+      ]);
+
+      const result = await messageModel.countWords({ endDate: '2023-02-01' });
+
+      // Only 'old message' should be counted = 11 characters
+      expect(result).toEqual(11);
+    });
   });
 
   describe('getHeatmaps', () => {
@@ -379,10 +427,11 @@ describe('MessageModel Statistics Tests', () => {
       vi.useRealTimers();
     });
 
-    it.skip('should return time count correctly when 19:00 time', async () => {
-      // 使用固定日期进行测试
+    it('should return time count correctly when 19:00 time', async () => {
+      // 使用固定日期进行测试，使用本地时间避免时区问题
       vi.useFakeTimers();
-      const fixedDate = new Date('2025-04-02T19:00:00Z');
+      // Use local time at noon to avoid timezone edge cases
+      const fixedDate = new Date('2025-04-02T12:00:00');
       vi.setSystemTime(fixedDate);
 
       const today = dayjs(fixedDate);
@@ -390,28 +439,28 @@ describe('MessageModel Statistics Tests', () => {
       const oneDayAgoDate = today.subtract(1, 'day').format('YYYY-MM-DD');
       const todayDate = today.format('YYYY-MM-DD');
 
-      // Create test data
+      // Create test data using explicit dates to avoid timezone issues
       await serverDB.insert(messages).values([
         {
           id: '1',
           userId,
           role: 'user',
           content: 'message 1',
-          createdAt: today.subtract(2, 'day').toDate(),
+          createdAt: new Date(twoDaysAgoDate + 'T10:00:00'),
         },
         {
           id: '2',
           userId,
           role: 'user',
           content: 'message 2',
-          createdAt: today.subtract(2, 'day').toDate(),
+          createdAt: new Date(twoDaysAgoDate + 'T14:00:00'),
         },
         {
           id: '3',
           userId,
           role: 'user',
           content: 'message 3',
-          createdAt: today.subtract(1, 'day').toDate(),
+          createdAt: new Date(oneDayAgoDate + 'T10:00:00'),
         },
       ]);
 

package/packages/database/src/models/__tests__/messages/message.update.test.ts

@@ -367,6 +367,25 @@ describe('MessageModel Update Tests', () => {
 
       expect(otherResult).toHaveLength(1);
     });
+
+    it('should handle database errors gracefully', async () => {
+      // Create test message
+      await serverDB.insert(messages).values({
+        id: '1',
+        content: 'test message',
+        role: 'user',
+        userId,
+      });
+
+      // Mock database to throw error by trying to update with invalid sessionId reference
+      // This should trigger the catch block in the update method
+      const result = await messageModel.update('1', {
+        // @ts-expect-error - intentionally passing invalid sessionId to trigger error
+        sessionId: 'non-existent-session-that-violates-fk',
+      });
+
+      expect(result.success).toBe(false);
+    });
   });
 
   describe('updatePluginState', () => {
@@ -392,6 +411,28 @@ describe('MessageModel Update Tests', () => {
       expect(result[0].state).toEqual({ key1: 'value1', key2: 'value2' });
     });
 
+    it('should handle null state in plugin', async () => {
+      // Create test data with null state
+      await serverDB.insert(messages).values({ id: '1', content: 'abc', role: 'user', userId });
+      await serverDB.insert(messagePlugins).values([
+        {
+          id: '1',
+          toolCallId: 'tool1',
+          identifier: 'plugin1',
+          state: null,
+          userId,
+        },
+      ]);
+
+      // Call updatePluginState method
+      await messageModel.updatePluginState('1', { key1: 'value1' });
+
+      // Assert result - should merge with empty object when state is null
+      const result = await serverDB.select().from(messagePlugins).where(eq(messagePlugins.id, '1'));
+
+      expect(result[0].state).toEqual({ key1: 'value1' });
+    });
+
     it('should throw an error if plugin does not exist', async () => {
       // 调用 updatePluginState 方法
       await expect(messageModel.updatePluginState('1', { key: 'value' })).rejects.toThrowError(
@@ -423,10 +464,10 @@ describe('MessageModel Update Tests', () => {
     });
 
     it('should throw an error if plugin does not exist', async () => {
-      // 调用 updatePluginState 方法
-      await expect(messageModel.updatePluginState('1', { key: 'value' })).rejects.toThrowError(
-        'Plugin not found',
-      );
+      // 调用 updateMessagePlugin 方法（修复：之前错误地调用了 updatePluginState）
+      await expect(
+        messageModel.updateMessagePlugin('non-existent-id', { identifier: 'test' }),
+      ).rejects.toThrowError('Plugin not found');
     });
   });