@lobehub/lobehub 2.0.0-next.23 → 2.0.0-next.25

package/src/features/Conversation/Messages/Group/index.tsx

@@ -0,0 +1,140 @@
+'use client';
+
+import { UIChatMessage } from '@lobechat/types';
+import { useResponsive } from 'antd-style';
+import { memo, useCallback } from 'react';
+import { Flexbox } from 'react-layout-kit';
+
+import Avatar from '@/features/ChatItem/components/Avatar';
+import BorderSpacing from '@/features/ChatItem/components/BorderSpacing';
+import Title from '@/features/ChatItem/components/Title';
+import { useStyles } from '@/features/ChatItem/style';
+import GroupChildren from '@/features/Conversation/Messages/Group/GroupChildren';
+import Usage from '@/features/Conversation/components/Extras/Usage';
+import { useOpenChatSettings } from '@/hooks/useInterceptingRoutes';
+import { useAgentStore } from '@/store/agent';
+import { agentChatConfigSelectors } from '@/store/agent/selectors';
+import { useChatStore } from '@/store/chat';
+import { chatSelectors, messageStateSelectors } from '@/store/chat/slices/message/selectors';
+import { useGlobalStore } from '@/store/global';
+import { useSessionStore } from '@/store/session';
+import { sessionSelectors } from '@/store/session/selectors';
+
+import { GroupActionsBar } from './Actions';
+import EditState from './EditState';
+
+const MOBILE_AVATAR_SIZE = 32;
+
+interface GroupMessageProps extends UIChatMessage {
+  disableEditing?: boolean;
+  index: number;
+  showTitle?: boolean;
+}
+
+const GroupMessage = memo<GroupMessageProps>((props) => {
+  const {
+    showTitle,
+    id,
+    disableEditing,
+    usage,
+    index,
+    createdAt,
+    meta,
+    children,
+    performance,
+    model,
+    provider,
+  } = props;
+  const avatar = meta;
+  const { mobile } = useResponsive();
+  const placement = 'left';
+  const type = useAgentStore(agentChatConfigSelectors.displayMode);
+  const variant = type === 'chat' ? 'bubble' : 'docs';
+
+  const { styles } = useStyles({
+    editing: false,
+    placement,
+    primary: false,
+    showTitle,
+    time: createdAt,
+    title: avatar.title,
+    variant,
+  });
+
+  const [isInbox] = useSessionStore((s) => [sessionSelectors.isInboxSession(s)]);
+  const [toggleSystemRole] = useGlobalStore((s) => [s.toggleSystemRole]);
+  const openChatSettings = useOpenChatSettings();
+  const lastAssistantMsg = useChatStore(chatSelectors.getGroupLatestMessageWithoutTools(id));
+
+  const contentId = lastAssistantMsg?.id;
+
+  const isEditing = useChatStore(messageStateSelectors.isMessageEditing(contentId || ''));
+
+  // ======================= Performance Optimization ======================= //
+  // these useMemo/useCallback are all for the performance optimization
+  // maybe we can remove it in React 19
+  // ======================================================================== //
+  const onAvatarClick = useCallback(() => {
+    if (!isInbox) {
+      toggleSystemRole(true);
+    } else {
+      openChatSettings();
+    }
+  }, [isInbox]);
+
+  return (
+    <Flexbox className={styles.container} gap={mobile ? 6 : 12}>
+      <Flexbox gap={4} horizontal>
+        <Avatar
+          alt={avatar.title || 'avatar'}
+          avatar={avatar}
+          onClick={onAvatarClick}
+          placement={placement}
+          size={mobile ? MOBILE_AVATAR_SIZE : undefined}
+          style={{ marginTop: 6 }}
+        />
+        <Title avatar={avatar} placement={placement} showTitle time={createdAt} />
+      </Flexbox>
+      {isEditing && contentId ? (
+        <EditState content={lastAssistantMsg?.content} id={contentId} />
+      ) : (
+        <Flexbox
+          align={'flex-start'}
+          className={styles.messageContent}
+          data-layout={'vertical'}
+          direction={'vertical'}
+          gap={8}
+          width={'100%'}
+        >
+          {children && children.length > 0 && (
+            <GroupChildren
+              blocks={children}
+              contentId={contentId}
+              disableEditing={disableEditing}
+              messageIndex={index}
+            />
+          )}
+
+          {model && (
+            <Usage metadata={{ ...performance, ...usage }} model={model} provider={provider!} />
+          )}
+          {!disableEditing && (
+            <Flexbox align={'flex-start'} className={styles.actions} role="menubar">
+              <GroupActionsBar
+                contentBlock={lastAssistantMsg}
+                contentId={contentId}
+                data={props}
+                id={id}
+                index={index}
+              />
+            </Flexbox>
+          )}
+        </Flexbox>
+      )}
+
+      {mobile && <BorderSpacing borderSpacing={MOBILE_AVATAR_SIZE} />}
+    </Flexbox>
+  );
+});
+
+export default GroupMessage;

