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

package/packages/builtin-tool-gtd/src/executor/index.ts

@@ -407,18 +407,20 @@ class GTDExecutor extends BaseExecutor<typeof GTDApiNameEnum> {
    * Execute a single async task
    *
    * This method triggers async task execution by returning a special state.
-   * The AgentRuntime's executor will recognize this state and trigger the exec_task instruction.
+   * The AgentRuntime's executor will recognize this state and trigger the appropriate instruction.
    *
    * Flow:
-   * 1. GTD tool returns stop: true with state.type = 'execTask'
-   * 2. AgentRuntime executor recognizes the state and triggers exec_task instruction
-   * 3. exec_task executor creates task message and polls for completion
+   * 1. GTD tool returns stop: true with state.type = 'execTask' or 'execClientTask'
+   * 2. AgentRuntime executor recognizes the state and triggers exec_task or exec_client_task instruction
+   * 3. The executor creates task message and handles execution
+   *
+   * @param params.runInClient - If true, returns 'execClientTask' state for client-side execution
    */
   execTask = async (
     params: ExecTaskParams,
     ctx: BuiltinToolContext,
   ): Promise<BuiltinToolResult> => {
-    const { description, instruction, inheritMessages, timeout } = params;
+    const { description, instruction, inheritMessages, timeout, runInClient } = params;
 
     if (!description || !instruction) {
       return {
@@ -427,19 +429,25 @@ class GTDExecutor extends BaseExecutor<typeof GTDApiNameEnum> {
       };
     }
 
+    const task = {
+      description,
+      inheritMessages,
+      instruction,
+      runInClient,
+      timeout,
+    };
+
+    // Determine state type based on runInClient
+    // If runInClient is true, return 'execClientTask' to trigger client-side executor
+    const stateType = runInClient ? 'execClientTask' : 'execTask';
+
     // Return stop: true with special state that AgentRuntime will recognize
-    // The exec_task executor will be triggered by the runtime when it sees this state
     return {
-      content: `🚀 Triggered async task for execution:\n- ${description}`,
+      content: `🚀 Triggered async task for ${runInClient ? 'client-side' : ''} execution:\n- ${description}`,
       state: {
         parentMessageId: ctx.messageId,
-        task: {
-          description,
-          inheritMessages,
-          instruction,
-          timeout,
-        },
-        type: 'execTask',
+        task,
+        type: stateType,
       },
       stop: true,
       success: true,
@@ -450,12 +458,15 @@ class GTDExecutor extends BaseExecutor<typeof GTDApiNameEnum> {
    * Execute one or more async tasks
    *
    * This method triggers async task execution by returning a special state.
-   * The AgentRuntime's executor will recognize this state and trigger the exec_tasks instruction.
+   * The AgentRuntime's executor will recognize this state and trigger the appropriate instruction.
    *
    * Flow:
-   * 1. GTD tool returns stop: true with state.type = 'execTasks'
-   * 2. AgentRuntime executor recognizes the state and triggers exec_tasks instruction
-   * 3. exec_tasks executor creates task messages and polls for completion
+   * 1. GTD tool returns stop: true with state.type = 'execTasks' or 'execClientTasks'
+   * 2. AgentRuntime executor recognizes the state and triggers exec_tasks or exec_client_tasks instruction
+   * 3. The executor creates task messages and handles execution
+   *
+   * Note: If any task has runInClient=true, all tasks will be routed to 'execClientTasks'.
+   * This is because client-side execution is the "special" case requiring local tool access.
    */
   execTasks = async (
     params: ExecTasksParams,
@@ -473,14 +484,20 @@ class GTDExecutor extends BaseExecutor<typeof GTDApiNameEnum> {
     const taskCount = tasks.length;
     const taskList = tasks.map((t, i) => `${i + 1}. ${t.description}`).join('\n');
 
+    // Check if any task requires client-side execution
+    const hasClientTasks = tasks.some((t) => t.runInClient);
+
+    // Determine state type: if any task needs client-side, route all to client executor
+    const stateType = hasClientTasks ? 'execClientTasks' : 'execTasks';
+    const executionMode = hasClientTasks ? 'client-side' : '';
+
     // Return stop: true with special state that AgentRuntime will recognize
-    // The exec_tasks executor will be triggered by the runtime when it sees this state
     return {
-      content: `🚀 Triggered ${taskCount} async task${taskCount > 1 ? 's' : ''} for execution:\n${taskList}`,
+      content: `🚀 Triggered ${taskCount} async task${taskCount > 1 ? 's' : ''} for ${executionMode} execution:\n${taskList}`,
       state: {
         parentMessageId: ctx.messageId,
         tasks,
-        type: 'execTasks',
+        type: stateType,
       },
       stop: true,
       success: true,

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

@@ -1,5 +1,6 @@
 import type { BuiltinToolManifest } from '@lobechat/types';
 
+import { isDesktop } from './const';
 import { systemPrompt } from './systemRole';
 import { GTDApiName } from './types';
 
@@ -171,6 +172,13 @@ export const GTDManifest: BuiltinToolManifest = {
               'Whether to inherit context messages from the parent conversation. Default is false.',
             type: 'boolean',
           },
+          ...(isDesktop && {
+            runInClient: {
+              description:
+                'Whether to run on the desktop client (for local file/shell access). MUST be true when task requires local-system tools. Default is false (server execution).',
+              type: 'boolean',
+            },
+          }),
           timeout: {
             description: 'Optional timeout in milliseconds. Default is 30 minutes.',
             type: 'number',
@@ -203,6 +211,13 @@ export const GTDManifest: BuiltinToolManifest = {
                     'Whether to inherit context messages from the parent conversation. Default is false.',
                   type: 'boolean',
                 },
+                ...(isDesktop && {
+                  runInClient: {
+                    description:
+                      'Whether to run on the desktop client (for local file/shell access). MUST be true when task requires local-system tools. Default is false (server execution).',
+                    type: 'boolean',
+                  },
+                }),
                 timeout: {
                   description: 'Optional timeout in milliseconds. Default is 30 minutes.',
                   type: 'number',

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

@@ -1,3 +1,35 @@
+import { isDesktop } from './const';
+
+const runInClientSection = `
+<run_in_client>
+**IMPORTANT: When to use \`runInClient: true\` for async tasks**
+
+The \`runInClient\` parameter controls WHERE the async task executes:
+- \`runInClient: false\` (default): Task runs on the **server** - suitable for web searches, API calls, general research
+- \`runInClient: true\`: Task runs on the **desktop client** - required for local system access
+
+**MUST set \`runInClient: true\` when the task involves:**
+- Reading or writing local files (via \`local-system\` tool)
+- Executing shell commands on the user's machine
+- Accessing local directories or file system
+- Any operation that requires desktop-only local tools
+
+**Keep \`runInClient: false\` (or omit) when:**
+- Task only needs web searches or API calls
+- Task processes data that doesn't require local file access
+- Task can be fully completed with server-side capabilities
+
+**Note:** \`runInClient\` only has effect on the **desktop app**. On web platform, tasks always run on the server regardless of this setting.
+
+**Examples:**
+- "Research Python best practices" → \`runInClient: false\` (web search only)
+- "Organize files in my Downloads folder" → \`runInClient: true\` (local file access required)
+- "Read the project README and summarize it" → \`runInClient: true\` (local file read required)
+- "Find trending tech news" → \`runInClient: false\` (web search only)
+- "Create a new directory structure for my project" → \`runInClient: true\` (local shell/file required)
+</run_in_client>
+`;
+
 export const systemPrompt = `You have GTD (Getting Things Done) tools to help manage plans, todos and tasks effectively. These tools support three levels of task management:
 
 - **Plan**: A high-level strategic document describing goals, context, and overall direction. Plans do NOT contain actionable steps - they define the "what" and "why". **Plans should be stable once created** - they represent the overarching objective that rarely changes.
@@ -85,7 +117,7 @@ Use \`execTask\` for a single task, \`execTasks\` for multiple parallel tasks.
 - User asks a factual question you know → Just answer directly
 - User wants multiple independent analyses → execTasks (parallel execution)
 </when_to_use>
-
+${isDesktop ? runInClientSection : ''}
 <best_practices>
 - **Plan first, then todos**: Always start with a plan unless explicitly told otherwise
 - **Separate concerns**: Plans describe goals; Todos list actions

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({