@lobehub/lobehub 2.0.0-next.356 → 2.0.0-next.358

package/CHANGELOG.md

@@ -2,6 +2,58 @@
 
 # Changelog
 
+## [Version 2.0.0-next.358](https://github.com/lobehub/lobe-chat/compare/v2.0.0-next.357...v2.0.0-next.358)
+
+<sup>Released on **2026-01-23**</sup>
+
+#### 🐛 Bug Fixes
+
+- **store**: Delete message before regeneration.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### What's fixed
+
+- **store**: Delete message before regeneration, closes [#11760](https://github.com/lobehub/lobe-chat/issues/11760) ([a8a6300](https://github.com/lobehub/lobe-chat/commit/a8a6300))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
+## [Version 2.0.0-next.357](https://github.com/lobehub/lobe-chat/compare/v2.0.0-next.356...v2.0.0-next.357)
+
+<sup>Released on **2026-01-23**</sup>
+
+#### 🐛 Bug Fixes
+
+- **model-runtime**: Handle null content in anthropic message builder.
+- **misc**: Page content switch mismatch.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### What's fixed
+
+- **model-runtime**: Handle null content in anthropic message builder, closes [#11756](https://github.com/lobehub/lobe-chat/issues/11756) ([539753a](https://github.com/lobehub/lobe-chat/commit/539753a))
+- **misc**: Page content switch mismatch, closes [#11758](https://github.com/lobehub/lobe-chat/issues/11758) ([fdc8f95](https://github.com/lobehub/lobe-chat/commit/fdc8f95))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
 ## [Version 2.0.0-next.356](https://github.com/lobehub/lobe-chat/compare/v2.0.0-next.355...v2.0.0-next.356)
 
 <sup>Released on **2026-01-23**</sup>

package/changelog/v1.json

@@ -1,4 +1,18 @@
 [
+  {
+    "children": {},
+    "date": "2026-01-23",
+    "version": "2.0.0-next.358"
+  },
+  {
+    "children": {
+      "fixes": [
+        "Page content switch mismatch."
+      ]
+    },
+    "date": "2026-01-23",
+    "version": "2.0.0-next.357"
+  },
   {
     "children": {
       "features": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/lobehub",
-  "version": "2.0.0-next.356",
+  "version": "2.0.0-next.358",
   "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/model-runtime/src/core/contextBuilders/anthropic.test.ts

@@ -281,6 +281,62 @@ describe('anthropicHelpers', () => {
       const result = await buildAnthropicMessage(message);
       expect(result).toBeUndefined();
     });
+
+    it('should handle assistant message with tool_calls but null content', async () => {
+      const message: OpenAIChatMessage = {
+        content: null as any,
+        role: 'assistant',
+        tool_calls: [
+          {
+            id: 'call1',
+            type: 'function',
+            function: {
+              name: 'search_people',
+              arguments: '{"location":"Singapore"}',
+            },
+          },
+        ],
+      };
+      const result = await buildAnthropicMessage(message);
+      expect(result!.role).toBe('assistant');
+      // null content should be filtered out, only tool_use remains
+      expect(result!.content).toEqual([
+        {
+          id: 'call1',
+          input: { location: 'Singapore' },
+          name: 'search_people',
+          type: 'tool_use',
+        },
+      ]);
+    });
+
+    it('should handle assistant message with tool_calls but empty string content', async () => {
+      const message: OpenAIChatMessage = {
+        content: '',
+        role: 'assistant',
+        tool_calls: [
+          {
+            id: 'call1',
+            type: 'function',
+            function: {
+              name: 'search_people',
+              arguments: '{"location":"Singapore"}',
+            },
+          },
+        ],
+      };
+      const result = await buildAnthropicMessage(message);
+      expect(result!.role).toBe('assistant');
+      // empty string content should be filtered out, only tool_use remains
+      expect(result!.content).toEqual([
+        {
+          id: 'call1',
+          input: { location: 'Singapore' },
+          name: 'search_people',
+          type: 'tool_use',
+        },
+      ]);
+    });
   });
 
   describe('buildAnthropicMessages', () => {
@@ -526,6 +582,320 @@ describe('anthropicHelpers', () => {
         ]);
       });
 
+      it('should handle tool message with null content', async () => {
+        const messages: OpenAIChatMessage[] = [
+          {
+            content: '搜索人员',
+            role: 'user',
+          },
+          {
+            content: '正在搜索...',
+            role: 'assistant',
+            tool_calls: [
+              {
+                function: {
+                  arguments: '{"location": "Singapore"}',
+                  name: 'search_people',
+                },
+                id: 'toolu_01CnXPcBEqsGGbvRriem3Rth',
+                type: 'function',
+              },
+            ],
+          },
+          {
+            content: null as any,
+            name: 'search_people',
+            role: 'tool',
+            tool_call_id: 'toolu_01CnXPcBEqsGGbvRriem3Rth',
+          },
+        ];
+
+        const contents = await buildAnthropicMessages(messages);
+
+        expect(contents).toEqual([
+          { content: '搜索人员', role: 'user' },
+          {
+            content: [
+              { text: '正在搜索...', type: 'text' },
+              {
+                id: 'toolu_01CnXPcBEqsGGbvRriem3Rth',
+                input: { location: 'Singapore' },
+                name: 'search_people',
+                type: 'tool_use',
+              },
+            ],
+            role: 'assistant',
+          },
+          {
+            content: [
+              {
+                content: [{ text: '<empty_content>', type: 'text' }],
+                tool_use_id: 'toolu_01CnXPcBEqsGGbvRriem3Rth',
+                type: 'tool_result',
+              },
+            ],
+            role: 'user',
+          },
+        ]);
+      });
+
+      it('should handle tool message with empty string content', async () => {
+        const messages: OpenAIChatMessage[] = [
+          {
+            content: '搜索人员',
+            role: 'user',
+          },
+          {
+            content: '正在搜索...',
+            role: 'assistant',
+            tool_calls: [
+              {
+                function: {
+                  arguments: '{"location": "Singapore"}',
+                  name: 'search_people',
+                },
+                id: 'toolu_01CnXPcBEqsGGbvRriem3Rth',
+                type: 'function',
+              },
+            ],
+          },
+          {
+            content: '',
+            name: 'search_people',
+            role: 'tool',
+            tool_call_id: 'toolu_01CnXPcBEqsGGbvRriem3Rth',
+          },
+        ];
+
+        const contents = await buildAnthropicMessages(messages);
+
+        expect(contents).toEqual([
+          { content: '搜索人员', role: 'user' },
+          {
+            content: [
+              { text: '正在搜索...', type: 'text' },
+              {
+                id: 'toolu_01CnXPcBEqsGGbvRriem3Rth',
+                input: { location: 'Singapore' },
+                name: 'search_people',
+                type: 'tool_use',
+              },
+            ],
+            role: 'assistant',
+          },
+          {
+            content: [
+              {
+                content: [{ text: '<empty_content>', type: 'text' }],
+                tool_use_id: 'toolu_01CnXPcBEqsGGbvRriem3Rth',
+                type: 'tool_result',
+              },
+            ],
+            role: 'user',
+          },
+        ]);
+      });
+
+      it('should handle tool message with array content', async () => {
+        const messages: OpenAIChatMessage[] = [
+          {
+            content: '搜索人员',
+            role: 'user',
+          },
+          {
+            content: '正在搜索...',
+            role: 'assistant',
+            tool_calls: [
+              {
+                function: {
+                  arguments: '{"location": "Singapore"}',
+                  name: 'search_people',
+                },
+                id: 'toolu_01CnXPcBEqsGGbvRriem3Rth',
+                type: 'function',
+              },
+            ],
+          },
+          {
+            content: [
+              { type: 'text', text: 'Found 5 candidates' },
+              { type: 'text', text: 'Result details here' },
+            ] as any,
+            name: 'search_people',
+            role: 'tool',
+            tool_call_id: 'toolu_01CnXPcBEqsGGbvRriem3Rth',
+          },
+        ];
+
+        const contents = await buildAnthropicMessages(messages);
+
+        expect(contents).toEqual([
+          { content: '搜索人员', role: 'user' },
+          {
+            content: [
+              { text: '正在搜索...', type: 'text' },
+              {
+                id: 'toolu_01CnXPcBEqsGGbvRriem3Rth',
+                input: { location: 'Singapore' },
+                name: 'search_people',
+                type: 'tool_use',
+              },
+            ],
+            role: 'assistant',
+          },
+          {
+            content: [
+              {
+                content: [
+                  { type: 'text', text: 'Found 5 candidates' },
+                  { type: 'text', text: 'Result details here' },
+                ],
+                tool_use_id: 'toolu_01CnXPcBEqsGGbvRriem3Rth',
+                type: 'tool_result',
+              },
+            ],
+            role: 'user',
+          },
+        ]);
+      });
+
+      it('should handle tool message with array content containing image', async () => {
+        vi.mocked(parseDataUri).mockReturnValueOnce({
+          mimeType: 'image/png',
+          base64: 'screenshotBase64Data',
+          type: 'base64',
+        });
+
+        const messages: OpenAIChatMessage[] = [
+          {
+            content: '截图分析',
+            role: 'user',
+          },
+          {
+            content: '正在截图...',
+            role: 'assistant',
+            tool_calls: [
+              {
+                function: {
+                  arguments: '{"url": "https://example.com"}',
+                  name: 'screenshot',
+                },
+                id: 'toolu_screenshot_123',
+                type: 'function',
+              },
+            ],
+          },
+          {
+            content: [
+              { type: 'text', text: 'Screenshot captured' },
+              {
+                type: 'image_url',
+                image_url: { url: 'data:image/png;base64,screenshotBase64Data' },
+              },
+            ] as any,
+            name: 'screenshot',
+            role: 'tool',
+            tool_call_id: 'toolu_screenshot_123',
+          },
+        ];
+
+        const contents = await buildAnthropicMessages(messages);
+
+        expect(contents).toEqual([
+          { content: '截图分析', role: 'user' },
+          {
+            content: [
+              { text: '正在截图...', type: 'text' },
+              {
+                id: 'toolu_screenshot_123',
+                input: { url: 'https://example.com' },
+                name: 'screenshot',
+                type: 'tool_use',
+              },
+            ],
+            role: 'assistant',
+          },
+          {
+            content: [
+              {
+                content: [
+                  { type: 'text', text: 'Screenshot captured' },
+                  {
+                    type: 'image',
+                    source: {
+                      type: 'base64',
+                      media_type: 'image/png',
+                      data: 'screenshotBase64Data',
+                    },
+                  },
+                ],
+                tool_use_id: 'toolu_screenshot_123',
+                type: 'tool_result',
+              },
+            ],
+            role: 'user',
+          },
+        ]);
+      });
+
+      it('should handle orphan tool message with null content', async () => {
+        // Tool message without corresponding assistant tool_call
+        const messages: OpenAIChatMessage[] = [
+          {
+            content: null as any,
+            name: 'some_tool',
+            role: 'tool',
+            tool_call_id: 'orphan_tool_call_id',
+          },
+          {
+            content: 'Continue',
+            role: 'user',
+          },
+        ];
+
+        const contents = await buildAnthropicMessages(messages);
+
+        expect(contents).toEqual([
+          {
+            content: '<empty_content>',
+            role: 'user',
+          },
+          {
+            content: 'Continue',
+            role: 'user',
+          },
+        ]);
+      });
+
+      it('should handle orphan tool message with empty string content', async () => {
+        // Tool message without corresponding assistant tool_call
+        const messages: OpenAIChatMessage[] = [
+          {
+            content: '',
+            name: 'some_tool',
+            role: 'tool',
+            tool_call_id: 'orphan_tool_call_id',
+          },
+          {
+            content: 'Continue',
+            role: 'user',
+          },
+        ];
+
+        const contents = await buildAnthropicMessages(messages);
+
+        expect(contents).toEqual([
+          {
+            content: '<empty_content>',
+            role: 'user',
+          },
+          {
+            content: 'Continue',
+            role: 'user',
+          },
+        ]);
+      });
+
       it('should work well starting with tool message', async () => {
         const messages: OpenAIChatMessage[] = [
           {

package/packages/model-runtime/src/core/contextBuilders/anthropic.ts

@@ -114,10 +114,13 @@ export const buildAnthropicMessage = async (
       // if there is tool_calls , we need to covert the tool_calls to tool_use content block
       // refs: https://docs.anthropic.com/claude/docs/tool-use#tool-use-and-tool-result-content-blocks
       if (message.tool_calls && message.tool_calls.length > 0) {
+        // Handle content: string with text, array, null/undefined/empty -> filter out
         const rawContent =
-          typeof content === 'string'
-            ? ([{ text: message.content, type: 'text' }] as UserMessageContentPart[])
-            : content;
+          typeof content === 'string' && content.trim()
+            ? ([{ text: content, type: 'text' }] as UserMessageContentPart[])
+            : Array.isArray(content)
+              ? content
+              : []; // null/undefined/empty string -> empty array (will be filtered)
 
         const messageContent = await buildArrayContent(rawContent);
 
@@ -180,10 +183,17 @@ export const buildAnthropicMessages = async (
 
     // refs: https://docs.anthropic.com/claude/docs/tool-use#tool-use-and-tool-result-content-blocks
     if (message.role === 'tool') {
+      // Handle different content types in tool messages
+      const toolResultContent = Array.isArray(message.content)
+        ? await buildArrayContent(message.content)
+        : !message.content
+          ? [{ text: '<empty_content>', type: 'text' as const }]
+          : [{ text: message.content, type: 'text' as const }];
+
       // 检查这个工具消息是否有对应的 assistant 工具调用
       if (message.tool_call_id && validToolCallIds.has(message.tool_call_id)) {
         pendingToolResults.push({
-          content: [{ text: message.content as string, type: 'text' }],
+          content: toolResultContent as Anthropic.ToolResultBlockParam['content'],
           tool_use_id: message.tool_call_id,
           type: 'tool_result',
         });
@@ -198,8 +208,11 @@ export const buildAnthropicMessages = async (
         }
       } else {
         // 如果工具消息没有对应的 assistant 工具调用，则作为普通文本处理
+        const fallbackContent = Array.isArray(message.content)
+          ? JSON.stringify(message.content)
+          : message.content || '<empty_content>';
         messages.push({
-          content: message.content as string,
+          content: fallbackContent,
           role: 'user',
         });
       }

package/src/features/Conversation/store/slices/generation/action.test.ts

@@ -462,6 +462,122 @@ describe('Generation Actions', () => {
       // Should complete operation
       expect(mockCompleteOperation).toHaveBeenCalledWith('test-op-id');
     });
+
+    it('should delete message BEFORE regeneration to prevent message not found issue (LOBE-2533)', async () => {
+      // This test verifies the fix for LOBE-2533:
+      // When "delete and regenerate" is called, if regeneration happens first,
+      // it switches to a new branch, causing the original message to no longer
+      // appear in displayMessages. Then deleteMessage cannot find the message
+      // and fails silently.
+      //
+      // The fix: delete first, then regenerate.
+
+      const callOrder: string[] = [];
+
+      // Re-setup mock to track call order
+      const { useChatStore } = await import('@/store/chat');
+      vi.mocked(useChatStore.getState).mockReturnValue({
+        messagesMap: {},
+        operations: {},
+        messageLoadingIds: [],
+        cancelOperations: mockCancelOperations,
+        cancelOperation: mockCancelOperation,
+        deleteMessage: vi.fn().mockImplementation(() => {
+          callOrder.push('deleteMessage');
+          return Promise.resolve();
+        }),
+        switchMessageBranch: vi.fn().mockImplementation(() => {
+          callOrder.push('switchMessageBranch');
+          return Promise.resolve();
+        }),
+        startOperation: mockStartOperation,
+        completeOperation: mockCompleteOperation,
+        failOperation: mockFailOperation,
+        internal_execAgentRuntime: vi.fn().mockImplementation(() => {
+          callOrder.push('internal_execAgentRuntime');
+          return Promise.resolve();
+        }),
+      } as any);
+
+      const context: ConversationContext = {
+        agentId: 'session-1',
+        topicId: 'topic-1',
+        threadId: null,
+        groupId: 'group-1',
+      };
+
+      const store = createStore({ context });
+
+      // Set displayMessages and dbMessages
+      act(() => {
+        store.setState({
+          displayMessages: [
+            { id: 'msg-1', role: 'user', content: 'Hello' },
+            { id: 'msg-2', role: 'assistant', content: 'Hi there', parentId: 'msg-1' },
+          ],
+          dbMessages: [
+            { id: 'msg-1', role: 'user', content: 'Hello' },
+            { id: 'msg-2', role: 'assistant', content: 'Hi there', parentId: 'msg-1' },
+          ],
+        } as any);
+      });
+
+      await act(async () => {
+        await store.getState().delAndRegenerateMessage('msg-2');
+      });
+
+      // CRITICAL: deleteMessage must be called BEFORE switchMessageBranch and internal_execAgentRuntime
+      // If regeneration (which calls switchMessageBranch) happens first, the message
+      // won't be found in displayMessages and deletion will fail silently.
+      expect(callOrder[0]).toBe('deleteMessage');
+      expect(callOrder).toContain('switchMessageBranch');
+      expect(callOrder).toContain('internal_execAgentRuntime');
+
+      // Verify deleteMessage is called before any regeneration-related calls
+      const deleteIndex = callOrder.indexOf('deleteMessage');
+      const switchIndex = callOrder.indexOf('switchMessageBranch');
+      const execIndex = callOrder.indexOf('internal_execAgentRuntime');
+
+      expect(deleteIndex).toBeLessThan(switchIndex);
+      expect(deleteIndex).toBeLessThan(execIndex);
+    });
+
+    it('should not proceed if assistant message has no parentId', async () => {
+      const { useChatStore } = await import('@/store/chat');
+      vi.mocked(useChatStore.getState).mockReturnValue({
+        messagesMap: {},
+        operations: {},
+        messageLoadingIds: [],
+        startOperation: mockStartOperation,
+        completeOperation: mockCompleteOperation,
+        deleteMessage: mockDeleteMessage,
+      } as any);
+
+      const context: ConversationContext = {
+        agentId: 'session-1',
+        topicId: null,
+        threadId: null,
+      };
+
+      const store = createStore({ context });
+
+      // Set displayMessages with assistant message that has no parentId
+      act(() => {
+        store.setState({
+          displayMessages: [
+            { id: 'msg-1', role: 'assistant', content: 'Hi there' }, // no parentId
+          ],
+        } as any);
+      });
+
+      await act(async () => {
+        await store.getState().delAndRegenerateMessage('msg-1');
+      });
+
+      // Should not proceed - no operation created, no delete called
+      expect(mockStartOperation).not.toHaveBeenCalled();
+      expect(mockDeleteMessage).not.toHaveBeenCalled();
+    });
   });
 
   describe('delAndResendThreadMessage', () => {

package/src/features/Conversation/store/slices/generation/action.ts

@@ -206,18 +206,29 @@ export const generationSlice: StateCreator<
   },
 
   delAndRegenerateMessage: async (messageId: string) => {
-    const { context } = get();
+    const { context, displayMessages } = get();
     const chatStore = useChatStore.getState();
 
+    // Find the assistant message and get parent user message ID before deletion
+    // This is needed because after deletion, we can't find the parent anymore
+    const currentMessage = displayMessages.find((c) => c.id === messageId);
+    if (!currentMessage) return;
+
+    const userId = currentMessage.parentId;
+    if (!userId) return;
+
     // Create operation to track context (use 'regenerate' type since this is a regenerate action)
     const { operationId } = chatStore.startOperation({
       context: { ...context, messageId },
       type: 'regenerate',
     });
 
-    // Regenerate first, then delete
-    await get().regenerateAssistantMessage(messageId);
+    // IMPORTANT: Delete first, then regenerate (LOBE-2533)
+    // If we regenerate first, it switches to a new branch, causing the original
+    // message to no longer appear in displayMessages. Then deleteMessage cannot
+    // find the message and fails silently.
     await chatStore.deleteMessage(messageId, { operationId });
+    await get().regenerateUserMessage(userId);
     chatStore.completeOperation(operationId);
   },
 

package/src/features/EditorCanvas/DiffAllToolbar.tsx

@@ -42,7 +42,6 @@ const useIsEditorInit = (editor: IEditor) => {
     if (!editor) return;
 
     const onInit = () => {
-      console.log('init: id', editor.getLexicalEditor()?._key);
       setEditInit(true);
     };
     editor.on('initialized', onInit);
@@ -103,13 +102,13 @@ interface DiffAllToolbarProps {
 const DiffAllToolbar = memo<DiffAllToolbarProps>(({ documentId }) => {
   const { t } = useTranslation('editor');
   const isDarkMode = useIsDark();
-  const [editor, performSave, markDirty] = useDocumentStore((s) => [
+  const [storeEditor, performSave, markDirty] = useDocumentStore((s) => [
     s.editor!,
     s.performSave,
     s.markDirty,
   ]);
 
-  const hasPendingDiffs = useEditorHasPendingDiffs(editor);
+  const hasPendingDiffs = useEditorHasPendingDiffs(storeEditor);
 
   if (!hasPendingDiffs) return null;
 
@@ -131,7 +130,7 @@ const DiffAllToolbar = memo<DiffAllToolbarProps>(({ documentId }) => {
         <Space>
           <Button
             onClick={async () => {
-              editor?.dispatchCommand(LITEXML_DIFFNODE_ALL_COMMAND, {
+              storeEditor?.dispatchCommand(LITEXML_DIFFNODE_ALL_COMMAND, {
                 action: DiffAction.Reject,
               });
               await handleSave();
@@ -145,7 +144,7 @@ const DiffAllToolbar = memo<DiffAllToolbarProps>(({ documentId }) => {
           <Button
             color={'default'}
             onClick={async () => {
-              editor?.dispatchCommand(LITEXML_DIFFNODE_ALL_COMMAND, {
+              storeEditor?.dispatchCommand(LITEXML_DIFFNODE_ALL_COMMAND, {
                 action: DiffAction.Accept,
               });
               await handleSave();

package/src/features/EditorCanvas/DocumentIdMode.tsx

@@ -2,7 +2,7 @@
 
 import { type IEditor } from '@lobehub/editor';
 import { Alert, Skeleton } from '@lobehub/ui';
-import { memo } from 'react';
+import { memo, useEffect, useRef } from 'react';
 import { useTranslation } from 'react-i18next';
 import { createStoreUpdater } from 'zustand-utils';
 
@@ -82,6 +82,26 @@ const DocumentIdMode = memo<DocumentIdModeProps>(
       onContentChange?.();
     };
 
+    const isEditorInitialized = !!editor?.getLexicalEditor();
+
+    // 追踪已经为哪个 documentId 调用过 onEditorInit
+    const initializedDocIdRef = useRef<string | null>(null);
+
+    // 关键修复：如果 editor 已经初始化，需要主动调用 onEditorInit
+    // 因为 onInit 回调只在 editor 首次初始化时触发
+    useEffect(() => {
+      // 避免重复调用：只在 documentId 变化且 editor 已初始化时调用
+      if (
+        editor &&
+        isEditorInitialized &&
+        !isLoading &&
+        initializedDocIdRef.current !== documentId
+      ) {
+        initializedDocIdRef.current = documentId;
+        onEditorInit(editor);
+      }
+    }, [documentId, editor, isEditorInitialized, isLoading, onEditorInit]);
+
     // Show loading state
     if (isLoading) {
       return <EditorSkeleton />;

package/src/store/document/slices/document/action.ts

@@ -194,6 +194,7 @@ export const createDocumentSlice: StateCreator<
             // Check if this response is still for the current active document
             // This prevents race conditions when quickly switching between documents
             const currentActiveId = get().activeDocumentId;
+
             if (currentActiveId && currentActiveId !== documentId) {
               // User has already switched to another document, discard this stale response
               return;