@lobehub/lobehub 2.0.0-next.34 → 2.0.0-next.36

package/packages/conversation-flow/src/transformation/FlatListBuilder.ts

@@ -165,18 +165,74 @@ export class FlatListBuilder {
           childMessages,
           this.childrenMap,
         );
-        const userWithBranches = this.createUserMessageWithBranches(message);
+        const activeBranchIndex = childMessages.indexOf(activeBranchId);
+        const userWithBranches = this.createUserMessageWithBranches(
+          message,
+          childMessages.length,
+          activeBranchIndex,
+        );
         flatList.push(userWithBranches);
         processedIds.add(message.id);
 
-        // Continue with active branch and process its message
+        // Continue with active branch - check if it's an assistantGroup
         const activeBranchMsg = this.messageMap.get(activeBranchId);
         if (activeBranchMsg) {
-          flatList.push(activeBranchMsg);
-          processedIds.add(activeBranchId);
-
-          // Continue with active branch's children
-          this.buildFlatListRecursive(activeBranchId, flatList, processedIds, allMessages);
+          // Check if active branch is assistant with tools (should be assistantGroup)
+          if (
+            activeBranchMsg.role === 'assistant' &&
+            activeBranchMsg.tools &&
+            activeBranchMsg.tools.length > 0
+          ) {
+            // Collect the entire assistant group chain
+            const assistantChain: Message[] = [];
+            const allToolMessages: Message[] = [];
+            this.messageCollector.collectAssistantChain(
+              activeBranchMsg,
+              allMessages,
+              assistantChain,
+              allToolMessages,
+              processedIds,
+            );
+
+            // Create assistantGroup virtual message
+            const groupMessage = this.createAssistantGroupMessage(
+              assistantChain[0],
+              assistantChain,
+              allToolMessages,
+            );
+            flatList.push(groupMessage);
+
+            // Mark all as processed
+            assistantChain.forEach((m) => processedIds.add(m.id));
+            allToolMessages.forEach((m) => processedIds.add(m.id));
+
+            // Continue after the assistant chain
+            const lastAssistant = assistantChain.at(-1);
+            const toolIds = new Set(allToolMessages.map((t) => t.id));
+
+            const lastAssistantNonToolChildren = lastAssistant
+              ? this.childrenMap.get(lastAssistant.id)?.filter((childId) => !toolIds.has(childId))
+              : undefined;
+
+            if (
+              lastAssistantNonToolChildren &&
+              lastAssistantNonToolChildren.length > 0 &&
+              lastAssistant
+            ) {
+              this.buildFlatListRecursive(lastAssistant.id, flatList, processedIds, allMessages);
+            } else {
+              for (const toolMsg of allToolMessages) {
+                this.buildFlatListRecursive(toolMsg.id, flatList, processedIds, allMessages);
+              }
+            }
+          } else {
+            // Regular message (not assistantGroup)
+            flatList.push(activeBranchMsg);
+            processedIds.add(activeBranchId);
+
+            // Continue with active branch's children
+            this.buildFlatListRecursive(activeBranchId, flatList, processedIds, allMessages);
+          }
         }
         continue;
       }
