@lobehub/lobehub 2.0.0-next.35 → 2.0.0-next.37

package/src/server/routers/lambda/message.ts

@@ -55,10 +55,9 @@ export const messageRouter = router({
     }),
 
   createMessage: messageProcedure
-    .input(CreateNewMessageParamsSchema.extend({ useGroup: z.boolean().optional() }))
+    .input(CreateNewMessageParamsSchema)
     .mutation(async ({ input, ctx }) => {
-      const { useGroup, ...params } = input;
-      return ctx.messageService.createMessage(params as any, { useGroup });
+      return ctx.messageService.createMessage(input as any);
     }),
 
   getHeatmaps: messageProcedure.query(async ({ ctx }) => {
@@ -74,20 +73,17 @@ export const messageRouter = router({
         pageSize: z.number().optional(),
         sessionId: z.string().nullable().optional(),
         topicId: z.string().nullable().optional(),
-        useGroup: z.boolean().optional(),
       }),
     )
     .query(async ({ input, ctx }) => {
       if (!ctx.userId) return [];
       const serverDB = await getServerDB();
 
-      const { useGroup, ...queryParams } = input;
-
       const messageModel = new MessageModel(serverDB, ctx.userId);
       const fileService = new FileService(serverDB, ctx.userId);
 
-      return messageModel.query(queryParams, {
-        groupAssistantMessages: useGroup ?? false,
+      return messageModel.query(input, {
+        groupAssistantMessages: false,
         postProcessUrl: (path) => fileService.getFullFileUrl(path),
       });
     }),
@@ -106,7 +102,6 @@ export const messageRouter = router({
         id: z.string(),
         sessionId: z.string().nullable().optional(),
         topicId: z.string().nullable().optional(),
-        useGroup: z.boolean().optional(),
       }),
     )
     .mutation(async ({ input, ctx }) => {
@@ -126,7 +121,6 @@ export const messageRouter = router({
         ids: z.array(z.string()),
         sessionId: z.string().nullable().optional(),
         topicId: z.string().nullable().optional(),
-        useGroup: z.boolean().optional(),
       }),
     )
     .mutation(async ({ input, ctx }) => {
@@ -173,7 +167,6 @@ export const messageRouter = router({
         id: z.string(),
         sessionId: z.string().nullable().optional(),
         topicId: z.string().nullable().optional(),
-        useGroup: z.boolean().optional(),
         value: UpdateMessageParamsSchema,
       }),
     )
@@ -198,7 +191,6 @@ export const messageRouter = router({
       UpdateMessageRAGParamsSchema.extend({
         sessionId: z.string().nullable().optional(),
         topicId: z.string().nullable().optional(),
-        useGroup: z.boolean().optional(),
       }),
     )
     .mutation(async ({ input, ctx }) => {
@@ -210,11 +202,14 @@ export const messageRouter = router({
     .input(
       z.object({
         id: z.string(),
+        sessionId: z.string().nullable().optional(),
+        topicId: z.string().nullable().optional(),
         value: z.object({}).passthrough(),
       }),
     )
     .mutation(async ({ input, ctx }) => {
-      return ctx.messageModel.updateMetadata(input.id, input.value);
+      const { id, value, ...options } = input;
+      return ctx.messageService.updateMetadata(id, value, options);
     }),
 
   updatePluginError: messageProcedure
@@ -223,7 +218,6 @@ export const messageRouter = router({
         id: z.string(),
         sessionId: z.string().nullable().optional(),
         topicId: z.string().nullable().optional(),
-        useGroup: z.boolean().optional(),
         value: z.object({}).passthrough().nullable(),
       }),
     )
@@ -238,7 +232,6 @@ export const messageRouter = router({
         id: z.string(),
         sessionId: z.string().nullable().optional(),
         topicId: z.string().nullable().optional(),
-        useGroup: z.boolean().optional(),
         value: z.object({}).passthrough(),
       }),
     )
@@ -267,7 +260,6 @@ export const messageRouter = router({
 
       return ctx.messageModel.updateTTS(input.id, input.value);
     }),
-
   updateTranslate: messageProcedure
     .input(
       z.object({

package/src/server/services/message/__tests__/index.test.ts

@@ -26,6 +26,7 @@ describe('MessageService', () => {
       update: vi.fn(),
       updateMessagePlugin: vi.fn(),
       updateMessageRAG: vi.fn(),
+      updateMetadata: vi.fn(),
       updatePluginState: vi.fn(),
     } as any;
 
@@ -222,36 +223,51 @@ describe('MessageService', () => {
     });
   });
 
-  describe('useGroup option', () => {
-    it('should pass useGroup option to query', async () => {
+  describe('updateMetadata', () => {
+    it('should update metadata and return { success: true } when no sessionId/topicId provided', async () => {
+      const messageId = 'msg-1';
+      const metadata = { someKey: 'someValue', count: 42 };
+
+      const result = await messageService.updateMetadata(messageId, metadata);
+
+      expect(mockMessageModel.updateMetadata).toHaveBeenCalledWith(messageId, metadata);
+      expect(result).toEqual({ success: true });
+      expect(mockMessageModel.query).not.toHaveBeenCalled();
+    });
+
+    it('should update metadata and return message list when sessionId provided', async () => {
+      const messageId = 'msg-1';
+      const metadata = { someKey: 'someValue', count: 42 };
       const mockMessages = [{ id: 'msg-1', content: 'test' }];
       vi.mocked(mockMessageModel.query).mockResolvedValue(mockMessages as any);
 
-      await messageService.removeMessage('msg-1', {
+      const result = await messageService.updateMetadata(messageId, metadata, {
         sessionId: 'session-1',
-        useGroup: true,
       });
 
-      expect(mockMessageModel.query).toHaveBeenCalledWith(
-        expect.anything(),
-        expect.objectContaining({
-          groupAssistantMessages: true,
-        }),
-      );
+      expect(mockMessageModel.updateMetadata).toHaveBeenCalledWith(messageId, metadata);
+      expect(mockMessageModel.query).toHaveBeenCalled();
+      expect(result).toEqual({ messages: mockMessages, success: true });
     });
 
-    it('should default useGroup to false', async () => {
+    it('should update metadata and return message list when topicId provided', async () => {
+      const messageId = 'msg-1';
+      const metadata = { key: 'value' };
       const mockMessages = [{ id: 'msg-1', content: 'test' }];
       vi.mocked(mockMessageModel.query).mockResolvedValue(mockMessages as any);
 
-      await messageService.removeMessage('msg-1', { sessionId: 'session-1' });
+      const result = await messageService.updateMetadata(messageId, metadata, {
+        topicId: 'topic-1',
+      });
 
+      expect(mockMessageModel.updateMetadata).toHaveBeenCalledWith(messageId, metadata);
       expect(mockMessageModel.query).toHaveBeenCalledWith(
-        expect.anything(),
+        { groupId: undefined, sessionId: undefined, topicId: 'topic-1' },
         expect.objectContaining({
           groupAssistantMessages: false,
         }),
       );
+      expect(result).toEqual({ messages: mockMessages, success: true });
     });
   });
 
@@ -289,32 +305,6 @@ describe('MessageService', () => {
       });
     });
 
-    it('should create message with useGroup option', async () => {
-      const params = {
-        content: 'Hello',
-        role: 'assistant' as const,
-        sessionId: 'session-1',
-      };
-      const createdMessage = { id: 'msg-1', ...params };
-      const mockMessages = [createdMessage];
-
-      vi.mocked(mockMessageModel.create).mockResolvedValue(createdMessage as any);
-      vi.mocked(mockMessageModel.query).mockResolvedValue(mockMessages as any);
-
-      const result = await messageService.createMessage(params as any, { useGroup: true });
-
-      expect(mockMessageModel.query).toHaveBeenCalledWith(
-        expect.anything(),
-        expect.objectContaining({
-          groupAssistantMessages: true,
-        }),
-      );
-      expect(result).toEqual({
-        id: 'msg-1',
-        messages: mockMessages,
-      });
-    });
-
     it('should create message with topicId and groupId', async () => {
       const params = {
         content: 'Hello',

package/src/server/services/message/index.ts

@@ -9,7 +9,6 @@ interface QueryOptions {
   groupId?: string | null;
   sessionId?: string | null;
   topicId?: string | null;
-  useGroup?: boolean;
 }
 
 interface CreateMessageResult {
@@ -42,9 +41,9 @@ export class MessageService {
   /**
    * Unified query options
    */
-  private getQueryOptions(options: QueryOptions) {
+  private getQueryOptions() {
     return {
-      groupAssistantMessages: options.useGroup ?? false,
+      groupAssistantMessages: false,
       postProcessUrl: this.postProcessUrl,
     };
   }
@@ -61,12 +60,45 @@ export class MessageService {
 
     const messages = await this.messageModel.query(
       { groupId, sessionId, topicId },
-      this.getQueryOptions(options),
+      this.getQueryOptions(),
     );
 
     return { messages, success: true };
   }
 
+  /**
+   * Create a new message and return the complete message list
+   * Pattern: create + query
+   *
+   * This method combines message creation and querying into a single operation,
+   * reducing the need for separate refresh calls and improving performance.
+   */
+  async createMessage(params: CreateMessageParams): Promise<CreateMessageResult> {
+    // 1. Create the message
+    const item = await this.messageModel.create(params);
+
+    // 2. Query all messages for this session/topic
+    const messages = await this.messageModel.query(
+      {
+        current: 0,
+        groupId: params.groupId,
+        pageSize: 9999,
+        sessionId: params.sessionId,
+        topicId: params.topicId,
+      },
+      {
+        groupAssistantMessages: false,
+        postProcessUrl: this.postProcessUrl,
+      },
+    );
+
+    // 3. Return the result
+    return {
+      id: item.id,
+      messages,
+    };
+  }
+
   /**
    * Remove messages with optional message list return
    * Pattern: delete + conditional query
@@ -122,38 +154,11 @@ export class MessageService {
   }
 
   /**
-   * Create a new message and return the complete message list
-   * Pattern: create + query
-   *
-   * This method combines message creation and querying into a single operation,
-   * reducing the need for separate refresh calls and improving performance.
+   * Update message metadata with optional message list return
+   * Pattern: update + conditional query
    */
-  async createMessage(
-    params: CreateMessageParams,
-    options?: QueryOptions,
-  ): Promise<CreateMessageResult> {
-    // 1. Create the message
-    const item = await this.messageModel.create(params);
-
-    // 2. Query all messages for this session/topic
-    const messages = await this.messageModel.query(
-      {
-        current: 0,
-        groupId: params.groupId,
-        pageSize: 9999,
-        sessionId: params.sessionId,
-        topicId: params.topicId,
-      },
-      {
-        groupAssistantMessages: options?.useGroup ?? false,
-        postProcessUrl: this.postProcessUrl,
-      },
-    );
-
-    // 3. Return the result
-    return {
-      id: item.id,
-      messages,
-    };
+  async updateMetadata(id: string, value: any, options?: QueryOptions) {
+    await this.messageModel.updateMetadata(id, value);
+    return this.queryWithSuccess(options);
   }
 }

package/src/services/electron/desktopNotification.ts

@@ -5,13 +5,13 @@ import {
 } from '@lobechat/electron-client-ipc';
 
 /**
- * 桌面通知服务
+ * Desktop notification service
  */
 export class DesktopNotificationService {
   /**
-   * 显示桌面通知（仅在窗口隐藏时）
-   * @param params 通知参数
-   * @returns 通知结果
+   * Show desktop notification (only when window is hidden)
+   * @param params Notification parameters
+   * @returns Notification result
    */
   async showNotification(
     params: ShowDesktopNotificationParams,
@@ -20,8 +20,8 @@ export class DesktopNotificationService {
   }
 
   /**
-   * 检查主窗口是否隐藏
-   * @returns 是否隐藏
+   * Check if main window is hidden
+   * @returns Whether it is hidden
    */
   async isMainWindowHidden(): Promise<boolean> {
     return dispatch('isMainWindowHidden');

package/src/services/electron/file.ts

@@ -2,15 +2,15 @@ import { dispatch } from '@lobechat/electron-client-ipc';
 import { FileMetadata } from '@lobechat/types';
 
 /**
- * 桌面应用文件API客户端服务
+ * Desktop application file API client service
  */
 class DesktopFileAPI {
   /**
-   * 上传文件到桌面应用
-   * @param file 文件对象
-   * @param hash 文件哈希
-   * @param path 文件存储路径
-   * @returns 上传结果
+   * Upload file to desktop application
+   * @param file File object
+   * @param hash File hash
+   * @param path File storage path
+   * @returns Upload result
    */
   async uploadFile(
     file: File,

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

@@ -13,9 +13,9 @@ export class BrowserS3Storage {
   }
 
   /**
-   * 上传文件
-   * @param key 文件 hash
-   * @param file File 对象
+   * Upload file
+   * @param key File hash
+   * @param file File object
    */
   putObject = async (key: string, file: File): Promise<void> => {
     try {
@@ -27,9 +27,9 @@ export class BrowserS3Storage {
   };
 
   /**
-   * 获取文件
-   * @param key 文件 hash
-   * @returns File 对象
+   * Get file
+   * @param key File hash
+   * @returns File object
    */
   getObject = async (key: string): Promise<File | undefined> => {
     try {
@@ -44,8 +44,8 @@ export class BrowserS3Storage {
   };
 
   /**
-   * 删除文件
-   * @param key 文件 hash
+   * Delete file
+   * @param key File hash
    */
   deleteObject = async (key: string): Promise<void> => {
     try {

package/src/services/message/__tests__/metadata-race-condition.test.ts

@@ -0,0 +1,157 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { lambdaClient } from '@/libs/trpc/client';
+
+import { MessageService } from '../index';
+
+vi.mock('@/libs/trpc/client', () => ({
+  lambdaClient: {
+    message: {
+      updateMetadata: {
+        mutate: vi.fn(),
+      },
+    },
+  },
+}));
+
+describe('MessageService - Race Condition Control', () => {
+  let messageService: MessageService;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    messageService = new MessageService();
+  });
+
+  describe('updateMessageMetadata race condition', () => {
+    it('should cancel previous request when new update is triggered for same message', async () => {
+      const messageId = 'test-message-id';
+      let firstRequestAborted = false;
+      let secondRequestCompleted = false;
+
+      // Mock first request (slow)
+      vi.mocked(lambdaClient.message.updateMetadata.mutate).mockImplementationOnce(
+        (_params, options) =>
+          new Promise((resolve, reject) => {
+            const signal = options?.signal;
+            if (signal) {
+              signal.addEventListener('abort', () => {
+                firstRequestAborted = true;
+                reject(new Error('Aborted'));
+              });
+            }
+            // Simulate slow request
+            setTimeout(() => resolve({ success: true, messages: [] }), 200);
+          }),
+      );
+
+      // Mock second request (fast)
+      vi.mocked(lambdaClient.message.updateMetadata.mutate).mockImplementationOnce(
+        async (_params, _options) => {
+          secondRequestCompleted = true;
+          return { success: true, messages: [] };
+        },
+      );
+
+      // Start first update
+      const firstPromise = messageService.updateMessageMetadata(messageId, { compare: true });
+
+      // Wait a bit then start second update
+      await new Promise((resolve) => setTimeout(resolve, 10));
+      const secondPromise = messageService.updateMessageMetadata(messageId, { compare: false });
+
+      // First should be aborted
+      await expect(firstPromise).rejects.toThrow('Aborted');
+      expect(firstRequestAborted).toBe(true);
+
+      // Second should complete successfully
+      await expect(secondPromise).resolves.toEqual({ success: true, messages: [] });
+      expect(secondRequestCompleted).toBe(true);
+    });
+
+    it('should allow concurrent updates for different messages', async () => {
+      const message1Id = 'message-1';
+      const message2Id = 'message-2';
+
+      vi.mocked(lambdaClient.message.updateMetadata.mutate).mockResolvedValue({
+        success: true,
+        messages: [],
+      });
+
+      const [result1, result2] = await Promise.all([
+        messageService.updateMessageMetadata(message1Id, { cost: 0.001 }),
+        messageService.updateMessageMetadata(message2Id, { cost: 0.002 }),
+      ]);
+
+      expect(result1).toEqual({ success: true, messages: [] });
+      expect(result2).toEqual({ success: true, messages: [] });
+      expect(lambdaClient.message.updateMetadata.mutate).toHaveBeenCalledTimes(2);
+    });
+
+    it('should handle rapid successive updates correctly', async () => {
+      const messageId = 'test-message-id';
+      let completedUpdates = 0;
+      const abortedUpdates: number[] = [];
+
+      // All but the last request should be aborted
+      let callIndex = 0;
+      vi.mocked(lambdaClient.message.updateMetadata.mutate).mockImplementation(
+        (_params, options) => {
+          const currentIndex = callIndex++;
+          return new Promise((resolve, reject) => {
+            const signal = options?.signal;
+            let isAborted = false;
+
+            if (signal) {
+              signal.addEventListener('abort', () => {
+                isAborted = true;
+                abortedUpdates.push(currentIndex);
+                reject(new Error('Aborted'));
+              });
+            }
+
+            setTimeout(() => {
+              if (!isAborted) {
+                completedUpdates++;
+                resolve({ success: true, messages: [] });
+              }
+            }, 50);
+          });
+        },
+      );
+
+      // Trigger 5 rapid updates sequentially with catch to prevent unhandled rejections
+      const promise1 = messageService
+        .updateMessageMetadata(messageId, { cost: 0.001 })
+        .catch((e) => e);
+      await new Promise((resolve) => setTimeout(resolve, 5));
+      const promise2 = messageService
+        .updateMessageMetadata(messageId, { cost: 0.002 })
+        .catch((e) => e);
+      await new Promise((resolve) => setTimeout(resolve, 5));
+      const promise3 = messageService.updateMessageMetadata(messageId, { tps: 10 }).catch((e) => e);
+      await new Promise((resolve) => setTimeout(resolve, 5));
+      const promise4 = messageService.updateMessageMetadata(messageId, { tps: 20 }).catch((e) => e);
+      await new Promise((resolve) => setTimeout(resolve, 5));
+      const promise5 = messageService
+        .updateMessageMetadata(messageId, { compare: true })
+        .catch((e) => e);
+
+      // Wait for all to settle
+      const results = await Promise.all([promise1, promise2, promise3, promise4, promise5]);
+
+      // First 4 should be errors (aborted), last should succeed
+      expect(results[0]).toBeInstanceOf(Error);
+      expect(results[1]).toBeInstanceOf(Error);
+      expect(results[2]).toBeInstanceOf(Error);
+      expect(results[3]).toBeInstanceOf(Error);
+      expect(results[4]).toEqual({ success: true, messages: [] });
+
+      // 4 requests should have been aborted
+      expect(abortedUpdates.length).toBe(4);
+      expect(abortedUpdates).toEqual([0, 1, 2, 3]);
+
+      // Only the last request should complete
+      expect(completedUpdates).toBe(1);
+    });
+  });
+});

package/src/services/message/index.ts

@@ -5,6 +5,7 @@ import {
   ChatTranslate,
   CreateMessageParams,
   CreateMessageResult,
+  MessageMetadata,
   ModelRankItem,
   UIChatMessage,
   UpdateMessageParams,
@@ -15,14 +16,10 @@ import type { HeatmapsProps } from '@lobehub/charts';
 
 import { INBOX_SESSION_ID } from '@/const/session';
 import { lambdaClient } from '@/libs/trpc/client';
-import { useUserStore } from '@/store/user';
-import { labPreferSelectors } from '@/store/user/selectors';
 
-export class MessageService {
-  private get useGroup() {
-    return labPreferSelectors.enableAssistantMessageGroup(useUserStore.getState());
-  }
+import { abortableRequest } from '../utils/abortableRequest';
 
+export class MessageService {
   createMessage = async ({
     sessionId,
     ...params
@@ -30,7 +27,6 @@ export class MessageService {
     return lambdaClient.message.createMessage.mutate({
       ...params,
       sessionId: sessionId ? this.toDbSessionId(sessionId) : undefined,
-      useGroup: this.useGroup,
     });
   };
 
@@ -43,7 +39,6 @@ export class MessageService {
       groupId,
       sessionId: this.toDbSessionId(sessionId),
       topicId,
-      useGroup: this.useGroup,
     });
 
     return data as unknown as UIChatMessage[];
@@ -53,7 +48,6 @@ export class MessageService {
     const data = await lambdaClient.message.getMessages.query({
       groupId,
       topicId,
-      useGroup: this.useGroup,
     });
     return data as unknown as UIChatMessage[];
   };
@@ -100,7 +94,6 @@ export class MessageService {
       id,
       sessionId: options?.sessionId,
       topicId: options?.topicId,
-      useGroup: this.useGroup,
       value,
     });
   };
@@ -113,6 +106,24 @@ export class MessageService {
     return lambdaClient.message.updateTTS.mutate({ id, value: tts });
   };
 
+  updateMessageMetadata = async (
+    id: string,
+    value: Partial<MessageMetadata>,
+    options?: { sessionId?: string | null; topicId?: string | null },
+  ): Promise<UpdateMessageResult> => {
+    return abortableRequest.execute(`message-metadata-${id}`, (signal) =>
+      lambdaClient.message.updateMetadata.mutate(
+        {
+          id,
+          sessionId: options?.sessionId,
+          topicId: options?.topicId,
+          value,
+        },
+        { signal },
+      ),
+    );
+  };
+
   updateMessagePluginState = async (
     id: string,
     value: Record<string, any>,
@@ -122,7 +133,6 @@ export class MessageService {
       id,
       sessionId: options?.sessionId,
       topicId: options?.topicId,
-      useGroup: this.useGroup,
       value,
     });
   };
@@ -136,7 +146,6 @@ export class MessageService {
       id,
       sessionId: options?.sessionId,
       topicId: options?.topicId,
-      useGroup: this.useGroup,
       value: error as any,
     });
   };
@@ -150,7 +159,6 @@ export class MessageService {
       id,
       sessionId: options?.sessionId,
       topicId: options?.topicId,
-      useGroup: this.useGroup,
       value: data,
     });
   };
@@ -163,7 +171,6 @@ export class MessageService {
       id,
       sessionId: options?.sessionId,
       topicId: options?.topicId,
-      useGroup: this.useGroup,
     });
   };
 
@@ -175,7 +182,6 @@ export class MessageService {
       ids,
       sessionId: options?.sessionId,
       topicId: options?.topicId,
-      useGroup: this.useGroup,
     });
   };