package/src/features/Conversation/Messages/index.tsx

@@ -16,6 +16,7 @@ import { chatSelectors, messageStateSelectors } from '@/store/chat/selectors';
 import History from '../components/History';
 import { InPortalThreadContext } from '../context/InPortalThreadContext';
 import AssistantMessage from './Assistant';
+import GroupMessage from './Group';
 import SupervisorMessage from './Supervisor';
 import UserMessage from './User';
 
@@ -132,6 +133,17 @@ const Item = memo<ChatListItemProps>(
           );
         }
 
+        case 'group': {
+          return (
+            <GroupMessage
+              {...item}
+              disableEditing={disableEditing}
+              index={index}
+              showTitle={item.groupId ? true : false}
+            />
+          );
+        }
+
         case 'supervisor': {
           return <SupervisorMessage {...item} disableEditing={disableEditing} index={index} />;
         }

package/src/features/Conversation/components/ShareMessageModal/ShareImage/Preview.tsx

@@ -1,3 +1,4 @@
+import { OFFICIAL_DOMAIN } from '@lobechat/const';
 import { UIChatMessage } from '@lobechat/types';
 import { ModelTag } from '@lobehub/icons';
 import { Avatar } from '@lobehub/ui';
@@ -14,7 +15,6 @@ import { agentSelectors } from '@/store/agent/selectors';
 import { useSessionStore } from '@/store/session';
 import { sessionMetaSelectors, sessionSelectors } from '@/store/session/selectors';
 
-import pkg from '../../../../../../package.json';
 import { useContainerStyles } from '../style';
 import { useStyles } from './style';
 import { FieldType } from './type';