@@ -364,58 +420,80 @@ export class FlatListBuilder {
         assistant.tools?.map((tool) => {
           const toolMsg = toolMap.get(tool.id);
           if (toolMsg) {
+            const result: any = {
+              content: toolMsg.content || '',
+              id: toolMsg.id,
+            };
+            if (toolMsg.error) result.error = toolMsg.error;
+            if (toolMsg.pluginState) result.state = toolMsg.pluginState;
+
             return {
               ...tool,
-              result: {
-                content: toolMsg.content || '',
-                error: toolMsg.error,
-                id: toolMsg.id,
-                state: toolMsg.pluginState,
-              },
+              result,
               result_msg_id: toolMsg.id,
             };
           }
           return tool;
         }) || [];
 
-      const { usage: msgUsage, performance: msgPerformance } =
+      // Prefer top-level usage/performance fields, fall back to metadata
+      const { usage: metaUsage, performance: metaPerformance } =
         this.messageTransformer.splitMetadata(assistant.metadata);
+      const msgUsage = assistant.usage || metaUsage;
+      const msgPerformance = assistant.performance || metaPerformance;
 
-      children.push({
+      const childBlock: AssistantContentBlock = {
         content: assistant.content || '',
-        error: assistant.error,
         id: assistant.id,
-        imageList:
-          assistant.imageList && assistant.imageList.length > 0 ? assistant.imageList : undefined,
-        performance: msgPerformance,
-        reasoning: assistant.reasoning || undefined,
-        tools: toolsWithResults.length > 0 ? toolsWithResults : undefined,
-        usage: msgUsage,
-      });
+      } as AssistantContentBlock;
+
+      if (assistant.error) childBlock.error = assistant.error;
+      if (assistant.imageList && assistant.imageList.length > 0)
+        childBlock.imageList = assistant.imageList;
+      if (msgPerformance) childBlock.performance = msgPerformance;
+      if (assistant.reasoning) childBlock.reasoning = assistant.reasoning;
+      if (toolsWithResults.length > 0) childBlock.tools = toolsWithResults;
+      if (msgUsage) childBlock.usage = msgUsage;
+
+      children.push(childBlock);
     }
 
     const aggregated = this.messageTransformer.aggregateMetadata(children);
 
-    return {
+    const result: Message = {
       ...firstAssistant,
       children,
       content: '',
-      imageList: undefined,
-      metadata: undefined,
-      performance: aggregated.performance,
-      reasoning: undefined,
       role: 'assistantGroup' as any,
-      tools: undefined,
-      usage: aggregated.usage,
     };
+
+    // Remove fields that should not be in assistantGroup
+    delete result.imageList;
+    delete result.metadata;
+    delete result.reasoning;
+    delete result.tools;
+
+    // Add aggregated fields if they exist
+    if (aggregated.performance) result.performance = aggregated.performance;
+    if (aggregated.usage) result.usage = aggregated.usage;
+
+    return result;
   }
 
   /**
    * Create user message with branch metadata
    */
-  private createUserMessageWithBranches(user: Message): Message {
-    // Just return the original user message with its metadata.activeBranchId
-    // No need to add extra.branches
-    return { ...user };
+  private createUserMessageWithBranches(
+    user: Message,
+    count: number,
+    activeBranchIndex: number,
+  ): Message {
+    return {
+      ...user,
+      branch: {
+        activeBranchIndex,
+        count,
+      },
+    } as Message;
   }
 }

package/packages/conversation-flow/src/types/flatMessageList.ts

@@ -41,22 +41,10 @@ export type FlatMessageRole =
  */
 export type FlatMessage = UIChatMessage;
 
-/**
- * Branch metadata attached to user messages
- */
-export interface BranchMetadata {
-  /** Active branch message ID */
-  activeId: string;
-  /** All branch message IDs */
-  branchIds: string[];
-}
-
 /**
  * Virtual message extra fields for flat list
  */
 export interface FlatMessageExtra {
-  /** Branch information for user messages with multiple children */
-  branches?: BranchMetadata;
   /** Optional description for groups */
   description?: string;
   /** Group mode for messageGroup and compare virtual messages */

package/packages/conversation-flow/src/{types.ts → types/index.ts}

@@ -16,21 +16,10 @@ export type {
   CompareNode,
   ContextNode,
   MessageNode,
-} from './types/contextTree';
+} from './contextTree';
 
 // Flat Message List Types
-export type {
-  BranchMetadata,
-  FlatMessage,
-  FlatMessageExtra,
-  FlatMessageRole,
-} from './types/flatMessageList';
+export type { FlatMessage, FlatMessageExtra, FlatMessageRole } from './flatMessageList';
 
 // Shared Types
-export type {
-  HelperMaps,
-  IdNode,
-  Message,
-  MessageGroupMetadata,
-  ParseResult,
-} from './types/shared';
+export type { HelperMaps, IdNode, Message, MessageGroupMetadata, ParseResult } from './shared';

