@lobehub/lobehub 2.0.0-next.327 → 2.0.0-next.328

package/packages/builtin-tool-gtd/src/types.ts

@@ -14,43 +14,25 @@ export const GTDApiName = {
   /** Clear completed or all todos */
   clearTodos: 'clearTodos',
 
-  
   // ==================== Planning ====================
-/** Create a structured plan by breaking down a goal into actionable steps */
-createPlan: 'createPlan',
+  /** Create a structured plan by breaking down a goal into actionable steps */
+  createPlan: 'createPlan',
 
-  
-  
+  /** Create new todo items */
+  createTodos: 'createTodos',
 
-/** Create new todo items */
-createTodos: 'createTodos',
+  // ==================== Async Tasks ====================
+  /** Execute a single async task */
+  execTask: 'execTask',
 
-  
-  
-  
-// ==================== Async Tasks ====================
-/** Execute a single async task */
-execTask: 'execTask',
+  /** Execute one or more async tasks */
+  execTasks: 'execTasks',
 
-  
-  
+  /** Update an existing plan */
+  updatePlan: 'updatePlan',
 
-
-/** Execute one or more async tasks */
-execTasks: 'execTasks',
-
-  
-  
-  
-
-
-/** Update an existing plan */
-updatePlan: 'updatePlan',
-
-  
-  
-/** Update todo items with batch operations (add, update, remove, complete, processing) */
-updateTodos: 'updateTodos',
+  /** Update todo items with batch operations (add, update, remove, complete, processing) */
+  updateTodos: 'updateTodos',
 } as const;
 
 export type GTDApiNameType = (typeof GTDApiName)[keyof typeof GTDApiName];
@@ -258,6 +240,14 @@ export interface ExecTaskItem {
   inheritMessages?: boolean;
   /** Detailed instruction/prompt for the task execution */
   instruction: string;
+  /**
+   * Whether to execute the task on the client side (desktop only).
+   * When true and running on desktop, the task will be executed locally
+   * with access to local tools (file system, shell commands, etc.).
+   *
+   * MUST be true when task requires local-system tools.
+   */
+  runInClient?: boolean;
   /** Timeout in milliseconds (optional, default 30 minutes) */
   timeout?: number;
 }
@@ -273,6 +263,14 @@ export interface ExecTaskParams {
   inheritMessages?: boolean;
   /** Detailed instruction/prompt for the task execution */
   instruction: string;
+  /**
+   * Whether to execute the task on the client side (desktop only).
+   * When true and running on desktop, the task will be executed locally
+   * with access to local tools (file system, shell commands, etc.).
+   *
+   * MUST be true when task requires local-system tools.
+   */
+  runInClient?: boolean;
   /** Timeout in milliseconds (optional, default 30 minutes) */
   timeout?: number;
 }