@@ -75,7 +75,7 @@ const Preview = memo<PreviewProps>(
             {withFooter ? (
               <Flexbox align={'center'} className={styles.footer} gap={4}>
                 <ProductLogo type={'combine'} />
-                <div className={styles.url}>{pkg.homepage}</div>
+                <div className={styles.url}>{OFFICIAL_DOMAIN}</div>
               </Flexbox>
             ) : (
               <div />

package/src/locales/default/labs.ts

@@ -1,6 +1,10 @@
 export default {
   desc: '这里会不定期更新我们正在探索的新功能，欢迎试用！',
   features: {
+    assistantMessageGroup: {
+      desc: '将助手消息及其工具调用结果聚合到分组里显示',
+      title: '助手消息聚合分组',
+    },
     groupChat: {
       desc: '启用多智能体群聊编排能力。',
       title: '群聊（多智能体）',

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

@@ -1,7 +1,6 @@
 import {
   CreateMessageParamsSchema,
   CreateNewMessageParamsSchema,
-  UIChatMessage,
   UpdateMessageParamsSchema,
   UpdateMessageRAGParamsSchema,
 } from '@lobechat/types';
@@ -14,8 +13,6 @@ import { authedProcedure, publicProcedure, router } from '@/libs/trpc/lambda';
 import { serverDatabase } from '@/libs/trpc/lambda/middleware';
 import { FileService } from '@/server/services/file';
 
-type ChatMessageList = UIChatMessage[];
-
 const messageProcedure = authedProcedure.use(serverDatabase).use(async (opts) => {
   const { ctx } = opts;
 
@@ -72,22 +69,6 @@ export const messageRouter = router({
       });
     }),
 
-  // TODO: it will be removed in V2
-  getAllMessages: messageProcedure.query(async ({ ctx }): Promise<ChatMessageList> => {
-    return ctx.messageModel.queryAll() as any;
-  }),
-
-  // TODO: it will be removed in V2
-  getAllMessagesInSession: messageProcedure
-    .input(
-      z.object({
-        sessionId: z.string().nullable().optional(),
-      }),
-    )
-    .query(async ({ ctx, input }): Promise<ChatMessageList> => {
-      return ctx.messageModel.queryBySessionId(input.sessionId) as any;
-    }),
-
   getHeatmaps: messageProcedure.query(async ({ ctx }) => {
     return ctx.messageModel.getHeatmaps();
   }),
@@ -101,16 +82,20 @@ 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(input, {
+      return messageModel.query(queryParams, {
+        groupAssistantMessages: useGroup ?? false,
         postProcessUrl: (path) => fileService.getFullFileUrl(path),
       });
     }),

package/src/services/chat/contextEngineering.ts

@@ -1,6 +1,7 @@
 import { isDesktop, isServerMode } from '@lobechat/const';
 import {
   ContextEngine,
+  GroupMessageFlattenProcessor,
   HistorySummaryProvider,
   HistoryTruncateProcessor,
   InputTemplateProcessor,
@@ -28,7 +29,6 @@ interface ContextEngineeringContext {
   historyCount?: number;
   historySummary?: string;
   inputTemplate?: string;
-  isWelcomeQuestion?: boolean;
   messages: UIChatMessage[];
   model: string;
   provider: string;
@@ -78,14 +78,15 @@ export const contextEngineering = async ({
       // Create message processing processors
 
       // 6. Input template processing
-      new InputTemplateProcessor({
-        inputTemplate,
-      }),
+      new InputTemplateProcessor({ inputTemplate }),
 
       // 7. Placeholder variables processing
       new PlaceholderVariablesProcessor({ variableGenerators: VARIABLE_GENERATORS }),
 
-      // 8. Message content processing
+      // 8. Group message flatten (convert role=group to standard assistant + tool messages)
+      new GroupMessageFlattenProcessor(),
+
+      // 8.5 Message content processing
       new MessageContentProcessor({
         fileContext: { enabled: isServerMode, includeFileUrl: !isDesktop },
         isCanUseVideo,

package/src/services/message/server.ts

@@ -3,6 +3,8 @@ import { ChatTranslate, UIChatMessage } from '@lobechat/types';
 
 import { INBOX_SESSION_ID } from '@/const/session';
 import { lambdaClient } from '@/libs/trpc/client';
+import { useUserStore } from '@/store/user';
+import { labPreferSelectors } from '@/store/user/selectors';
 
 import { IMessageService } from './type';
 
@@ -22,33 +24,31 @@ export class ServerService implements IMessageService {
   };
 
   getMessages: IMessageService['getMessages'] = async (sessionId, topicId, groupId) => {
+    // Get user lab preference for message grouping
+    const useGroup = labPreferSelectors.enableAssistantMessageGroup(useUserStore.getState());
+
     const data = await lambdaClient.message.getMessages.query({
       groupId,
       sessionId: this.toDbSessionId(sessionId),
       topicId,
+      useGroup,
     });
 
     return data as unknown as UIChatMessage[];
   };
 
   getGroupMessages: IMessageService['getGroupMessages'] = async (groupId, topicId) => {
+    // Get user lab preference for message grouping
+    const useGroup = labPreferSelectors.enableAssistantMessageGroup(useUserStore.getState());
+
     const data = await lambdaClient.message.getMessages.query({
       groupId,
       topicId,
+      useGroup,
     });
     return data as unknown as UIChatMessage[];
   };
 
-  getAllMessages: IMessageService['getAllMessages'] = async () => {
-    return lambdaClient.message.getAllMessages.query();
-  };
-
-  getAllMessagesInSession: IMessageService['getAllMessagesInSession'] = async (sessionId) => {
-    return lambdaClient.message.getAllMessagesInSession.query({
-      sessionId: this.toDbSessionId(sessionId),
-    });
-  };
-
   countMessages: IMessageService['countMessages'] = async (params) => {
     return lambdaClient.message.count.query(params);
   };

package/src/services/message/type.ts

@@ -21,8 +21,6 @@ export interface IMessageService {
 
   getMessages(sessionId: string, topicId?: string, groupId?: string): Promise<UIChatMessage[]>;
   getGroupMessages(groupId: string, topicId?: string): Promise<UIChatMessage[]>;
-  getAllMessages(): Promise<UIChatMessage[]>;
-  getAllMessagesInSession(sessionId: string): Promise<UIChatMessage[]>;
   countMessages(params?: {
     endDate?: string;
     range?: [string, string];

package/src/store/chat/slices/aiChat/actions/__tests__/generateAIChatV2.test.ts

@@ -541,7 +541,7 @@ describe('generateAIChatV2 actions', () => {
         result.current.cancelSendMessageInServer();
       });
 
-      expect(mockAbort).toHaveBeenCalledWith('User cancelled sendMessageInServer operation');
+      expect(mockAbort).toHaveBeenCalledWith('User cancelled sendMessage operation');
       expect(
         result.current.mainSendMessageOperations[
           messageMapKey(TEST_IDS.SESSION_ID, TEST_IDS.TOPIC_ID)
@@ -571,7 +571,7 @@ describe('generateAIChatV2 actions', () => {
         result.current.cancelSendMessageInServer(customTopicId);
       });
 
-      expect(mockAbort).toHaveBeenCalledWith('User cancelled sendMessageInServer operation');
+      expect(mockAbort).toHaveBeenCalledWith('User cancelled sendMessage operation');
     });
 
     it('should handle gracefully when operation does not exist', () => {
@@ -740,4 +740,311 @@ describe('generateAIChatV2 actions', () => {
       });
     });
   });
+
+  describe('callToolFollowAssistantMessage', () => {
+    const TOOL_RESULT_MSG_ID = 'tool-result-msg-id';
+    const ASSISTANT_BLOCK_ID = 'assistant-block-id';
+    const GROUP_MESSAGE_ID = 'group-message-id';
+    const TOOL_CALL_ID = 'tool-call-id';
+
+    beforeEach(() => {
+      // Reset mocks
+      vi.spyOn(messageService, 'createNewMessage').mockResolvedValue({
+        id: 'new-assistant-block-id',
+        messages: [] as any,
+      });
+    });
+
+    it('should find group message from tool result_msg_id in tools array', async () => {
+      const { result } = renderHook(() => useChatStore());
+      const dispatchSpy = vi.fn();
+
+      // Create a group message structure with tool results
+      const groupMessage: UIChatMessage = {
+        id: GROUP_MESSAGE_ID,
+        role: 'group',
+        content: '',
+        sessionId: TEST_IDS.SESSION_ID,
+        topicId: TEST_IDS.TOPIC_ID,
+        children: [
+          {
+            id: ASSISTANT_BLOCK_ID,
+            content: 'Assistant response',
+            tools: [
+              {
+                id: TOOL_CALL_ID,
+                type: 'builtin',
+                apiName: 'testTool',
+                identifier: 'test-tool',
+                arguments: '{}',
+                result: {
+                  id: TOOL_RESULT_MSG_ID,
+                  content: 'Tool result',
+                },
+                result_msg_id: TOOL_RESULT_MSG_ID,
+              },
+            ],
+          },
+        ],
+      } as any;
+
+      act(() => {
+        useChatStore.setState({
+          activeId: TEST_IDS.SESSION_ID,
+          activeTopicId: TEST_IDS.TOPIC_ID,
+          messagesMap: {
+            [messageMapKey(TEST_IDS.SESSION_ID, TEST_IDS.TOPIC_ID)]: [groupMessage],
+          },
+          internal_execAgentRuntime: vi.fn(),
+          internal_dispatchMessage: dispatchSpy,
+        });
+      });
+
+      await act(async () => {
+        await result.current.callToolFollowAssistantMessage({
+          parentId: TOOL_RESULT_MSG_ID,
+        });
+      });
+
+      // Verify that addGroupBlock was called with the correct groupMessageId
+      expect(dispatchSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: 'addGroupBlock',
+          groupMessageId: GROUP_MESSAGE_ID,
+        }),
+      );
+
+      // Verify that createNewMessage was called with message params
+      expect(messageService.createNewMessage).toHaveBeenCalledWith(
+        expect.objectContaining({
+          role: 'assistant',
+          parentId: TOOL_RESULT_MSG_ID,
+        }),
+      );
+    });
+
+    it('should handle case when tool result is not found in any group message', async () => {
+      const { result } = renderHook(() => useChatStore());
+      const dispatchSpy = vi.fn();
+
+      const groupMessage: UIChatMessage = {
+        id: GROUP_MESSAGE_ID,
+        role: 'group',
+        content: '',
+        sessionId: TEST_IDS.SESSION_ID,
+        children: [
+          {
+            id: ASSISTANT_BLOCK_ID,
+            content: 'Assistant response',
+            tools: [], // No tools
+          },
+        ],
+      } as any;
+
+      act(() => {
+        useChatStore.setState({
+          activeId: TEST_IDS.SESSION_ID,
+          activeTopicId: TEST_IDS.TOPIC_ID,
+          messagesMap: {
+            [messageMapKey(TEST_IDS.SESSION_ID, TEST_IDS.TOPIC_ID)]: [groupMessage],
+          },
+          internal_execAgentRuntime: vi.fn(),
+          internal_dispatchMessage: dispatchSpy,
+        });
+      });
+
+      await act(async () => {
+        await result.current.callToolFollowAssistantMessage({
+          parentId: 'non-existent-tool-result-id',
+        });
+      });
+
+      // Should create message as regular top-level message (createMessage, not addGroupBlock)
+      expect(dispatchSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: 'createMessage',
+        }),
+      );
+
+      expect(messageService.createNewMessage).toHaveBeenCalledWith(
+        expect.objectContaining({
+          role: 'assistant',
+          parentId: 'non-existent-tool-result-id',
+        }),
+      );
+    });
+
+    it('should find group message from nested tool results in multiple children', async () => {
+      const { result } = renderHook(() => useChatStore());
+      const dispatchSpy = vi.fn();
+
+      const groupMessage: UIChatMessage = {
+        id: GROUP_MESSAGE_ID,
+        role: 'group',
+        content: '',
+        sessionId: TEST_IDS.SESSION_ID,
+        children: [
+          {
+            id: 'first-block',
+            content: 'First assistant response',
+            tools: [
+              {
+                id: 'tool-1',
+                type: 'builtin',
+                apiName: 'tool1',
+                identifier: 'tool-1',
+                arguments: '{}',
+                result_msg_id: 'other-result-id',
+              },
+            ],
+          },
+          {
+            id: 'second-block',
+            content: 'Second assistant response',
+            tools: [
+              {
+                id: 'tool-2',
+                type: 'builtin',
+                apiName: 'tool2',
+                identifier: 'tool-2',
+                arguments: '{}',
+                result_msg_id: TOOL_RESULT_MSG_ID, // Target tool result
+              },
+            ],
+          },
+        ],
+      } as any;
+
+      act(() => {
+        useChatStore.setState({
+          activeId: TEST_IDS.SESSION_ID,
+          messagesMap: {
+            [messageMapKey(TEST_IDS.SESSION_ID, TEST_IDS.TOPIC_ID)]: [groupMessage],
+          },
+          internal_execAgentRuntime: vi.fn(),
+          internal_dispatchMessage: dispatchSpy,
+        });
+      });
+
+      await act(async () => {
+        await result.current.callToolFollowAssistantMessage({
+          parentId: TOOL_RESULT_MSG_ID,
+        });
+      });
+
+      // Should find the correct group message even with multiple children
+      expect(dispatchSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: 'addGroupBlock',
+          groupMessageId: GROUP_MESSAGE_ID,
+        }),
+      );
+    });
+
+    it('should call internal_execAgentRuntime after creating assistant message', async () => {
+      const { result } = renderHook(() => useChatStore());
+      const mockExecAgentRuntime = vi.fn();
+
+      const groupMessage: UIChatMessage = {
+        id: GROUP_MESSAGE_ID,
+        role: 'group',
+        content: '',
+        sessionId: TEST_IDS.SESSION_ID,
+        children: [
+          {
+            id: ASSISTANT_BLOCK_ID,
+            content: 'Response',
+            tools: [
+              {
+                id: TOOL_CALL_ID,
+                type: 'builtin',
+                apiName: 'test',
+                identifier: 'test',
+                arguments: '{}',
+                result_msg_id: TOOL_RESULT_MSG_ID,
+              },
+            ],
+          },
+        ],
+      } as any;
+
+      act(() => {
+        useChatStore.setState({
+          activeId: TEST_IDS.SESSION_ID,
+          messagesMap: {
+            [messageMapKey(TEST_IDS.SESSION_ID, TEST_IDS.TOPIC_ID)]: [groupMessage],
+          },
+          internal_execAgentRuntime: mockExecAgentRuntime,
+        });
+      });
+
+      await act(async () => {
+        await result.current.callToolFollowAssistantMessage({
+          parentId: TOOL_RESULT_MSG_ID,
+          traceId: 'test-trace-id',
+          threadId: 'test-thread-id',
+        });
+      });
+
+      expect(mockExecAgentRuntime).toHaveBeenCalledWith(
+        expect.objectContaining({
+          assistantMessageId: 'new-assistant-block-id',
+          traceId: 'test-trace-id',
+          threadId: 'test-thread-id',
+        }),
+      );
+    });
+
+    it('should handle missing result_msg_id field gracefully', async () => {
+      const { result } = renderHook(() => useChatStore());
+      const dispatchSpy = vi.fn();
+
+      const groupMessage: UIChatMessage = {
+        id: GROUP_MESSAGE_ID,
+        role: 'group',
+        content: '',
+        sessionId: TEST_IDS.SESSION_ID,
+        children: [
+          {
+            id: ASSISTANT_BLOCK_ID,
+            content: 'Response',
+            tools: [
+              {
+                id: TOOL_CALL_ID,
+                type: 'builtin',
+                apiName: 'test',
+                identifier: 'test',
+                arguments: '{}',
+                // Missing result_msg_id
+              },
+            ],
+          },
+        ],
+      } as any;
+
+      act(() => {
+        useChatStore.setState({
+          activeId: TEST_IDS.SESSION_ID,
+          messagesMap: {
+            [messageMapKey(TEST_IDS.SESSION_ID, TEST_IDS.TOPIC_ID)]: [groupMessage],
+          },
+          internal_execAgentRuntime: vi.fn(),
+          internal_dispatchMessage: dispatchSpy,
+        });
+      });
+
+      await act(async () => {
+        await result.current.callToolFollowAssistantMessage({
+          parentId: TOOL_RESULT_MSG_ID,
+        });
+      });
+
+      // Should create as regular message since no groupMessageId found
+      expect(dispatchSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: 'createMessage',
+        }),
+      );
+    });
+  });
 });