package/packages/database/src/models/message.ts

@@ -40,7 +40,6 @@ import {
 } from '../schemas';
 import { LobeChatDatabase } from '../type';
 import { genEndDateWhere, genRangeWhere, genStartDateWhere, genWhere } from '../utils/genWhere';
-import { groupAssistantMessages } from '../utils/groupMessages';
 import { idGenerator } from '../utils/idGenerator';
 
 export class MessageModel {
@@ -227,8 +226,8 @@ export class MessageModel {
             })),
 
           extra: {
-            fromModel: model,
-            fromProvider: provider,
+            model: model,
+            provider: provider,
             translate,
             tts: ttsId
               ? {
@@ -269,9 +268,7 @@ export class MessageModel {
       },
     );
 
-    // Group assistant messages with their tool results
-    const { groupAssistantMessages: useGroup = false } = options;
-    return useGroup ? groupAssistantMessages(mappedMessages) : mappedMessages;
+    return mappedMessages;
   };
 
   findById = async (id: string) => {
@@ -464,8 +461,8 @@ export class MessageModel {
 
   create = async (
     {
-      fromModel,
-      fromProvider,
+      model: fromModel,
+      provider: fromProvider,
       files,
       plugin,
       pluginState,
@@ -771,17 +768,19 @@ export class MessageModel {
     sessionId?: string | null,
     topicId?: string | null,
     groupId?: string | null,
-  ) =>
-    this.db
-      .delete(messages)
-      .where(
-        and(
-          eq(messages.userId, this.userId),
-          this.matchSession(sessionId),
-          this.matchTopic(topicId),
-          this.matchGroup(groupId),
-        ),
-      );
+  ) => {
+    const conditions = [eq(messages.userId, this.userId), this.matchSession(sessionId)];
+
+    // For deletion: only filter by topicId/groupId if explicitly provided
+    if (topicId !== undefined && topicId !== null) {
+      conditions.push(eq(messages.topicId, topicId));
+    }
+    if (groupId !== undefined && groupId !== null) {
+      conditions.push(eq(messages.groupId, groupId));
+    }
+
+    return this.db.delete(messages).where(and(...conditions));
+  };
 
   deleteAllMessages = async () => {
     return this.db.delete(messages).where(eq(messages.userId, this.userId));

package/packages/types/src/aiChat.ts

@@ -9,6 +9,7 @@ export interface SendNewMessage {
   content: string;
   // if message has attached with files, then add files to message and the agent
   files?: string[];
+  parentId?: string;
 }
 
 export interface SendMessageServerParams {
@@ -41,6 +42,7 @@ export const AiSendMessageServerSchema = z.object({
   newUserMessage: z.object({
     content: z.string(),
     files: z.array(z.string()).optional(),
+    parentId: z.string().optional(),
   }),
   sessionId: z.string().optional(),
   threadId: z.string().optional(),

package/packages/types/src/importer.ts

@@ -28,8 +28,8 @@ export interface ImportMessage {
 
   // 扩展字段
   extra?: {
-    fromModel?: string;
-    fromProvider?: string;
+    model?: string;
+    provider?: string;
     // 翻译
     translate?: ChatTranslate | false | null;
     // TTS

package/packages/types/src/message/ui/chat.ts

@@ -13,7 +13,13 @@ import { ChatMessageExtra } from './extra';
 import { ChatFileChunk } from './rag';
 import { ChatVideoItem } from './video';
 
-export type UIMessageRoleType = 'user' | 'system' | 'assistant' | 'tool' | 'supervisor' | 'group';
+export type UIMessageRoleType =
+  | 'user'
+  | 'system'
+  | 'assistant'
+  | 'tool'
+  | 'supervisor'
+  | 'assistantGroup';
 
 export interface ChatFileItem {
   content?: string;
@@ -34,10 +40,20 @@ export interface AssistantContentBlock {
   tools?: ChatToolPayloadWithResult[];
   usage?: ModelUsage;
 }
+interface UIMessageBranch {
+  /** Index of the active branch (0-based) */
+  activeBranchIndex: number;
+  /** Total number of branches */
+  count: number;
+}
 
 export interface UIChatMessage {
   // Group chat fields (alphabetically before other fields)
   agentId?: string | 'supervisor';
+  /**
+   * Branch information for user messages with multiple children
+   */
+  branch?: UIMessageBranch;
   /**
    * children messages for grouped display
    * Used to group tool messages under their parent assistant message

package/packages/types/src/message/ui/extra.ts

@@ -7,8 +7,8 @@ export interface ChatTTS {
 }
 
 export interface ChatMessageExtra {
-  fromModel?: string;
-  fromProvider?: string;
+  model?: string;
+  provider?: string;
   // 翻译
   translate?: ChatTranslate | false | null;
   // TTS

package/packages/types/src/message/ui/params.ts

@@ -16,8 +16,8 @@ export interface CreateMessageParams
   error?: ChatMessageError | null;
   fileChunks?: MessageSemanticSearchChunk[];
   files?: string[];
-  fromModel?: string;
-  fromProvider?: string;
+  model?: string;
+  provider?: string;
   groupId?: string;
   role: CreateMessageRoleType;
   sessionId: string;

package/packages/types/src/user/preference.ts

@@ -35,10 +35,6 @@ export const UserGuideSchema = z.object({
 export type UserGuide = z.infer<typeof UserGuideSchema>;
 
 export const UserLabSchema = z.object({
-  /**
-   * enable assistant message grouping in chat display
-   */
-  enableAssistantMessageGroup: z.boolean().optional(),
   /**
    * enable multi-agent group chat mode
    */

package/packages/utils/src/tokenizer/index.ts

@@ -1,15 +1,7 @@
+import { estimateTokenCount } from 'tokenx';
+
 export const encodeAsync = async (str: string): Promise<number> => {
   if (str.length === 0) return 0;
 
-  // use gpt-tokenizer under 10000 str
-  // use approximation way if large then 10000
-  if (str.length <= 10_000) {
-    const { clientEncodeAsync } = await import('./client');
-
-    return await clientEncodeAsync(str);
-  } else {
-    const { estimatedEncodeAsync } = await import('./estimated');
-
-    return await estimatedEncodeAsync(str);
-  }
+  return estimateTokenCount(str);
 };

package/src/app/[variants]/(main)/chat/ChatRouter.tsx

@@ -0,0 +1,83 @@
+'use client';
+
+import { memo, useEffect } from 'react';
+import { useMediaQuery } from 'react-responsive';
+import { MemoryRouter, Navigate, Route, Routes, useLocation, useNavigate } from 'react-router-dom';
+
+import MainChatPage from './components/MainChatPage';
+import SettingsPage from './components/SettingsPage';
+
+// Get initial path from URL
+const getInitialPath = () => {
+  if (typeof window === 'undefined') return '/';
+  const fullPath = window.location.pathname;
+  const searchParams = window.location.search;
+  const chatIndex = fullPath.indexOf('/chat');
+
+  if (chatIndex !== -1) {
+    const pathAfterChat = fullPath.slice(chatIndex + '/chat'.length) || '/';
+    return pathAfterChat + searchParams;
+  }
+  return '/';
+};
+
+// Helper component to sync URL with MemoryRouter
+const UrlSynchronizer = () => {
+  const location = useLocation();
+  const navigate = useNavigate();
+
+  // Sync initial URL
+  useEffect(() => {
+    const fullPath = window.location.pathname;
+    const searchParams = window.location.search;
+    const chatIndex = fullPath.indexOf('/chat');
+
+    if (chatIndex !== -1) {
+      const pathAfterChat = fullPath.slice(chatIndex + '/chat'.length) || '/';
+      const targetPath = pathAfterChat + searchParams;
+
+      if (location.pathname + location.search !== targetPath) {
+        navigate(targetPath, { replace: true });
+      }
+    }
+  }, []);
+
+  // Update browser URL when location changes
+  useEffect(() => {
+    const normalizedPath = location.pathname === '/' ? '' : location.pathname;
+    const newUrl = `/chat${normalizedPath}${location.search}`;
+    if (window.location.pathname + window.location.search !== newUrl) {
+      window.history.replaceState({}, '', newUrl);
+    }
+  }, [location.pathname, location.search]);
+
+  return null;
+};
+
+const ChatRouter = memo(() => {
+  const mobile = useMediaQuery({ maxWidth: 768 });
+  const routes = (
+    <Routes>
+      <Route element={<MainChatPage mobile={true} />} path="/" />
+      <Route element={<SettingsPage mobile={true} />} path="/settings" />
+      <Route element={<Navigate replace to="/" />} path="*" />
+    </Routes>
+  );
+
+  return (
+    <MemoryRouter initialEntries={[getInitialPath()]} initialIndex={0}>
+      <UrlSynchronizer />
+      {mobile ? (
+        // Mobile Layout
+        routes
+      ) : (
+        // Desktop Layout
+        <MainChatPage mobile={false} />
+      )}
+    </MemoryRouter>
+  );
+});
+
+ChatRouter.displayName = 'ChatRouter';
+
+export default ChatRouter;

package/src/app/[variants]/(main)/chat/_layout/ChatLayout.tsx

@@ -0,0 +1,22 @@
+'use client';
+
+import { PropsWithChildren, memo } from 'react';
+
+import Desktop from './Desktop';
+import Mobile from './Mobile';
+
+interface ChatLayoutProps extends PropsWithChildren {
+  mobile?: boolean;
+}
+
+const ChatLayout = memo<ChatLayoutProps>(({ children, mobile }) => {
+  if (mobile) {
+    return <Mobile>{children}</Mobile>;
+  }
+
+  return <Desktop>{children}</Desktop>;
+});
+
+ChatLayout.displayName = 'ChatLayout';
+
+export default ChatLayout;

package/src/app/[variants]/(main)/chat/_layout/Desktop/SessionPanel.tsx

@@ -3,7 +3,7 @@
 import { DraggablePanel, DraggablePanelContainer, type DraggablePanelProps } from '@lobehub/ui';
 import { createStyles, useResponsive, useThemeMode } from 'antd-style';
 import isEqual from 'fast-deep-equal';
-import { PropsWithChildren, memo, useEffect, useMemo, useState } from 'react';
+import { memo, useEffect, useMemo, useState } from 'react';
 
 import { withSuspense } from '@/components/withSuspense';
 import { FOLDER_WIDTH } from '@/const/layoutTokens';
@@ -12,6 +12,7 @@ import { usePinnedAgentState } from '@/hooks/usePinnedAgentState';
 import { useGlobalStore } from '@/store/global';
 import { systemStatusSelectors } from '@/store/global/selectors';
 
+import SessionPanelContent from '../../components/SessionPanel';
 import { TOOGLE_PANEL_BUTTON_ID } from '../../features/TogglePanelButton';
 
 export const useStyles = createStyles(({ css, token }) => ({
@@ -33,7 +34,7 @@ export const useStyles = createStyles(({ css, token }) => ({
   `,
 }));
 
-const SessionPanel = memo<PropsWithChildren>(({ children }) => {
+const SessionPanel = memo(() => {
   const isSingleMode = useIsSingleMode();
 
   const { md = true } = useResponsive();
@@ -75,11 +76,15 @@ const SessionPanel = memo<PropsWithChildren>(({ children }) => {
 
   const { appearance } = useThemeMode();
 
-  const SessionPanel = useMemo(() => {
+  const PanelContent = useMemo(() => {
     if (isSingleMode) {
-      // 在单一模式下，仍然渲染 children 以确保 SessionHydration 等逻辑组件正常工作
+      // 在单一模式下，仍然渲染 SessionPanelContent 以确保 SessionHydration 等逻辑组件正常工作
       // 但使用隐藏样式而不是 return null
-      return <div style={{ display: 'none' }}>{children}</div>;
+      return (
+        <div style={{ display: 'none' }}>
+          <SessionPanelContent mobile={false} />
+        </div>
+      );
     }
 
     return (
@@ -98,13 +103,13 @@ const SessionPanel = memo<PropsWithChildren>(({ children }) => {
         size={{ height: '100%', width: sessionsWidth }}
       >
         <DraggablePanelContainer style={{ flex: 'none', height: '100%', minWidth: FOLDER_WIDTH }}>
-          {children}
+          <SessionPanelContent mobile={false} />
         </DraggablePanelContainer>
       </DraggablePanel>
     );
   }, [sessionsWidth, md, isPinned, sessionExpandable, tmpWidth, appearance, isSingleMode]);
 
-  return SessionPanel;
+  return PanelContent;
 });
 
 export default withSuspense(SessionPanel);

package/src/app/[variants]/(main)/chat/_layout/Desktop/index.tsx

@@ -9,7 +9,7 @@ import RegisterHotkeys from './RegisterHotkeys';
 import SessionPanel from './SessionPanel';
 import Workspace from './Workspace';
 
-const Layout = ({ children, session }: LayoutProps) => {
+const Layout = ({ children }: LayoutProps) => {
   return (
     <>
       <Flexbox
@@ -18,7 +18,7 @@ const Layout = ({ children, session }: LayoutProps) => {
         style={{ maxWidth: '100%', overflow: 'hidden', position: 'relative' }}
         width={'100%'}
       >
-        <SessionPanel>{session}</SessionPanel>
+        <SessionPanel />
         <Workspace>{children}</Workspace>
       </Flexbox>
       {/* ↓ cloud slot ↓ */}

package/src/app/[variants]/(main)/chat/_layout/FeatureFlagsProvider.tsx

@@ -0,0 +1,24 @@
+'use client';
+
+import { PropsWithChildren, createContext, useContext } from 'react';
+
+interface FeatureFlags {
+  hideDocs?: boolean;
+  showChangelog?: boolean;
+}
+
+const FeatureFlagsContext = createContext<FeatureFlags>({});
+
+export const useFeatureFlags = () => useContext(FeatureFlagsContext);
+
+export const FeatureFlagsProvider = ({
+  children,
+  hideDocs,
+  showChangelog,
+}: PropsWithChildren<FeatureFlags>) => {
+  return (
+    <FeatureFlagsContext.Provider value={{ hideDocs, showChangelog }}>
+      {children}
+    </FeatureFlagsContext.Provider>
+  );
+};

package/src/app/[variants]/(main)/chat/_layout/Mobile.tsx

@@ -7,6 +7,7 @@ import { Flexbox } from 'react-layout-kit';
 import { withSuspense } from '@/components/withSuspense';
 import { useShowMobileWorkspace } from '@/hooks/useShowMobileWorkspace';
 
+import SessionPanelContent from '../components/SessionPanel';
 import { LayoutProps } from './type';
 
 const useStyles = createStyles(({ css, token }) => ({
@@ -17,7 +18,7 @@ const useStyles = createStyles(({ css, token }) => ({
   `,
 }));
 
-const Layout = memo<LayoutProps>(({ children, session }) => {
+const Layout = memo<LayoutProps>(({ children }) => {
   const showMobileWorkspace = useShowMobileWorkspace();
   const { styles } = useStyles();
 
@@ -29,7 +30,7 @@ const Layout = memo<LayoutProps>(({ children, session }) => {
         style={showMobileWorkspace ? { display: 'none' } : undefined}
         width="100%"
       >
-        {session}
+        <SessionPanelContent mobile />
       </Flexbox>
       <Flexbox
         className={styles.main}

package/src/app/[variants]/(main)/chat/_layout/type.ts

@@ -2,5 +2,4 @@ import { ReactNode } from 'react';
 
 export interface LayoutProps {
   children: ReactNode;
-  session: ReactNode;
 }