@@ -287,7 +285,7 @@ export interface ExecTasksParams {
 }
 
 /**
- * State returned after triggering exec_task
+ * State returned after triggering exec_task (server-side)
  */
 export interface ExecTaskState {
   /** Parent message ID (tool message) */
@@ -299,7 +297,7 @@ export interface ExecTaskState {
 }
 
 /**
- * State returned after triggering exec_tasks
+ * State returned after triggering exec_tasks (server-side)
  */
 export interface ExecTasksState {
   /** Parent message ID (tool message) */
@@ -309,3 +307,27 @@ export interface ExecTasksState {
   /** Type identifier for render component */
   type: 'execTasks';
 }
+
+/**
+ * State returned after triggering exec_client_task (client-side, desktop only)
+ */
+export interface ExecClientTaskState {
+  /** Parent message ID (tool message) */
+  parentMessageId: string;
+  /** The task definition that was triggered */
+  task: ExecTaskItem;
+  /** Type identifier for render component */
+  type: 'execClientTask';
+}
+
+/**
+ * State returned after triggering exec_client_tasks (client-side, desktop only)
+ */
+export interface ExecClientTasksState {
+  /** Parent message ID (tool message) */
+  parentMessageId: string;
+  /** Array of task definitions that were triggered */
+  tasks: ExecTaskItem[];
+  /** Type identifier for render component */
+  type: 'execClientTasks';
+}

package/packages/builtin-tool-local-system/src/client/Inspector/ReadLocalFile/index.tsx

@@ -15,6 +15,7 @@ const styles = createStaticStyles(({ css }) => ({
   lineRange: css`
     flex-shrink: 0;
     margin-inline-start: 4px;
+    font-size: 12px;
     opacity: 0.7;
   `,
 }));

package/packages/builtin-tool-local-system/src/client/Inspector/RunCommand/index.tsx

@@ -47,7 +47,7 @@ export const RunCommandInspector = memo<BuiltinInspectorProps<RunCommandParams,
 
     // Get execution result from pluginState
     const result = pluginState?.result;
-    const isSuccess = result?.success && result?.exit_code === 0;
+    const isSuccess = result?.success || result?.exit_code === 0;
 
     return (
       <div className={cx(inspectorTextStyles.root, isLoading && shinyTextStyles.shinyText)}>

package/packages/builtin-tool-local-system/src/client/Render/WriteFile/index.tsx

@@ -32,7 +32,7 @@ const WriteFile = memo<BuiltinRenderProps<WriteLocalFileParams>>(({ args }) => {
 
     if (ext === 'md' || ext === 'mdx') {
       return (
-        <Markdown style={{ maxHeight: 240, overflow: 'auto', padding: '0 8px' }}>
+        <Markdown style={{ maxHeight: 240, overflow: 'auto', padding: '0 8px' }} variant={'chat'}>
           {args.content}
         </Markdown>
       );

package/packages/builtin-tool-local-system/src/client/Streaming/WriteFile/index.tsx

@@ -19,7 +19,11 @@ export const WriteFileStreaming = memo<BuiltinStreamingProps<WriteLocalFileParam
 
   // Use Markdown for .md files, Highlighter for others
   if (ext === 'md' || ext === 'mdx') {
-    return <Markdown style={{ overflow: 'auto' }}>{content}</Markdown>;
+    return (
+      <Markdown animated style={{ overflow: 'auto' }} variant={'chat'}>
+        {content}
+      </Markdown>
+    );
   }
 
   return (

package/packages/builtin-tool-notebook/src/systemRole.ts

@@ -12,11 +12,17 @@ Note: The list of existing documents is automatically provided in the context, s
 
 <when_to_use>
 **Save to Notebook when**:
-- Creating reports, analyses, or summaries that should persist
 - User explicitly asks to "save", "write down", or "document" something
-- Generating structured content like articles, notes, or reports
-- Web browsing results worth keeping for later reference
-- Any content the user might want to review or edit later
+- Creating substantial content meant to persist (reports, articles, analyses)
+- Generating structured deliverables the user will likely reference later
+- Web browsing results worth keeping for future reference
+
+**Do NOT save to Notebook when**:
+- User asks a simple question (just answer directly)
+- Providing explanations, tutorials, or how-to responses
+- Having casual conversations or discussions
+- Content is short, temporary, or doesn't need persistence
+- User didn't request saving and the content isn't a clear deliverable
 
 **Document Types**:
 - markdown: General formatted text (default)
@@ -44,8 +50,22 @@ Note: The list of existing documents is automatically provided in the context, s
 
 <response_format>
 After creating/updating documents:
-- Briefly confirm the action: "Saved to Notebook: [title]"
-- Don't repeat the full content in your response
-- Mention that user can view/edit in the Portal sidebar
+- Confirm the action briefly: "Saved to Notebook: [title]"
+- Provide a short summary (2-4 bullet points max) highlighting only the key takeaways
+- NEVER repeat or rephrase the full document content - the user just saw it being created
+- Optionally mention they can view/edit in the sidebar
+
+❌ Bad (repeating content):
+"I've saved 'Project Plan' which covers the three-phase implementation approach. Phase 1 focuses on user research and requirements gathering from March to April. Phase 2 involves design and prototyping from May to June. Phase 3 covers development and testing from July to September..."
+
+✅ Good (brief summary):
+"Saved to Notebook: Project Plan
+
+Key points:
+- 3-phase approach: Research → Design → Development
+- Timeline: March - September
+- 5 team members involved
+
+You can edit it in the sidebar."
 </response_format>
 `;

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

@@ -31,8 +31,20 @@ export class FlatListBuilder {
     const flatList: Message[] = [];
     const processedIds = new Set<string>();
 
+    // Determine the root parentId
+    // Normal case: start from null (messages with no parentId)
+    // Orphan case: if all messages have parentId (thread mode), use first message as root
+    let rootParentId: string | null = null;
+
+    const hasRootMessages = this.childrenMap.has(null) && this.childrenMap.get(null)!.length > 0;
+    if (!hasRootMessages && messages.length > 0) {
+      // All messages have parentId - this is orphan/thread mode
+      // Use the first message's parentId as the virtual root
+      rootParentId = messages[0].parentId ?? null;
+    }
+
     // Build the active path by traversing from root
-    this.buildFlatListRecursive(null, flatList, processedIds, messages);
+    this.buildFlatListRecursive(rootParentId, flatList, processedIds, messages);
 
     return flatList;
   }

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

@@ -517,5 +517,45 @@ describe('FlatListBuilder', () => {
       // User message should not have branch info since we're in optimistic update mode
       expect((result[0] as any).siblingCount).toBeUndefined();
     });
+
+    it('should handle orphan messages where all have parentId (thread mode)', () => {
+      // Scenario: Thread messages where the parent (source message) is not in the query result
+      // All messages have parentId pointing to a message not in the array
+      const messages: Message[] = [
+        {
+          content: 'Thread user message',
+          createdAt: 0,
+          id: 'msg-1',
+          parentId: 'source-msg-not-in-array',
+          role: 'user',
+          updatedAt: 0,
+        },
+        {
+          content: 'Thread assistant reply',
+          createdAt: 0,
+          id: 'msg-2',
+          parentId: 'msg-1',
+          role: 'assistant',
+          updatedAt: 0,
+        },
+        {
+          content: 'Thread user follow-up',
+          createdAt: 0,
+          id: 'msg-3',
+          parentId: 'msg-2',
+          role: 'user',
+          updatedAt: 0,
+        },
+      ];
+
+      const builder = createBuilder(messages);
+      const result = builder.flatten(messages);
+
+      // Should flatten all messages correctly using first message's parentId as virtual root
+      expect(result).toHaveLength(3);
+      expect(result[0].id).toBe('msg-1');
+      expect(result[1].id).toBe('msg-2');
+      expect(result[2].id).toBe('msg-3');
+    });
   });
 });

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

@@ -1,10 +1,10 @@
 import { eq, sql } from 'drizzle-orm';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 
+import { getTestDB } from '../../../core/getTestDB';
 import { agents, messages, sessions, threads, topics, users } from '../../../schemas';
 import { LobeChatDatabase } from '../../../type';
 import { MessageModel } from '../../message';
-import { getTestDB } from '../../../core/getTestDB';
 
 const serverDB: LobeChatDatabase = await getTestDB();
 
@@ -337,6 +337,90 @@ describe('MessageModel thread query', () => {
       expect(result.map((m) => m.id)).toEqual(['msg2', 'thread-msg1', 'thread-msg2']);
     });
 
+    it('should return only thread messages for Isolation type (no parent messages)', async () => {
+      await serverDB.transaction(async (trx) => {
+        await trx.insert(agents).values([{ id: 'agent1', userId }]);
+        await trx.insert(topics).values([{ id: 'topic1', userId }]);
+
+        // Create thread with Isolation type
+        await trx.insert(threads).values([
+          {
+            id: 'thread1',
+            userId,
+            topicId: 'topic1',
+            sourceMessageId: 'msg2',
+            type: 'isolation',
+          },
+        ]);
+
+        // Create main conversation messages
+        await trx.insert(messages).values([
+          {
+            id: 'msg1',
+            userId,
+            agentId: 'agent1',
+            topicId: 'topic1',
+            threadId: null,
+            role: 'user',
+            content: 'first message',
+            createdAt: new Date('2023-01-01'),
+          },
+          {
+            id: 'msg2',
+            userId,
+            agentId: 'agent1',
+            topicId: 'topic1',
+            threadId: null,
+            role: 'assistant',
+            content: 'second message - source',
+            createdAt: new Date('2023-01-02'),
+          },
+          {
+            id: 'msg3',
+            userId,
+            agentId: 'agent1',
+            topicId: 'topic1',
+            threadId: null,
+            role: 'user',
+            content: 'third message',
+            createdAt: new Date('2023-01-03'),
+          },
+          // Thread messages
+          {
+            id: 'thread-msg1',
+            userId,
+            agentId: 'agent1',
+            topicId: 'topic1',
+            threadId: 'thread1',
+            role: 'user',
+            content: 'thread message 1',
+            createdAt: new Date('2023-01-02T10:00:00'),
+          },
+          {
+            id: 'thread-msg2',
+            userId,
+            agentId: 'agent1',
+            topicId: 'topic1',
+            threadId: 'thread1',
+            role: 'assistant',
+            content: 'thread message 2',
+            createdAt: new Date('2023-01-02T11:00:00'),
+          },
+        ]);
+      });
+
+      const result = await messageModel.query({
+        agentId: 'agent1',
+        topicId: 'topic1',
+        threadId: 'thread1',
+      });
+
+      // For Isolation: should include ONLY thread messages, NO parent messages at all
+      // Should NOT include msg1, msg2 (source), or msg3
+      expect(result).toHaveLength(2);
+      expect(result.map((m) => m.id)).toEqual(['thread-msg1', 'thread-msg2']);
+    });
+
     it('should return only thread messages when thread has no sourceMessageId', async () => {
       await serverDB.transaction(async (trx) => {
         await trx.insert(sessions).values([{ id: 'session1', userId }]);
@@ -572,6 +656,55 @@ describe('MessageModel thread query', () => {
       expect(result[0].id).toBe('msg2');
     });
 
+    it('should return empty array for Isolation thread type', async () => {
+      await serverDB.transaction(async (trx) => {
+        await trx.insert(agents).values([{ id: 'agent1', userId }]);
+        await trx.insert(topics).values([{ id: 'topic1', userId }]);
+
+        await trx.insert(messages).values([
+          {
+            id: 'msg1',
+            userId,
+            agentId: 'agent1',
+            topicId: 'topic1',
+            threadId: null,
+            role: 'user',
+            content: 'first',
+            createdAt: new Date('2023-01-01'),
+          },
+          {
+            id: 'msg2',
+            userId,
+            agentId: 'agent1',
+            topicId: 'topic1',
+            threadId: null,
+            role: 'assistant',
+            content: 'second - source',
+            createdAt: new Date('2023-01-02'),
+          },
+          {
+            id: 'msg3',
+            userId,
+            agentId: 'agent1',
+            topicId: 'topic1',
+            threadId: null,
+            role: 'user',
+            content: 'third',
+            createdAt: new Date('2023-01-03'),
+          },
+        ]);
+      });
+
+      const result = await messageModel.getThreadParentMessages({
+        sourceMessageId: 'msg2',
+        topicId: 'topic1',
+        threadType: 'isolation' as any,
+      });
+
+      // Isolation should return empty array (no parent messages)
+      expect(result).toHaveLength(0);
+    });
+
     it('should return all messages up to source message for Continuation thread type', async () => {
       await serverDB.transaction(async (trx) => {
         await trx.insert(sessions).values([{ id: 'session1', userId }]);

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

@@ -431,6 +431,7 @@ export class MessageModel {
           return [
             t.sourceMessageId!,
             {
+              clientMode: metadata?.clientMode as boolean | undefined,
               duration: metadata?.duration as number | undefined,
               status: t.status as ThreadStatus,
               threadId: t.threadId,
@@ -678,10 +679,11 @@ export class MessageModel {
    * @param params - Parameters for getting parent messages
    * @param params.sourceMessageId - The ID of the source message that started the thread
    * @param params.topicId - The topic ID the thread belongs to
-   * @param params.threadType - The type of thread (Continuation or Standalone)
+   * @param params.threadType - The type of thread (Continuation, Standalone, or Isolation)
    * @returns Parent messages based on thread type:
    *   - Continuation: All messages from the topic up to and including the source message
    *   - Standalone: Only the source message itself
+   *   - Isolation: No parent messages (completely isolated thread)
    */
   getThreadParentMessages = async (params: {
     sourceMessageId: string;
@@ -690,6 +692,11 @@ export class MessageModel {
   }): Promise<DBMessageItem[]> => {
     const { sourceMessageId, topicId, threadType } = params;
 
+    // For Isolation type, return empty array (no parent messages)
+    if (threadType === ThreadType.Isolation) {
+      return [];
+    }
+
     // For Standalone type, only return the source message
     if (threadType === ThreadType.Standalone) {
       const sourceMessage = await this.db.query.messages.findFirst({

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

@@ -32,7 +32,7 @@ export class ThreadModel {
     // @ts-ignore
     const [result] = await this.db
       .insert(threads)
-      .values({ ...params, status: ThreadStatus.Active, userId: this.userId })
+      .values({ status: ThreadStatus.Active, ...params, userId: this.userId })
       .onConflictDoNothing()
       .returning();
 

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

@@ -64,6 +64,8 @@ interface UIMessageBranch {
  * Retrieved from the associated Thread via sourceMessageId
  */
 export interface TaskDetail {
+  /** Whether this task runs in client mode (local execution) */
+  clientMode?: boolean;
   /** Task completion time (ISO string) */
   completedAt?: string;
   /** Execution duration in milliseconds */

package/packages/types/src/topic/thread.ts

@@ -23,6 +23,8 @@ export enum ThreadStatus {
  * Metadata for Thread, used for agent task execution
  */
 export interface ThreadMetadata {
+  /** Whether this thread runs in client mode (local execution) */
+  clientMode?: boolean;
   /** Task completion time */
   completedAt?: string;
   /** Execution duration in milliseconds */
@@ -68,16 +70,34 @@ export interface CreateThreadParams {
   agentId?: string;
   /** Group ID for group chat context */
   groupId?: string;
+  /** Initial metadata for the thread */
+  metadata?: ThreadMetadata;
   parentThreadId?: string;
   sourceMessageId?: string;
+  /** Initial status (defaults to Active) */
+  status?: ThreadStatus;
   title?: string;
   topicId: string;
   type: IThreadType;
 }
 
+export const threadMetadataSchema = z.object({
+  clientMode: z.boolean().optional(),
+  completedAt: z.string().optional(),
+  duration: z.number().optional(),
+  error: z.any().optional(),
+  operationId: z.string().optional(),
+  startedAt: z.string().optional(),
+  totalCost: z.number().optional(),
+  totalMessages: z.number().optional(),
+  totalTokens: z.number().optional(),
+  totalToolCalls: z.number().optional(),
+});
+
 export const createThreadSchema = z.object({
   agentId: z.string().optional(),
   groupId: z.string().optional(),
+  metadata: threadMetadataSchema.optional(),
   parentThreadId: z.string().optional(),
   sourceMessageId: z.string().optional(),
   title: z.string().optional(),

package/src/components/StreamingMarkdown/index.tsx

@@ -2,7 +2,9 @@
 
 import { Markdown, ScrollShadow } from '@lobehub/ui';
 import { createStaticStyles } from 'antd-style';
-import { memo, useCallback, useEffect, useRef, useState } from 'react';
+import { type RefObject, memo, useEffect } from 'react';
+
+import { useAutoScroll } from '@/hooks/useAutoScroll';
 
 const styles = createStaticStyles(({ css }) => ({
   container: css`
@@ -19,51 +21,16 @@ interface StreamingMarkdownProps {
 }
 
 const StreamingMarkdown = memo<StreamingMarkdownProps>(({ children, maxHeight = 400 }) => {
-  const containerRef = useRef<HTMLDivElement>(null);
-  const [userHasScrolled, setUserHasScrolled] = useState(false);
-  const isAutoScrollingRef = useRef(false);
-
-  // Handle user scroll detection
-  const handleScroll = useCallback(() => {
-    // Ignore scroll events triggered by auto-scroll
-    if (isAutoScrollingRef.current) return;
-
-    const container = containerRef.current;
-    if (!container) return;
-
-    // Check if user scrolled away from bottom
-    const distanceToBottom = container.scrollHeight - container.scrollTop - container.clientHeight;
-    const isAtBottom = distanceToBottom < 20;
-
-    // If user scrolled up, stop auto-scrolling
-    if (!isAtBottom) {
-      setUserHasScrolled(true);
-    }
-  }, []);
-
-  // Auto scroll to bottom when content changes (unless user has scrolled)
-  useEffect(() => {
-    if (userHasScrolled) return;
-
-    const container = containerRef.current;
-    if (!container) return;
-
-    isAutoScrollingRef.current = true;
-    requestAnimationFrame(() => {
-      container.scrollTop = container.scrollHeight;
-      // Reset the flag after scroll completes
-      requestAnimationFrame(() => {
-        isAutoScrollingRef.current = false;
-      });
-    });
-  }, [children, userHasScrolled]);
+  const { ref, handleScroll, resetScrollLock } = useAutoScroll<HTMLDivElement>({
+    deps: [children],
+  });
 
-  // Reset userHasScrolled when content is cleared (new stream starts)
+  // Reset scroll lock when content is cleared (new stream starts)
   useEffect(() => {
     if (!children) {
-      setUserHasScrolled(false);
+      resetScrollLock();
     }
-  }, [children]);
+  }, [children, resetScrollLock]);
 
   if (!children) return null;
 
@@ -72,7 +39,7 @@ const StreamingMarkdown = memo<StreamingMarkdownProps>(({ children, maxHeight =
       className={styles.container}
       offset={12}
       onScroll={handleScroll}
-      ref={containerRef}
+      ref={ref as RefObject<HTMLDivElement>}
       size={12}
       style={{ maxHeight }}
     >

package/src/features/Conversation/Messages/AssistantGroup/components/MessageContent.tsx

@@ -28,8 +28,6 @@ const MessageContent = memo<ContentBlockProps>(({ content, hasTools, id }) => {
   if (!content && !hasTools) return <ContentLoading id={id} />;
 
   if (content === LOADING_FLAT) {
-    if (hasTools) return null;
-
     return <ContentLoading id={id} />;
   }