@lobehub/lobehub 2.0.0-next.28 → 2.0.0-next.29

package/src/services/message/index.ts

@@ -2,8 +2,8 @@
 import {
   ChatMessageError,
   ChatMessagePluginError,
-  ChatTranslate,
   ChatTTS,
+  ChatTranslate,
   CreateMessageParams,
   CreateMessageResult,
   ModelRankItem,
@@ -20,12 +20,9 @@ import { useUserStore } from '@/store/user';
 import { labPreferSelectors } from '@/store/user/selectors';
 
 export class MessageService {
-  createMessage = async ({ sessionId, ...params }: CreateMessageParams): Promise<string> => {
-    return lambdaClient.message.createMessage.mutate({
-      ...params,
-      sessionId: sessionId ? this.toDbSessionId(sessionId) : undefined,
-    });
-  };
+  private get useGroup() {
+    return labPreferSelectors.enableAssistantMessageGroup(useUserStore.getState());
+  }
 
   createNewMessage = async ({
     sessionId,
@@ -42,27 +39,21 @@ export class MessageService {
     topicId?: string,
     groupId?: string,
   ): Promise<UIChatMessage[]> => {
-    // Get user lab preference for message grouping
-    const useGroup = labPreferSelectors.enableAssistantMessageGroup(useUserStore.getState());
-
     const data = await lambdaClient.message.getMessages.query({
       groupId,
       sessionId: this.toDbSessionId(sessionId),
       topicId,
-      useGroup,
+      useGroup: this.useGroup,
     });
 
     return data as unknown as UIChatMessage[];
   };
 
   getGroupMessages = async (groupId: string, topicId?: string): Promise<UIChatMessage[]> => {
-    // Get user lab preference for message grouping
-    const useGroup = labPreferSelectors.enableAssistantMessageGroup(useUserStore.getState());
-
     const data = await lambdaClient.message.getMessages.query({
       groupId,
       topicId,
-      useGroup,
+      useGroup: this.useGroup,
     });
     return data as unknown as UIChatMessage[];
   };
@@ -109,6 +100,7 @@ export class MessageService {
       id,
       sessionId: options?.sessionId,
       topicId: options?.topicId,
+      useGroup: this.useGroup,
       value,
     });
   };
@@ -121,24 +113,70 @@ export class MessageService {
     return lambdaClient.message.updateTTS.mutate({ id, value: tts });
   };
 
-  updateMessagePluginState = async (id: string, value: Record<string, any>) => {
-    return lambdaClient.message.updatePluginState.mutate({ id, value });
+  updateMessagePluginState = async (
+    id: string,
+    value: Record<string, any>,
+    options?: { sessionId?: string | null; topicId?: string | null },
+  ): Promise<UpdateMessageResult> => {
+    return lambdaClient.message.updatePluginState.mutate({
+      id,
+      sessionId: options?.sessionId,
+      topicId: options?.topicId,
+      useGroup: this.useGroup,
+      value,
+    });
   };
 
-  updateMessagePluginError = async (id: string, error: ChatMessagePluginError | null) => {
-    return lambdaClient.message.updatePluginError.mutate({ id, value: error as any });
+  updateMessagePluginError = async (
+    id: string,
+    error: ChatMessagePluginError | null,
+    options?: { sessionId?: string | null; topicId?: string | null },
+  ): Promise<UpdateMessageResult> => {
+    return lambdaClient.message.updatePluginError.mutate({
+      id,
+      sessionId: options?.sessionId,
+      topicId: options?.topicId,
+      useGroup: this.useGroup,
+      value: error as any,
+    });
   };
 
-  updateMessageRAG = async (id: string, data: UpdateMessageRAGParams): Promise<void> => {
-    return lambdaClient.message.updateMessageRAG.mutate({ id, value: data });
+  updateMessageRAG = async (
+    id: string,
+    data: UpdateMessageRAGParams,
+    options?: { sessionId?: string | null; topicId?: string | null },
+  ): Promise<UpdateMessageResult> => {
+    return lambdaClient.message.updateMessageRAG.mutate({
+      id,
+      sessionId: options?.sessionId,
+      topicId: options?.topicId,
+      useGroup: this.useGroup,
+      value: data,
+    });
   };
 
-  removeMessage = async (id: string) => {
-    return lambdaClient.message.removeMessage.mutate({ id });
+  removeMessage = async (
+    id: string,
+    options?: { sessionId?: string | null; topicId?: string | null },
+  ): Promise<UpdateMessageResult> => {
+    return lambdaClient.message.removeMessage.mutate({
+      id,
+      sessionId: options?.sessionId,
+      topicId: options?.topicId,
+      useGroup: this.useGroup,
+    });
   };
 
-  removeMessages = async (ids: string[]) => {
-    return lambdaClient.message.removeMessages.mutate({ ids });
+  removeMessages = async (
+    ids: string[],
+    options?: { sessionId?: string | null; topicId?: string | null },
+  ): Promise<UpdateMessageResult> => {
+    return lambdaClient.message.removeMessages.mutate({
+      ids,
+      sessionId: options?.sessionId,
+      topicId: options?.topicId,
+      useGroup: this.useGroup,
+    });
   };
 
   removeMessagesByAssistant = async (sessionId: string, topicId?: string) => {
@@ -162,16 +200,6 @@ export class MessageService {
   private toDbSessionId = (sessionId: string | undefined) => {
     return sessionId === INBOX_SESSION_ID ? null : sessionId;
   };
-
-  hasMessages = async (): Promise<boolean> => {
-    const number = await this.countMessages();
-    return number > 0;
-  };
-
-  messageCountToCheckTrace = async (): Promise<boolean> => {
-    const number = await this.countMessages();
-    return number >= 4;
-  };
 }
 
 export const messageService = new MessageService();

package/src/store/chat/slices/aiChat/actions/__tests__/generateAIChat.test.ts

@@ -61,7 +61,7 @@ describe('chatMessage actions', () => {
           await result.current.sendMessage({ message: TEST_CONTENT.USER_MESSAGE });
         });
 
-        expect(messageService.createMessage).not.toHaveBeenCalled();
+        expect(messageService.createNewMessage).not.toHaveBeenCalled();
         expect(result.current.internal_coreProcessMessage).not.toHaveBeenCalled();
       });
 
@@ -72,7 +72,7 @@ describe('chatMessage actions', () => {
           await result.current.sendMessage({ message: TEST_CONTENT.EMPTY });
         });
 
-        expect(messageService.createMessage).not.toHaveBeenCalled();
+        expect(messageService.createNewMessage).not.toHaveBeenCalled();
       });
 
       it('should not send when message is empty with empty files array', async () => {
@@ -82,7 +82,7 @@ describe('chatMessage actions', () => {
           await result.current.sendMessage({ message: TEST_CONTENT.EMPTY, files: [] });
         });
 
-        expect(messageService.createMessage).not.toHaveBeenCalled();
+        expect(messageService.createNewMessage).not.toHaveBeenCalled();
       });
     });
 
@@ -97,13 +97,13 @@ describe('chatMessage actions', () => {
           });
         });
 
