@lobehub/lobehub 2.0.0-next.137 → 2.0.0-next.138

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 # Changelog
 
+## [Version 2.0.0-next.138](https://github.com/lobehub/lobe-chat/compare/v2.0.0-next.137...v2.0.0-next.138)
+
+<sup>Released on **2025-11-30**</sup>
+
+#### 🐛 Bug Fixes
+
+- **conversation-flow**: Support optimistic update for activeBranchIndex.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### What's fixed
+
+- **conversation-flow**: Support optimistic update for activeBranchIndex, closes [#10517](https://github.com/lobehub/lobe-chat/issues/10517) ([9b5b234](https://github.com/lobehub/lobe-chat/commit/9b5b234))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
 ## [Version 2.0.0-next.137](https://github.com/lobehub/lobe-chat/compare/v2.0.0-next.136...v2.0.0-next.137)
 
 <sup>Released on **2025-11-30**</sup>

package/CLAUDE.md

@@ -55,6 +55,44 @@ see @.cursor/rules/typescript.mdc
 - **Dev**: Translate `locales/zh-CN/namespace.json` and `locales/en-US/namespace.json` locales file only for dev preview
 - DON'T run `pnpm i18n`, let CI auto handle it
 
+## Linear Issue Management
+
+When working with Linear issues:
+
+1. **Retrieve issue details** before starting work using `mcp__linear-server__get_issue`
+2. **Check for sub-issues**: If the issue has sub-issues, retrieve and review ALL sub-issues using `mcp__linear-server__list_issues` with `parentId` filter before starting work
+3. **Update issue status** when completing tasks using `mcp__linear-server__update_issue`
+4. **MUST add completion comment** using `mcp__linear-server__create_comment`
+
+### Completion Comment (REQUIRED)
+
+**Every time you complete an issue, you MUST add a comment summarizing the work done.** This is critical for:
+
+- Team visibility and knowledge sharing
+- Code review context
+- Future reference and debugging
+
+### IMPORTANT: Per-Issue Completion Rule
+
+**When working on multiple issues (e.g., parent issue with sub-issues), you MUST update status and add comment for EACH issue IMMEDIATELY after completing it.** Do NOT wait until all issues are done to update them in batch.
+
+**Workflow for EACH individual issue:**
+
+1. Complete the implementation for this specific issue
+2. Run type check: `bun run type-check`
+3. Run related tests if applicable
+4. **IMMEDIATELY** update issue status to "Done": `mcp__linear-server__update_issue`
+5. **IMMEDIATELY** add completion comment: `mcp__linear-server__create_comment`
+6. Only then move on to the next issue
+
+**❌ Wrong approach:**
+
+- Complete Issue A → Complete Issue B → Complete Issue C → Update all statuses → Add all comments
+
+**✅ Correct approach:**
+
+- Complete Issue A → Update A status → Add A comment → Complete Issue B → Update B status → Add B comment → ...
+
 ## Rules Index
 
 Some useful project rules are listed in @.cursor/rules/rules-index.mdc

package/changelog/v1.json

@@ -1,4 +1,9 @@
 [
+  {
+    "children": {},
+    "date": "2025-11-30",
+    "version": "2.0.0-next.138"
+  },
   {
     "children": {
       "fixes": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/lobehub",
-  "version": "2.0.0-next.137",
+  "version": "2.0.0-next.138",
   "description": "LobeHub - an open-source,comprehensive AI Agent framework that supports speech synthesis, multimodal, and extensible Function Call plugin system. Supports one-click free deployment of your private ChatGPT/LLM web application.",
   "keywords": [
     "framework",

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

@@ -11,16 +11,21 @@ import type { IdNode, Message } from '../types';
 export class BranchResolver {
   /**
    * Get active branch ID from IdNode structure (used in contextTree building)
+   * Returns undefined for optimistic updates when the branch hasn't been created yet
    */
-  getActiveBranchId(message: Message, idNode: IdNode): string {
+  getActiveBranchId(message: Message, idNode: IdNode): string | undefined {
     // Priority 1: Try to get from metadata.activeBranchIndex (index-based)
     const activeBranchIndex = (message.metadata as any)?.activeBranchIndex;
-    if (
-      typeof activeBranchIndex === 'number' &&
-      activeBranchIndex >= 0 &&
-      activeBranchIndex < idNode.children.length
-    ) {
-      return idNode.children[activeBranchIndex].id;
+    if (typeof activeBranchIndex === 'number' && activeBranchIndex >= 0) {
+      // If index is within bounds, return the branch at that index
+      if (activeBranchIndex < idNode.children.length) {
+        return idNode.children[activeBranchIndex].id;
+      }
+      // Optimistic update: index === children.length means branch is being created
+      if (activeBranchIndex === idNode.children.length) {
+        return undefined;
+      }
+      // Invalid index (> children.length), ignore and continue to other strategies
     }
 
     // Priority 2: Infer from which branch has children
@@ -36,20 +41,25 @@ export class BranchResolver {
 
   /**
    * Get active branch ID from flat list (used in flatList building)
+   * Returns undefined for optimistic updates when the branch hasn't been created yet
    */
   getActiveBranchIdFromMetadata(
     message: Message,
     childIds: string[],
     childrenMap: Map<string | null, string[]>,
-  ): string {
+  ): string | undefined {
     // Priority 1: Try to get from metadata.activeBranchIndex (index-based)
     const activeBranchIndex = (message.metadata as any)?.activeBranchIndex;
-    if (
-      typeof activeBranchIndex === 'number' &&
-      activeBranchIndex >= 0 &&
-      activeBranchIndex < childIds.length
-    ) {
-      return childIds[activeBranchIndex];
+    if (typeof activeBranchIndex === 'number' && activeBranchIndex >= 0) {
+      // If index is within bounds, return the branch at that index
+      if (activeBranchIndex < childIds.length) {
+        return childIds[activeBranchIndex];
+      }
+      // Optimistic update: index === childIds.length means branch is being created
+      if (activeBranchIndex === childIds.length) {
+        return undefined;
+      }
+      // Invalid index (> childIds.length), ignore and continue to other strategies
     }
 
     // Priority 2: Infer from which child has descendants

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

@@ -185,7 +185,12 @@ export class ContextTreeBuilder {
    */
   private createBranchNode(message: Message, idNode: IdNode): BranchNode {
     const activeBranchId = this.branchResolver.getActiveBranchId(message, idNode);
-    const activeBranchIndex = idNode.children.findIndex((child) => child.id === activeBranchId);
+
+    // For optimistic update (activeBranchId is undefined), use children.length as the index
+    // This indicates the branch is being created but doesn't exist yet
+    const activeBranchIndex = activeBranchId
+      ? idNode.children.findIndex((child) => child.id === activeBranchId)
+      : idNode.children.length;
 
     // Each branch is a tree starting from that child
     const branches = idNode.children.map((child) => {

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

@@ -165,6 +165,15 @@ export class FlatListBuilder {
           childMessages,
           this.childrenMap,
         );
+
+        // Optimistic update: activeBranchId is undefined when branch is being created
+        // In this case, just add user message without branch info and continue
+        if (!activeBranchId) {
+          flatList.push(message);
+          processedIds.add(message.id);
+          continue;
+        }
+
         const activeBranchIndex = childMessages.indexOf(activeBranchId);
         const userWithBranches = this.createUserMessageWithBranches(
           message,
@@ -248,6 +257,12 @@ export class FlatListBuilder {
         flatList.push(message);
         processedIds.add(message.id);
 
+        // Optimistic update: activeBranchId is undefined when branch is being created
+        // In this case, just add assistant message and continue (no active branch yet)
+        if (!activeBranchId) {
+          continue;
+        }
+
         // Continue with active branch and process its message
         const activeBranchMsg = this.messageMap.get(activeBranchId);
         if (activeBranchMsg) {

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

@@ -71,13 +71,13 @@ describe('BranchResolver', () => {
       expect(resolver.getActiveBranchId(message, idNode)).toBe('msg-2');
     });
 
-    it('should ignore invalid activeBranchIndex', () => {
+    it('should return undefined for optimistic update (activeBranchIndex === children.length)', () => {
       const message: Message = {
         content: 'test',
         createdAt: 0,
         id: 'msg-1',
         meta: {},
-        metadata: { activeBranchIndex: 5 }, // out of bounds
+        metadata: { activeBranchIndex: 2 }, // index = children.length (optimistic update)
         role: 'user',
         updatedAt: 0,
       };
@@ -90,7 +90,31 @@ describe('BranchResolver', () => {
         id: 'msg-1',
       };
 
-      // Should default to first branch
+      // When activeBranchIndex === children.length, it's an optimistic update
+      // The branch hasn't been created yet, so return undefined
+      expect(resolver.getActiveBranchId(message, idNode)).toBeUndefined();
+    });
+
+    it('should ignore activeBranchIndex when it exceeds optimistic update range', () => {
+      const message: Message = {
+        content: 'test',
+        createdAt: 0,
+        id: 'msg-1',
+        meta: {},
+        metadata: { activeBranchIndex: 5 }, // > children.length (invalid)
+        role: 'user',
+        updatedAt: 0,
+      };
+
+      const idNode: IdNode = {
+        children: [
+          { children: [], id: 'msg-2' },
+          { children: [], id: 'msg-3' },
+        ],
+        id: 'msg-1',
+      };
+
+      // activeBranchIndex > children.length should be ignored, fallback to default
       expect(resolver.getActiveBranchId(message, idNode)).toBe('msg-2');
     });
   });
@@ -147,5 +171,44 @@ describe('BranchResolver', () => {
 
       expect(resolver.getActiveBranchIdFromMetadata(message, childIds, childrenMap)).toBe('msg-2');
     });
+
+    it('should return undefined for optimistic update (activeBranchIndex === childIds.length)', () => {
+      const message: Message = {
+        content: 'test',
+        createdAt: 0,
+        id: 'msg-1',
+        meta: {},
+        metadata: { activeBranchIndex: 2 }, // index = childIds.length (optimistic update)
+        role: 'user',
+        updatedAt: 0,
+      };
+
+      const childIds = ['msg-2', 'msg-3'];
+      const childrenMap = new Map<string | null, string[]>();
+
+      // When activeBranchIndex === childIds.length, it's an optimistic update
+      // The branch hasn't been created yet, so return undefined
+      expect(
+        resolver.getActiveBranchIdFromMetadata(message, childIds, childrenMap),
+      ).toBeUndefined();
+    });
+
+    it('should ignore activeBranchIndex when it exceeds optimistic update range', () => {
+      const message: Message = {
+        content: 'test',
+        createdAt: 0,
+        id: 'msg-1',
+        meta: {},
+        metadata: { activeBranchIndex: 5 }, // > childIds.length (invalid)
+        role: 'user',
+        updatedAt: 0,
+      };
+
+      const childIds = ['msg-2', 'msg-3'];
+      const childrenMap = new Map<string | null, string[]>();
+
+      // activeBranchIndex > childIds.length should be ignored, fallback to default
+      expect(resolver.getActiveBranchIdFromMetadata(message, childIds, childrenMap)).toBe('msg-2');
+    });
   });
 });

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

@@ -311,6 +311,70 @@ describe('ContextTreeBuilder', () => {
       expect(result).toHaveLength(0);
     });
 
+    it('should set activeBranchIndex to children.length for optimistic update', () => {
+      const messageMap = new Map<string, Message>([
+        [
+          'msg-1',
+          {
+            content: 'Hello',
+            createdAt: 0,
+            id: 'msg-1',
+            meta: {},
+            // activeBranchIndex = 2 means optimistic update (pointing to not-yet-created branch)
+            metadata: { activeBranchIndex: 2 },
+            role: 'user',
+            updatedAt: 0,
+          },
+        ],
+        [
+          'msg-2',
+          {
+            content: 'Response 1',
+            createdAt: 0,
+            id: 'msg-2',
+            meta: {},
+            role: 'assistant',
+            updatedAt: 0,
+          },
+        ],
+        [
+          'msg-3',
+          {
+            content: 'Response 2',
+            createdAt: 0,
+            id: 'msg-3',
+            meta: {},
+            role: 'assistant',
+            updatedAt: 0,
+          },
+        ],
+      ]);
+
+      const builder = createBuilder(messageMap);
+      const idNodes: IdNode[] = [
+        {
+          children: [
+            { children: [], id: 'msg-2' },
+            { children: [], id: 'msg-3' },
+          ],
+          id: 'msg-1',
+        },
+      ];
+
+      const result = builder.transformAll(idNodes);
+
+      expect(result).toHaveLength(2);
+      expect(result[0]).toEqual({ id: 'msg-1', type: 'message' });
+      // When activeBranchIndex === children.length (optimistic update),
+      // BranchResolver returns undefined, and ContextTreeBuilder uses children.length as index
+      expect(result[1]).toMatchObject({
+        activeBranchIndex: 2, // children.length = 2
+        branches: [[{ id: 'msg-2', type: 'message' }], [{ id: 'msg-3', type: 'message' }]],
+        parentMessageId: 'msg-1',
+        type: 'branch',
+      });
+    });
+
     it('should continue with active column children in compare mode', () => {
       const messageMap = new Map<string, Message>([
         [

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

@@ -507,5 +507,52 @@ describe('FlatListBuilder', () => {
       expect(result[1].role).toBe('assistantGroup');
       expect(result[2].id).toBe('msg-3');
     });
+
+    it('should handle optimistic update for user message with branches', () => {
+      // Scenario: User has sent a new message, activeBranchIndex points to a branch
+      // that is being created but doesn't exist yet (optimistic update)
+      const messages: Message[] = [
+        {
+          content: 'User',
+          createdAt: 0,
+          id: 'msg-1',
+          meta: {},
+          // activeBranchIndex = 2 means pointing to a not-yet-created branch (optimistic update)
+          // when there are only 2 existing children (msg-2, msg-3)
+          metadata: { activeBranchIndex: 2 },
+          role: 'user',
+          updatedAt: 0,
+        },
+        {
+          content: 'Branch 1',
+          createdAt: 0,
+          id: 'msg-2',
+          meta: {},
+          parentId: 'msg-1',
+          role: 'assistant',
+          updatedAt: 0,
+        },
+        {
+          content: 'Branch 2',
+          createdAt: 0,
+          id: 'msg-3',
+          meta: {},
+          parentId: 'msg-1',
+          role: 'assistant',
+          updatedAt: 0,
+        },
+      ];
+
+      const builder = createBuilder(messages);
+      const result = builder.flatten(messages);
+
+      // When activeBranchIndex === children.length (optimistic update),
+      // BranchResolver returns undefined, and FlatListBuilder just adds the user message
+      // without branch info and doesn't continue to any branch
+      expect(result).toHaveLength(1);
+      expect(result[0].id).toBe('msg-1');
+      // User message should not have branch info since we're in optimistic update mode
+      expect((result[0] as any).siblingCount).toBeUndefined();
+    });
   });
 });

package/packages/database/src/models/__tests__/agent.test.ts

@@ -20,9 +20,12 @@ import { getTestDB } from './_util';
 const serverDB: LobeChatDatabase = await getTestDB();
 
 const userId = 'agent-model-test-user-id';
+const userId2 = 'agent-model-test-user-id-2';
 const agentModel = new AgentModel(serverDB, userId);
+const agentModel2 = new AgentModel(serverDB, userId2);
 
 const knowledgeBase = { id: 'kb1', userId, name: 'knowledgeBase' };
+const knowledgeBase2 = { id: 'kb2', userId: userId2, name: 'knowledgeBase2' };
 const fileList = [
   {
     id: '1',
@@ -42,11 +45,22 @@ const fileList = [
   },
 ];
 
+const fileList2 = [
+  {
+    id: '3',
+    name: 'other.pdf',
+    url: 'https://a.com/other.pdf',
+    size: 1000,
+    fileType: 'application/pdf',
+    userId: userId2,
+  },
+];
+
 beforeEach(async () => {
   await serverDB.delete(users);
-  await serverDB.insert(users).values([{ id: userId }]);
-  await serverDB.insert(knowledgeBases).values(knowledgeBase);
-  await serverDB.insert(files).values(fileList);
+  await serverDB.insert(users).values([{ id: userId }, { id: userId2 }]);
+  await serverDB.insert(knowledgeBases).values([knowledgeBase, knowledgeBase2]);
+  await serverDB.insert(files).values([...fileList, ...fileList2]);
 });
 
 afterEach(async () => {
@@ -226,6 +240,27 @@ describe('AgentModel', () => {
 
       expect(result).toBeUndefined();
     });
+
+    it('should not delete another user agent knowledge base association', async () => {
+      const agent = await serverDB
+        .insert(agents)
+        .values({ userId })
+        .returning()
+        .then((res) => res[0]);
+      await serverDB
+        .insert(agentsKnowledgeBases)
+        .values({ agentId: agent.id, knowledgeBaseId: knowledgeBase.id, userId });
+
+      // Try to delete with another user's model
+      await agentModel2.deleteAgentKnowledgeBase(agent.id, knowledgeBase.id);
+
+      const result = await serverDB.query.agentsKnowledgeBases.findFirst({
+        where: eq(agentsKnowledgeBases.agentId, agent.id),
+      });
+
+      // Should still exist
+      expect(result).toBeDefined();
+    });
   });
 
   describe('toggleKnowledgeBase', () => {
@@ -248,6 +283,28 @@ describe('AgentModel', () => {
 
       expect(result?.enabled).toBe(false);
     });
+
+    it('should not toggle another user agent knowledge base association', async () => {
+      const agent = await serverDB
+        .insert(agents)
+        .values({ userId })
+        .returning()
+        .then((res) => res[0]);
+
+      await serverDB
+        .insert(agentsKnowledgeBases)
+        .values({ agentId: agent.id, knowledgeBaseId: knowledgeBase.id, userId, enabled: true });
+
+      // Try to toggle with another user's model
+      await agentModel2.toggleKnowledgeBase(agent.id, knowledgeBase.id, false);
+
+      const result = await serverDB.query.agentsKnowledgeBases.findFirst({
+        where: eq(agentsKnowledgeBases.agentId, agent.id),
+      });
+
+      // Should still be enabled
+      expect(result?.enabled).toBe(true);
+    });
   });
 
   describe('createAgentFiles', () => {
@@ -363,6 +420,26 @@ describe('AgentModel', () => {
 
       expect(result).toBeUndefined();
     });
+
+    it('should not delete another user agent file association', async () => {
+      const agent = await serverDB
+        .insert(agents)
+        .values({ userId })
+        .returning()
+        .then((res) => res[0]);
+
+      await serverDB.insert(agentsFiles).values({ agentId: agent.id, fileId: '1', userId });
+
+      // Try to delete with another user's model
+      await agentModel2.deleteAgentFile(agent.id, '1');
+
+      const result = await serverDB.query.agentsFiles.findFirst({
+        where: eq(agentsFiles.agentId, agent.id),
+      });
+
+      // Should still exist
+      expect(result).toBeDefined();
+    });
   });
 
   describe('toggleFile', () => {
@@ -385,5 +462,27 @@ describe('AgentModel', () => {
 
       expect(result?.enabled).toBe(false);
     });
+
+    it('should not toggle another user agent file association', async () => {
+      const agent = await serverDB
+        .insert(agents)
+        .values({ userId })
+        .returning()
+        .then((res) => res[0]);
+
+      await serverDB
+        .insert(agentsFiles)
+        .values({ agentId: agent.id, fileId: '1', userId, enabled: true });
+
+      // Try to toggle with another user's model
+      await agentModel2.toggleFile(agent.id, '1', false);
+
+      const result = await serverDB.query.agentsFiles.findFirst({
+        where: eq(agentsFiles.agentId, agent.id),
+      });
+
+      // Should still be enabled
+      expect(result?.enabled).toBe(true);
+    });
   });
 });