@lobehub/chat 1.139.2 → 1.139.4

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

@@ -98,6 +98,7 @@ export const aiChatRouter = router({
         files: input.newUserMessage.files,
         role: 'user',
         sessionId: input.sessionId!,
+        threadId: input.threadId,
         topicId,
       });
 
@@ -117,6 +118,7 @@ export const aiChatRouter = router({
         parentId: messageId,
         role: 'assistant',
         sessionId: input.sessionId!,
+        threadId: input.threadId,
         topicId,
       });
       log('assistant message created with id: %s', assistantMessageItem.id);

package/src/store/chat/slices/message/action.test.ts

@@ -103,6 +103,98 @@ describe('chatMessage actions', () => {
     });
   });
 
+  describe('addUserMessage', () => {
+    it('should return early if activeId is undefined', async () => {
+      useChatStore.setState({ activeId: undefined });
+      const { result } = renderHook(() => useChatStore());
+      const updateInputMessageSpy = vi.spyOn(result.current, 'updateInputMessage');
+
+      await act(async () => {
+        await result.current.addUserMessage({ message: 'test message' });
+      });
+
+      expect(messageService.createMessage).not.toHaveBeenCalled();
+      expect(updateInputMessageSpy).not.toHaveBeenCalled();
+    });
+
+    it('should call internal_createMessage with correct parameters', async () => {
+      const message = 'Test user message';
+      const fileList = ['file-id-1', 'file-id-2'];
+      useChatStore.setState({
+        activeId: mockState.activeId,
+        activeTopicId: mockState.activeTopicId,
+      });
+      const { result } = renderHook(() => useChatStore());
+
+      await act(async () => {
+        await result.current.addUserMessage({ message, fileList });
+      });
+
+      expect(messageService.createMessage).toHaveBeenCalledWith({
+        content: message,
+        files: fileList,
+        role: 'user',
+        sessionId: mockState.activeId,
+        topicId: mockState.activeTopicId,
+        threadId: undefined,
+      });
+    });
+
+    it('should call internal_createMessage with threadId when activeThreadId is set', async () => {
+      const message = 'Test user message';
+      const activeThreadId = 'thread-123';
+      useChatStore.setState({
+        activeId: mockState.activeId,
+        activeTopicId: mockState.activeTopicId,
+        activeThreadId,
+      });
+      const { result } = renderHook(() => useChatStore());
+
+      await act(async () => {
+        await result.current.addUserMessage({ message });
+      });
+
+      expect(messageService.createMessage).toHaveBeenCalledWith({
+        content: message,
+        files: undefined,
+        role: 'user',
+        sessionId: mockState.activeId,
+        topicId: mockState.activeTopicId,
+        threadId: activeThreadId,
+      });
+    });
+
+    it('should call updateInputMessage with empty string', async () => {
+      const { result } = renderHook(() => useChatStore());
+      const updateInputMessageSpy = vi.spyOn(result.current, 'updateInputMessage');
+
+      await act(async () => {
+        await result.current.addUserMessage({ message: 'test' });
+      });
+
+      expect(updateInputMessageSpy).toHaveBeenCalledWith('');
+    });
+
+    it('should handle message without fileList', async () => {
+      const message = 'Test user message without files';
+      useChatStore.setState({ activeId: mockState.activeId });
+      const { result } = renderHook(() => useChatStore());
+
+      await act(async () => {
+        await result.current.addUserMessage({ message });
+      });
+
+      expect(messageService.createMessage).toHaveBeenCalledWith({
+        content: message,
+        files: undefined,
+        role: 'user',
+        sessionId: mockState.activeId,
+        topicId: mockState.activeTopicId,
+        threadId: undefined,
+      });
+    });
+  });
+
   describe('deleteMessage', () => {
     it('deleteMessage should remove a message by id', async () => {
       const { result } = renderHook(() => useChatStore());

package/src/store/chat/slices/message/action.ts

@@ -255,7 +255,8 @@ export const chatMessage: StateCreator<
     updateInputMessage('');
   },
   addUserMessage: async ({ message, fileList }) => {
-    const { internal_createMessage, updateInputMessage, activeTopicId, activeId } = get();
+    const { internal_createMessage, updateInputMessage, activeTopicId, activeId, activeThreadId } =
+      get();
     if (!activeId) return;
 
     await internal_createMessage({
@@ -265,6 +266,7 @@ export const chatMessage: StateCreator<
       sessionId: activeId,
       // if there is activeTopicId，then add topicId to message
       topicId: activeTopicId,
+      threadId: activeThreadId,
     });
 
     updateInputMessage('');

package/src/server/routers/lambda/aiChat.test.ts

@@ -1,108 +0,0 @@
-// @vitest-environment node
-import { describe, expect, it, vi } from 'vitest';
-
-import { MessageModel } from '@/database/models/message';
-import { TopicModel } from '@/database/models/topic';
-import { AiChatService } from '@/server/services/aiChat';
-
-import { aiChatRouter } from './aiChat';
-
-vi.mock('@/database/models/message');
-vi.mock('@/database/models/topic');
-vi.mock('@/server/services/aiChat');
-vi.mock('@/server/services/file', () => ({
-  FileService: vi.fn(),
-}));
-
-describe('aiChatRouter', () => {
-  const mockCtx = { userId: 'u1' };
-
-  it('should create topic optionally, create user/assistant messages, and return payload', async () => {
-    const mockCreateTopic = vi.fn().mockResolvedValue({ id: 't1' });
-    const mockCreateMessage = vi
-      .fn()
-      .mockResolvedValueOnce({ id: 'm-user' })
-      .mockResolvedValueOnce({ id: 'm-assistant' });
-    const mockGet = vi
-      .fn()
-      .mockResolvedValue({ messages: [{ id: 'm-user' }, { id: 'm-assistant' }], topics: [{}] });
-
-    vi.mocked(TopicModel).mockImplementation(() => ({ create: mockCreateTopic }) as any);
-    vi.mocked(MessageModel).mockImplementation(() => ({ create: mockCreateMessage }) as any);
-    vi.mocked(AiChatService).mockImplementation(() => ({ getMessagesAndTopics: mockGet }) as any);
-
-    const caller = aiChatRouter.createCaller(mockCtx as any);
-
-    const input = {
-      newAssistantMessage: { model: 'gpt-4o', provider: 'openai' },
-      newTopic: { title: 'T', topicMessageIds: ['a', 'b'] },
-      newUserMessage: { content: 'hi', files: ['f1'] },
-      sessionId: 's1',
-    } as any;
-
-    const res = await caller.sendMessageInServer(input);
-
-    expect(mockCreateTopic).toHaveBeenCalledWith({
-      messages: ['a', 'b'],
-      sessionId: 's1',
-      title: 'T',
-    });
-
-    expect(mockCreateMessage).toHaveBeenNthCalledWith(1, {
-      content: 'hi',
-      files: ['f1'],
-      role: 'user',
-      sessionId: 's1',
-      topicId: 't1',
-    });
-
-    expect(mockCreateMessage).toHaveBeenNthCalledWith(
-      2,
-      expect.objectContaining({
-        content: expect.any(String),
-        fromModel: 'gpt-4o',
-        parentId: 'm-user',
-        role: 'assistant',
-        sessionId: 's1',
-        topicId: 't1',
-      }),
-    );
-
-    expect(mockGet).toHaveBeenCalledWith({ includeTopic: true, sessionId: 's1', topicId: 't1' });
-    expect(res.assistantMessageId).toBe('m-assistant');
-    expect(res.userMessageId).toBe('m-user');
-    expect(res.isCreateNewTopic).toBe(true);
-    expect(res.topicId).toBe('t1');
-    expect(res.messages?.length).toBe(2);
-    expect(res.topics?.length).toBe(1);
-  });
-
-  it('should reuse existing topic when topicId provided', async () => {
-    const mockCreateMessage = vi
-      .fn()
-      .mockResolvedValueOnce({ id: 'm-user' })
-      .mockResolvedValueOnce({ id: 'm-assistant' });
-    const mockGet = vi.fn().mockResolvedValue({ messages: [], topics: undefined });
-
-    vi.mocked(MessageModel).mockImplementation(() => ({ create: mockCreateMessage }) as any);
-    vi.mocked(AiChatService).mockImplementation(() => ({ getMessagesAndTopics: mockGet }) as any);
-
-    const caller = aiChatRouter.createCaller(mockCtx as any);
-
-    const res = await caller.sendMessageInServer({
-      newAssistantMessage: { model: 'gpt-4o', provider: 'openai' },
-      newUserMessage: { content: 'hi' },
-      sessionId: 's1',
-      topicId: 't-exist',
-    } as any);
-
-    expect(mockCreateMessage).toHaveBeenCalled();
-    expect(mockGet).toHaveBeenCalledWith({
-      includeTopic: false,
-      sessionId: 's1',
-      topicId: 't-exist',
-    });
-    expect(res.isCreateNewTopic).toBe(false);
-    expect(res.topicId).toBe('t-exist');
-  });
-});