-        expect(messageService.createMessage).toHaveBeenCalled();
+        expect(messageService.createNewMessage).toHaveBeenCalled();
         expect(result.current.internal_coreProcessMessage).not.toHaveBeenCalled();
       });
 
       it('should handle message creation errors gracefully', async () => {
         const { result } = renderHook(() => useChatStore());
-        vi.spyOn(messageService, 'createMessage').mockRejectedValue(
+        vi.spyOn(messageService, 'createNewMessage').mockRejectedValue(
           new Error('create message error'),
         );
 
@@ -210,6 +210,8 @@ describe('chatMessage actions', () => {
 
   describe('internal_coreProcessMessage', () => {
     it('should process user message and generate AI response', async () => {
+      const mockMessages = [{ id: 'msg-1', content: 'test' }] as any;
+
       act(() => {
         useChatStore.setState({ internal_coreProcessMessage: realCoreProcessMessage });
       });
@@ -227,8 +229,10 @@ describe('chatMessage actions', () => {
         .mockResolvedValue({ isFunctionCall: false, content: 'AI response' });
 
       const createMessageSpy = vi
-        .spyOn(messageService, 'createMessage')
-        .mockResolvedValue(TEST_IDS.ASSISTANT_MESSAGE_ID);
+        .spyOn(messageService, 'createNewMessage')
+        .mockResolvedValue({ id: TEST_IDS.ASSISTANT_MESSAGE_ID, messages: mockMessages });
+
+      const replaceMessagesSpy = vi.spyOn(result.current, 'replaceMessages');
 
       await act(async () => {
         await result.current.internal_coreProcessMessage([userMessage], userMessage.id);
@@ -245,7 +249,7 @@ describe('chatMessage actions', () => {
       );
 
       expect(fetchAIChatSpy).toHaveBeenCalled();
-      expect(result.current.refreshMessages).toHaveBeenCalled();
+      expect(replaceMessagesSpy).toHaveBeenCalledWith(mockMessages);
     });
 
     it('should handle RAG flow when ragQuery is provided', async () => {
@@ -268,7 +272,10 @@ describe('chatMessage actions', () => {
           rewriteQuery: 'rewritten query',
         });
 
-      vi.spyOn(messageService, 'createMessage').mockResolvedValue(TEST_IDS.ASSISTANT_MESSAGE_ID);
+      vi.spyOn(messageService, 'createNewMessage').mockResolvedValue({
+        id: TEST_IDS.ASSISTANT_MESSAGE_ID,
+        messages: [],
+      });
 
       await act(async () => {
         await result.current.internal_coreProcessMessage([userMessage], userMessage.id, {
@@ -299,7 +306,7 @@ describe('chatMessage actions', () => {
         .spyOn(result.current, 'internal_fetchAIChatMessage')
         .mockResolvedValue({ isFunctionCall: false, content: '' });
 
-      vi.spyOn(messageService, 'createMessage').mockResolvedValue(undefined as any);
+      vi.spyOn(messageService, 'createNewMessage').mockResolvedValue(undefined as any);
 
       await act(async () => {
         await result.current.internal_coreProcessMessage([userMessage], userMessage.id);

package/src/store/chat/slices/aiChat/actions/__tests__/generateAIChatV2.test.ts

@@ -131,7 +131,7 @@ describe('generateAIChatV2 actions', () => {
           await result.current.sendMessage({ message: TEST_CONTENT.USER_MESSAGE });
         });
 
-        expect(messageService.createMessage).not.toHaveBeenCalled();
+        expect(messageService.createNewMessage).not.toHaveBeenCalled();
         expect(result.current.internal_execAgentRuntime).not.toHaveBeenCalled();
       });
 
@@ -142,7 +142,7 @@ describe('generateAIChatV2 actions', () => {
           await result.current.sendMessage({ message: TEST_CONTENT.EMPTY });
         });
 
-        expect(messageService.createMessage).not.toHaveBeenCalled();
+        expect(messageService.createNewMessage).not.toHaveBeenCalled();
       });
 
       it('should not send when message is empty with empty files array', async () => {
@@ -152,7 +152,7 @@ describe('generateAIChatV2 actions', () => {
           await result.current.sendMessage({ message: TEST_CONTENT.EMPTY, files: [] });
         });
 
-        expect(messageService.createMessage).not.toHaveBeenCalled();
+        expect(messageService.createNewMessage).not.toHaveBeenCalled();
       });
     });
 
@@ -312,7 +312,7 @@ describe('generateAIChatV2 actions', () => {
           });
         });
 
-        expect(messageService.createMessage).toHaveBeenCalled();
+        expect(messageService.createNewMessage).toHaveBeenCalled();
         expect(result.current.internal_execAgentRuntime).not.toHaveBeenCalled();
       });
 

package/src/store/chat/slices/aiChat/actions/__tests__/helpers.ts

@@ -58,8 +58,8 @@ export const createMockAbortController = () => {
  */
 export const spyOnMessageService = () => {
   const createMessageSpy = vi
-    .spyOn(messageService, 'createMessage')
-    .mockResolvedValue(TEST_IDS.NEW_MESSAGE_ID);
+    .spyOn(messageService, 'createNewMessage')
+    .mockResolvedValue({ id: TEST_IDS.NEW_MESSAGE_ID, messages: [] });
   const updateMessageSpy = vi
     .spyOn(messageService, 'updateMessage')
     .mockResolvedValue({ messages: [], success: true });

package/src/store/chat/slices/aiChat/actions/generateAIChat.ts

@@ -220,9 +220,10 @@ export const generateAIChat: StateCreator<
       ragQueryId,
     };
 
-    const assistantId = await get().internal_createMessage(assistantMessage);
+    const result = await get().internal_createMessage(assistantMessage);
 
-    if (!assistantId) return;
+    if (!result) return;
+    const assistantId = result.id;
 
     // 3. place a search with the search working model if this model is not support tool use
     const aiInfraStoreState = getAiInfraStoreState();

package/src/store/chat/slices/aiChat/actions/generateAIChatV2.ts

@@ -659,7 +659,7 @@ export const generateAIChatV2: StateCreator<
           groupId: groupMessage.groupId, // Propagate groupId from parent message for group chat
         };
 
-        const result = await get().internal_createNewMessage(toolMessage);
+        const result = await get().internal_createMessage(toolMessage);
 
         if (!result) {
           log('[triggerToolsCalling] Failed to create tool message for %s', payload.identifier);
@@ -768,7 +768,7 @@ export const generateAIChatV2: StateCreator<
       topicId: get().activeTopicId,
     });
 
-    const result = await get().internal_createNewMessage(assistantMessage, { groupMessageId });
+    const result = await get().internal_createMessage(assistantMessage, { groupMessageId });
 
     if (!result) {
       log('[callToolFollowAssistantMessage] Failed to create assistant message');

package/src/store/chat/slices/aiChat/actions/generateAIGroupChat.ts

@@ -294,7 +294,7 @@ export const chatAiGroupChat: StateCreator<
           targetId: targetMemberId,
         };
 
-        const messageId = await internal_createMessage(userMessage);
+        const result = await internal_createMessage(userMessage);
 
         // if only add user message, then stop
         if (onlyAddUserMessage) {
@@ -302,6 +302,9 @@ export const chatAiGroupChat: StateCreator<
           return;
         }
 
+        if (!result) return;
+        const messageId = result.id;
+
         if (messageId) {
           // Use the specific group's config rather than relying on active session
           const groupConfig = selectGroupConfig(groupId);
@@ -668,7 +671,9 @@ export const chatAiGroupChat: StateCreator<
 
         console.log('DEBUG: Creating agent message with:', agentMessage);
 
-        const assistantId = await internal_createMessage(agentMessage);
+        const result = await internal_createMessage(agentMessage);
+        if (!result) return;
+        const assistantId = result.id;
 
         const systemMessage: UIChatMessage = {
           id: 'group-system',

package/src/store/chat/slices/builtinTool/actions/search.ts

@@ -106,16 +106,16 @@ export const searchSlice: StateCreator<
       });
     };
 
-    const [newMessageId] = await Promise.all([
+    const [result] = await Promise.all([
       // 1. 添加 tool message
       internal_createMessage(toolMessage),
       // 2. 将这条 tool call message 插入到 ai 消息的 tools 中
       addToolItem(),
     ]);
-    if (!newMessageId) return;
+    if (!result) return;
 
     // 将新创建的 tool message 激活
-    openToolUI(newMessageId, message.plugin.identifier);
+    openToolUI(result.id, message.plugin.identifier);
   },
 
   search: async (id, params, aiSummary = true) => {

package/src/store/chat/slices/message/action.test.ts

@@ -25,7 +25,7 @@ vi.mock('@/services/message', () => ({
     removeMessage: vi.fn(),
     removeMessagesByAssistant: vi.fn(),
     removeMessages: vi.fn(() => Promise.resolve()),
-    createMessage: vi.fn(() => Promise.resolve('new-message-id')),
+    createNewMessage: vi.fn(() => Promise.resolve({ id: 'new-message-id', messages: [] })),
     updateMessage: vi.fn(),
     removeAllMessages: vi.fn(() => Promise.resolve()),
   },
@@ -71,7 +71,7 @@ describe('chatMessage actions', () => {
         await result.current.addAIMessage();
       });
 
-      expect(messageService.createMessage).not.toHaveBeenCalled();
+      expect(messageService.createNewMessage).not.toHaveBeenCalled();
       expect(updateInputMessageSpy).not.toHaveBeenCalled();
     });
 
@@ -84,7 +84,7 @@ describe('chatMessage actions', () => {
         await result.current.addAIMessage();
       });
 
-      expect(messageService.createMessage).toHaveBeenCalledWith({
+      expect(messageService.createNewMessage).toHaveBeenCalledWith({
         content: inputMessage,
         role: 'assistant',
         sessionId: mockState.activeId,
@@ -113,7 +113,7 @@ describe('chatMessage actions', () => {
         await result.current.addUserMessage({ message: 'test message' });
       });
 
-      expect(messageService.createMessage).not.toHaveBeenCalled();
+      expect(messageService.createNewMessage).not.toHaveBeenCalled();
       expect(updateInputMessageSpy).not.toHaveBeenCalled();
     });
 
@@ -130,7 +130,7 @@ describe('chatMessage actions', () => {
         await result.current.addUserMessage({ message, fileList });
       });
 
-      expect(messageService.createMessage).toHaveBeenCalledWith({
+      expect(messageService.createNewMessage).toHaveBeenCalledWith({
         content: message,
         files: fileList,
         role: 'user',
@@ -154,7 +154,7 @@ describe('chatMessage actions', () => {
         await result.current.addUserMessage({ message });
       });
 
-      expect(messageService.createMessage).toHaveBeenCalledWith({
+      expect(messageService.createNewMessage).toHaveBeenCalledWith({
         content: message,
         files: undefined,
         role: 'user',
@@ -184,7 +184,7 @@ describe('chatMessage actions', () => {
         await result.current.addUserMessage({ message });
       });
 
-      expect(messageService.createMessage).toHaveBeenCalledWith({
+      expect(messageService.createNewMessage).toHaveBeenCalledWith({
         content: message,
         files: undefined,
         role: 'user',
@@ -200,6 +200,15 @@ describe('chatMessage actions', () => {
       const { result } = renderHook(() => useChatStore());
       const messageId = 'message-id';
       const deleteSpy = vi.spyOn(result.current, 'deleteMessage');
+      const mockMessages = [{ id: 'other-message' }] as any;
+
+      // Mock the service to return messages
+      (messageService.removeMessages as Mock).mockResolvedValue({
+        success: true,
+        messages: mockMessages,
+      });
+
+      const replaceMessagesSpy = vi.spyOn(result.current, 'replaceMessages');
 
       act(() => {
         useChatStore.setState({
@@ -215,13 +224,22 @@ describe('chatMessage actions', () => {
       });
 
       expect(deleteSpy).toHaveBeenCalledWith(messageId);
-      expect(result.current.refreshMessages).toHaveBeenCalled();
+      expect(replaceMessagesSpy).toHaveBeenCalledWith(mockMessages);
     });
 
     it('deleteMessage should remove messages with tools', async () => {
       const { result } = renderHook(() => useChatStore());
       const messageId = 'message-id';
       const removeMessagesSpy = vi.spyOn(messageService, 'removeMessages');
+      const mockMessages = [{ id: 'remaining-message' }] as any;
+
+      // Mock the service to return messages
+      (messageService.removeMessages as Mock).mockResolvedValue({
+        success: true,
+        messages: mockMessages,
+      });
+
+      const replaceMessagesSpy = vi.spyOn(result.current, 'replaceMessages');
 
       act(() => {
         useChatStore.setState({
@@ -240,8 +258,120 @@ describe('chatMessage actions', () => {
         await result.current.deleteMessage(messageId);
       });
 
-      expect(removeMessagesSpy).toHaveBeenCalledWith([messageId, '2', '3']);
-      expect(result.current.refreshMessages).toHaveBeenCalled();
+      expect(removeMessagesSpy).toHaveBeenCalledWith([messageId, '2', '3'], {
+        sessionId: 'session-id',
+        topicId: undefined,
+      });
+      expect(replaceMessagesSpy).toHaveBeenCalledWith(mockMessages);
+    });
+
+    it('deleteMessage should remove group message with all children', async () => {
+      const { result } = renderHook(() => useChatStore());
+      const groupMessageId = 'group-message-id';
+      const removeMessagesSpy = vi.spyOn(messageService, 'removeMessages');
+      const mockMessages = [{ id: 'remaining-message' }] as any;
+
+      // Mock the service to return messages
+      (messageService.removeMessages as Mock).mockResolvedValue({
+        success: true,
+        messages: mockMessages,
+      });
+
+      const replaceMessagesSpy = vi.spyOn(result.current, 'replaceMessages');
+
+      act(() => {
+        useChatStore.setState({
+          activeId: 'session-id',
+          activeTopicId: undefined,
+          messagesMap: {
+            [messageMapKey('session-id')]: [
+              { id: groupMessageId, role: 'group', content: 'Group message' } as UIChatMessage,
+              {
+                id: 'child-1',
+                parentId: groupMessageId,
+                role: 'assistant',
+                content: 'Child 1',
+              } as UIChatMessage,
+              {
+                id: 'child-2',
+                parentId: groupMessageId,
+                role: 'assistant',
+                content: 'Child 2',
+              } as UIChatMessage,
+              { id: 'other-message', role: 'user', content: 'Other' } as UIChatMessage,
+            ],
+          },
+        });
+      });
+      await act(async () => {
+        await result.current.deleteMessage(groupMessageId);
+      });
+
+      expect(removeMessagesSpy).toHaveBeenCalledWith([groupMessageId, 'child-1', 'child-2'], {
+        sessionId: 'session-id',
+        topicId: undefined,
+      });
+      expect(replaceMessagesSpy).toHaveBeenCalledWith(mockMessages);
+    });
+
+    it('deleteMessage should remove group message with children that have tool calls', async () => {
+      const { result } = renderHook(() => useChatStore());
+      const groupMessageId = 'group-message-id';
+      const removeMessagesSpy = vi.spyOn(messageService, 'removeMessages');
+      const mockMessages = [{ id: 'remaining-message' }] as any;
+
+      // Mock the service to return messages
+      (messageService.removeMessages as Mock).mockResolvedValue({
+        success: true,
+        messages: mockMessages,
+      });
+
+      const replaceMessagesSpy = vi.spyOn(result.current, 'replaceMessages');
+
+      act(() => {
+        useChatStore.setState({
+          activeId: 'session-id',
+          activeTopicId: undefined,
+          messagesMap: {
+            [messageMapKey('session-id')]: [
+              { id: groupMessageId, role: 'group', content: 'Group message' } as UIChatMessage,
+              {
+                id: 'child-1',
+                parentId: groupMessageId,
+                role: 'assistant',
+                content: 'Child with tools',
+                tools: [{ id: 'tool1' }],
+              } as UIChatMessage,
+              {
+                id: 'tool-result-1',
+                tool_call_id: 'tool1',
+                role: 'tool',
+                content: 'Tool result',
+              } as UIChatMessage,
+              {
+                id: 'child-2',
+                parentId: groupMessageId,
+                role: 'assistant',
+                content: 'Child 2',
+              } as UIChatMessage,
+              { id: 'other-message', role: 'user', content: 'Other' } as UIChatMessage,
+            ],
+          },
+        });
+      });
+      await act(async () => {
+        await result.current.deleteMessage(groupMessageId);
+      });
+
+      // Should delete group message + all children + tool results of children
+      expect(removeMessagesSpy).toHaveBeenCalledWith(
+        [groupMessageId, 'child-1', 'child-2', 'tool-result-1'],
+        {
+          sessionId: 'session-id',
+          topicId: undefined,
+        },
+      );
+      expect(replaceMessagesSpy).toHaveBeenCalledWith(mockMessages);
     });
   });
 
@@ -309,10 +439,16 @@ describe('chatMessage actions', () => {
       });
 
       expect(removeMessageSpy).toHaveBeenCalled();
-      expect(updateMessageSpy).toHaveBeenCalledWith('message-id', {
-        tools: [{ id: 'tool2' }],
-      });
-      expect(result.current.refreshMessages).toHaveBeenCalled();
+      expect(updateMessageSpy).toHaveBeenCalledWith(
+        'message-id',
+        {
+          tools: [{ id: 'tool2' }],
+        },
+        {
+          sessionId: 'session-id',
+          topicId: undefined,
+        },
+      );
     });
   });
 
@@ -320,13 +456,14 @@ describe('chatMessage actions', () => {
     it('clearAllMessages should remove all messages', async () => {
       const { result } = renderHook(() => useChatStore());
       const clearAllSpy = vi.spyOn(result.current, 'clearAllMessages');
+      const replaceMessagesSpy = vi.spyOn(result.current, 'replaceMessages');
 
       await act(async () => {
         await result.current.clearAllMessages();
       });
 
       expect(clearAllSpy).toHaveBeenCalled();
-      expect(result.current.refreshMessages).toHaveBeenCalled();
+      expect(replaceMessagesSpy).toHaveBeenCalledWith([]);
     });
   });