@lobehub/lobehub 2.0.0-next.273 → 2.0.0-next.275

package/src/server/routers/lambda/agentGroup.ts

@@ -37,6 +37,45 @@ export const agentGroupRouter = router({
       return ctx.chatGroupModel.addAgentsToGroup(input.groupId, input.agentIds);
     }),
 
+  /**
+   * Batch create virtual agents and add them to an existing group.
+   * This is more efficient than calling createAgentOnly multiple times.
+   */
+  batchCreateAgentsInGroup: agentGroupProcedure
+    .input(
+      z.object({
+        agents: z.array(
+          insertAgentSchema
+            .omit({
+              chatConfig: true,
+              openingMessage: true,
+              openingQuestions: true,
+              tts: true,
+              userId: true,
+            })
+            .partial(),
+        ),
+        groupId: z.string(),
+      }),
+    )
+    .mutation(async ({ input, ctx }) => {
+      // Batch create virtual agents
+      const agentConfigs = input.agents.map((agent) => ({
+        ...agent,
+        plugins: agent.plugins as string[] | undefined,
+        tags: agent.tags as string[] | undefined,
+        virtual: true,
+      }));
+
+      const createdAgents = await ctx.agentModel.batchCreate(agentConfigs);
+      const agentIds = createdAgents.map((agent) => agent.id);
+
+      // Add all agents to the group
+      await ctx.chatGroupModel.addAgentsToGroup(input.groupId, agentIds);
+
+      return { agentIds, agents: createdAgents };
+    }),
+
   /**
    * Check agents before removal to identify virtual agents that will be permanently deleted.
    * This allows the frontend to show a confirmation dialog.

package/src/services/agent.ts

@@ -51,6 +51,15 @@ export interface CreateAgentResult {
   sessionId: string;
 }
 
+export interface CreateAgentOnlyParams {
+  config?: PartialDeep<AgentItem>;
+  groupId: string;
+}
+
+export interface CreateAgentOnlyResult {
+  agentId: string;
+}
+
 class AgentService {
   /**
    * Check if an agent with the given marketIdentifier already exists
@@ -80,6 +89,19 @@ class AgentService {
     });
   };
 
+  /**
+   * Create a virtual agent without session.
+   * Used for Group Agent Builder to create virtual agents for groups.
+   */
+  createAgentOnly = async (params: CreateAgentOnlyParams): Promise<CreateAgentOnlyResult> => {
+    const normalizedConfig = normalizeMarketAgentModel(params.config);
+
+    return lambdaClient.agent.createAgentOnly.mutate({
+      config: normalizedConfig as any,
+      groupId: params.groupId,
+    });
+  };
+
   createAgentKnowledgeBase = async (
     agentId: string,
     knowledgeBaseId: string,

package/src/services/chatGroup/index.ts

@@ -85,6 +85,20 @@ class ChatGroupService {
     return lambdaClient.group.addAgentsToGroup.mutate({ agentIds, groupId });
   };
 
+  /**
+   * Batch create virtual agents and add them to an existing group.
+   * This is more efficient than calling createAgentOnly multiple times.
+   */
+  batchCreateAgentsInGroup = (
+    groupId: string,
+    agents: GroupMemberConfig[],
+  ) => {
+    return lambdaClient.group.batchCreateAgentsInGroup.mutate({
+      agents: agents as Partial<AgentItem>[],
+      groupId,
+    });
+  };
+
   removeAgentsFromGroup = (groupId: string, agentIds: string[]) => {
     return lambdaClient.group.removeAgentsFromGroup.mutate({ agentIds, groupId });
   };

package/src/store/agent/selectors/selectors.ts

@@ -260,6 +260,8 @@ const currentAgentLocalSystemConfig = (s: AgentStoreState): LocalSystemConfig |
 const currentAgentWorkingDirectory = (s: AgentStoreState): string | undefined =>
   currentAgentLocalSystemConfig(s)?.workingDirectory;
 
+const isCurrentAgentExternal = (s: AgentStoreState): boolean => !currentAgentData(s)?.virtual;
+
 export const agentSelectors = {
   currentAgentAvatar,
   currentAgentBackgroundColor,
@@ -293,6 +295,7 @@ export const agentSelectors = {
   inboxAgentModel,
   isAgentConfigLoading,
   isAgentModeEnabled,
+  isCurrentAgentExternal,
   openingMessage,
   openingQuestions,
 };

package/src/store/agentGroup/initialState.ts

@@ -1,13 +1,19 @@
 import type { AgentGroupDetail } from '@lobechat/types';
+import type { ParsedQuery } from 'query-string';
 
 import type { ChatGroupItem } from '@/database/schemas/chatGroup';
 
+export interface QueryRouter {
+  push: (url: string, options?: { query?: ParsedQuery }) => void;
+}
+
 export interface ChatGroupState {
   activeGroupId?: string;
   activeThreadAgentId: string;
   groupMap: Record<string, AgentGroupDetail>;
   groups: ChatGroupItem[];
   groupsInit: boolean;
+  router?: QueryRouter;
   showGroupSetting: boolean;
   /**
    * Content being streamed for system prompt update (for GroupAgentBuilder)

package/src/store/agentGroup/selectors/byId.ts

@@ -19,6 +19,8 @@ const groupConfig = (groupId: string) => (s: ChatGroupStore) => {
 const groupMeta = (groupId: string) => (s: ChatGroupStore) => {
   const group = groupById(groupId)(s);
   return merge(DEFAULT_CHAT_GROUP_META_CONFIG, {
+    avatar: group?.avatar || undefined,
+    backgroundColor: group?.backgroundColor || undefined,
     description: group?.description || '',
     title: group?.title || '',
   });
@@ -26,7 +28,7 @@ const groupMeta = (groupId: string) => (s: ChatGroupStore) => {
 
 const groupAgents =
   (groupId: string) =>
-  (s: ChatGroupStore): AgentItem[] => {
+  (s: ChatGroupStore): AgentGroupMember[] => {
     const group = groupById(groupId)(s);
     return group?.agents || [];
   };

package/src/store/agentGroup/selectors/current.ts

@@ -3,7 +3,7 @@ import {
   DEFAULT_CHAT_GROUP_CHAT_CONFIG,
   DEFAULT_CHAT_GROUP_META_CONFIG,
 } from '@lobechat/const';
-import type { AgentGroupDetail, AgentGroupMember, AgentItem } from '@lobechat/types';
+import type { AgentGroupDetail, AgentGroupMember } from '@lobechat/types';
 
 import type { ChatGroupState } from '../initialState';
 import type { ChatGroupStore } from '../store';
@@ -36,7 +36,7 @@ const currentGroupMeta = (s: ChatGroupStore) => {
   return groupId ? agentGroupByIdSelectors.groupMeta(groupId)(s) : DEFAULT_CHAT_GROUP_META_CONFIG;
 };
 
-const currentGroupAgents = (s: ChatGroupStore): AgentItem[] => {
+const currentGroupAgents = (s: ChatGroupStore): AgentGroupMember[] => {
   const groupId = activeGroupId(s);
   return groupId ? agentGroupByIdSelectors.groupAgents(groupId)(s) : [];
 };

package/src/store/agentGroup/slices/lifecycle.ts

@@ -1,8 +1,10 @@
 import type { NewChatGroup } from '@lobechat/types';
+import urlJoin from 'url-join';
 import { type StateCreator } from 'zustand/vanilla';
 
 import { chatGroupService } from '@/services/chatGroup';
 import { type ChatGroupStore } from '@/store/agentGroup/store';
+import { useChatStore } from '@/store/chat';
 import { getSessionStoreState } from '@/store/session';
 
 export interface ChatGroupLifecycleAction {
@@ -11,6 +13,11 @@ export interface ChatGroupLifecycleAction {
     agentIds?: string[],
     silent?: boolean,
   ) => Promise<string>;
+  /**
+   * Switch to a new topic in the group
+   * Clears activeTopicId and navigates to group root
+   */
+  switchToNewTopic: () => void;
 }
 
 export const chatGroupLifecycleSlice: StateCreator<
@@ -48,4 +55,15 @@ export const chatGroupLifecycleSlice: StateCreator<
 
     return group.id;
   },
+
+  switchToNewTopic: () => {
+    const { activeGroupId, router } = get();
+    if (!activeGroupId || !router) return;
+
+    useChatStore.setState({ activeTopicId: undefined });
+
+    router.push(urlJoin('/group', activeGroupId), {
+      query: { bt: null, tab: null, thread: null, topic: null },
+    });
+  },
 });

package/src/store/chat/agents/__tests__/createAgentExecutors/fixtures/mockStore.ts

@@ -15,7 +15,7 @@ export const createMockStore = (overrides: Partial<ChatStore> = {}): ChatStore =
 
   const store = {
     // Other store properties (add as needed)
-    activeId: 'test-session',
+    activeAgentId: 'test-session',
 
     activeTopicId: 'test-topic',
 

package/src/store/chat/slices/aiAgent/actions/__tests__/agentGroup.test.ts

@@ -556,7 +556,10 @@ describe('agentGroup actions', () => {
           });
         });
 
-        expect(result.current.switchTopic).toHaveBeenCalledWith(TEST_IDS.TOPIC_ID, true);
+        expect(result.current.switchTopic).toHaveBeenCalledWith(TEST_IDS.TOPIC_ID, {
+          clearNewKey: true,
+          skipRefreshMessage: true,
+        });
       });
 
       it('should not switch topic when using existing topic', async () => {

package/src/store/chat/slices/aiAgent/actions/agentGroup.ts

@@ -118,7 +118,7 @@ export const agentGroupSlice: StateCreator<
 
       // 4. Switch to new topic if created
       if (result.isCreateNewTopic && result.topicId) {
-        await get().switchTopic(result.topicId, true);
+        await get().switchTopic(result.topicId, { clearNewKey: true, skipRefreshMessage: true });
       }
 
       // 5. Create execContext with updated topicId from server response

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

@@ -3,6 +3,7 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 import { aiChatService } from '@/services/aiChat';
 import * as agentGroupStore from '@/store/agentGroup';
+import { messageMapKey } from '@/store/chat/utils/messageMapKey';
 import { getSessionStoreState } from '@/store/session';
 
 import { useChatStore } from '../../../../store';
@@ -353,5 +354,69 @@ describe('ConversationLifecycle actions', () => {
         );
       });
     });
+
+    describe('new topic creation cleanup', () => {
+      it('should clear _new key data when new topic is created', async () => {
+        const { result } = renderHook(() => useChatStore());
+        const agentId = TEST_IDS.SESSION_ID;
+        const newTopicId = 'created-topic-id';
+
+        // Setup initial state: messages exist in the _new key (no topicId)
+        const newKey = messageMapKey({ agentId, topicId: null });
+        const existingMessages = [
+          createMockMessage({ id: 'old-msg-1', role: 'user' }),
+          createMockMessage({ id: 'old-msg-2', role: 'assistant' }),
+        ];
+
+        await act(async () => {
+          useChatStore.setState({
+            activeAgentId: agentId,
+            activeTopicId: undefined,
+            messagesMap: {
+              [newKey]: existingMessages,
+            },
+            dbMessagesMap: {
+              [newKey]: existingMessages,
+            },
+          });
+        });
+
+        // Verify messages exist in _new key before sending
+        expect(useChatStore.getState().messagesMap[newKey]).toHaveLength(2);
+
+        // Mock server response with new topic creation
+        vi.spyOn(aiChatService, 'sendMessageInServer').mockResolvedValue({
+          messages: [
+            createMockMessage({ id: 'new-user-msg', role: 'user', topicId: newTopicId }),
+            createMockMessage({ id: 'new-assistant-msg', role: 'assistant', topicId: newTopicId }),
+          ],
+          topics: { items: [{ id: newTopicId, title: 'New Topic' }], total: 1 },
+          topicId: newTopicId,
+          isCreateNewTopic: true,
+          assistantMessageId: 'new-assistant-msg',
+          userMessageId: 'new-user-msg',
+        } as any);
+
+        // Mock switchTopic to verify it's called correctly
+        const switchTopicSpy = vi.spyOn(result.current, 'switchTopic');
+
+        await act(async () => {
+          await result.current.sendMessage({
+            message: TEST_CONTENT.USER_MESSAGE,
+            context: { agentId, topicId: null, threadId: null },
+          });
+        });
+
+        // switchTopic should be called with the new topicId and clearNewKey option
+        expect(switchTopicSpy).toHaveBeenCalledWith(newTopicId, {
+          clearNewKey: true,
+          skipRefreshMessage: true,
+        });
+
+        // After new topic creation, the _new key should be cleared
+        const messagesInNewKey = useChatStore.getState().messagesMap[newKey];
+        expect(messagesInNewKey ?? []).toHaveLength(0);
+      });
+    });
   });
 });

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

@@ -286,7 +286,8 @@ export const conversationLifecycle: StateCreator<
       });
 
       if (data.isCreateNewTopic && data.topicId) {
-        await get().switchTopic(data.topicId, true);
+        // clearNewKey: true ensures the _new key data is cleared after topic creation
+        await get().switchTopic(data.topicId, { clearNewKey: true, skipRefreshMessage: true });
       }
     } catch (e) {
       console.error(e);

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

@@ -43,7 +43,7 @@ describe('search actions', () => {
       invokeBuiltinTool: vi.fn(),
     });
 
-    // Default mock for dbMessageSelectors - returns undefined to use activeId/activeTopicId
+    // Default mock for dbMessageSelectors - returns undefined to use activeAgentId/activeTopicId
     vi.spyOn(dbMessageSelectors, 'getDbMessageById').mockImplementation(() => () => undefined);
   });
 

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

@@ -2,13 +2,10 @@ import { type StateCreator } from 'zustand/vanilla';
 
 import { type ChatStore } from '@/store/chat/store';
 
-import { type AgentBuilderAction, agentBuilderSlice } from './agentBuilder';
-import { type GroupAgentBuilderAction, groupAgentBuilderSlice } from './groupAgentBuilder';
 import { type ChatCodeInterpreterAction, codeInterpreterSlice } from './interpreter';
 import { type SearchAction, searchSlice } from './search';
 
-export interface ChatBuiltinToolAction
-  extends SearchAction, ChatCodeInterpreterAction, AgentBuilderAction, GroupAgentBuilderAction {}
+export interface ChatBuiltinToolAction extends SearchAction, ChatCodeInterpreterAction {}
 
 export const chatToolSlice: StateCreator<
   ChatStore,
@@ -18,6 +15,4 @@ export const chatToolSlice: StateCreator<
 > = (...params) => ({
   ...searchSlice(...params),
   ...codeInterpreterSlice(...params),
-  ...agentBuilderSlice(...params),
-  ...groupAgentBuilderSlice(...params),
 });

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

@@ -75,7 +75,7 @@ afterEach(() => {
 
 describe('chatMessage actions', () => {
   describe('addAIMessage', () => {
-    it('should return early if activeId is undefined', async () => {
+    it('should return early if activeAgentId is undefined', async () => {
       useChatStore.setState({ activeAgentId: undefined });
       const { result } = renderHook(() => useChatStore());
       const updateMessageInputSpy = vi.spyOn(result.current, 'updateMessageInput');
@@ -117,7 +117,7 @@ describe('chatMessage actions', () => {
   });
 
   describe('addUserMessage', () => {
-    it('should return early if activeId is undefined', async () => {
+    it('should return early if activeAgentId is undefined', async () => {
       useChatStore.setState({ activeAgentId: undefined });
       const { result } = renderHook(() => useChatStore());
       const updateMessageInputSpy = vi.spyOn(result.current, 'updateMessageInput');
@@ -739,7 +739,7 @@ describe('chatMessage actions', () => {
       useChatStore.setState({ refreshMessages: realRefreshMessages });
 
       const { result } = renderHook(() => useChatStore());
-      const activeId = useChatStore.getState().activeAgentId;
+      const activeAgentId = useChatStore.getState().activeAgentId;
       const activeTopicId = useChatStore.getState().activeTopicId;
 
       // 在这里，我们不需要再次模拟 mutate，因为它已经在顶部被模拟了
@@ -750,13 +750,13 @@ describe('chatMessage actions', () => {
       // 确保 mutate 调用了正确的参数（session 和 group 两次）
       expect(mutate).toHaveBeenCalledWith([
         'SWR_USE_FETCH_MESSAGES',
-        activeId,
+        activeAgentId,
         activeTopicId,
         'session',
       ]);
       expect(mutate).toHaveBeenCalledWith([
         'SWR_USE_FETCH_MESSAGES',
-        activeId,
+        activeAgentId,
         activeTopicId,
         'group',
       ]);

package/src/store/chat/slices/message/actions/publicApi.ts

@@ -235,16 +235,16 @@ export const messagePublicApi: StateCreator<
   },
 
   clearMessage: async () => {
-    const { activeId, activeTopicId, activeGroupId, refreshTopic, switchTopic } = get();
+    const { activeAgentId, activeTopicId, activeGroupId, refreshTopic, switchTopic } = get();
 
     // For group sessions, we need to clear group messages using groupId
-    // For regular sessions, we clear session messages using sessionId
+    // For regular sessions, we clear session messages using agentId
     if (activeGroupId) {
       // For group chat, activeGroupId is the groupId
       await messageService.removeMessagesByGroup(activeGroupId, activeTopicId);
     } else {
-      // For regular session, activeId is the sessionId
-      await messageService.removeMessagesByAssistant(activeId, activeTopicId);
+      // For regular session, activeAgentId is the agentId
+      await messageService.removeMessagesByAssistant(activeAgentId, activeTopicId);
     }
 
     if (activeTopicId) {
@@ -256,7 +256,7 @@ export const messagePublicApi: StateCreator<
     get().replaceMessages([]);
 
     // after remove topic , go back to default topic
-    switchTopic();
+    switchTopic(null);
   },
 
   clearAllMessages: async () => {

package/src/store/chat/slices/message/initialState.ts

@@ -4,10 +4,6 @@ import { type ChatGroupAgentItem } from '@/database/schemas/chatGroup';
 
 export interface ChatMessageState {
   activeAgentId: string;
-  /**
-   * @deprecated
-   */
-  activeId: string;
   /**
    * Raw messages from database (flat structure)
    */
@@ -37,7 +33,6 @@ export interface ChatMessageState {
 
 export const initialMessageState: ChatMessageState = {
   activeAgentId: '',
-  activeId: 'inbox',
   dbMessagesMap: {},
   groupAgentMaps: {},
   isCreatingMessage: false,

package/src/store/chat/slices/message/selectors/displayMessage.test.ts

@@ -288,7 +288,7 @@ describe('displayMessageSelectors', () => {
   });
 
   describe('currentDisplayChatKey', () => {
-    it('should generate correct key with activeId only', () => {
+    it('should generate correct key with activeAgentId only', () => {
       const state: Partial<ChatStore> = {
         activeAgentId: 'testId',
         activeTopicId: undefined,
@@ -297,7 +297,7 @@ describe('displayMessageSelectors', () => {
       expect(result).toBe(messageMapKey({ agentId: 'testId', topicId: undefined }));
     });
 
-    it('should generate correct key with both activeId and activeTopicId', () => {
+    it('should generate correct key with both activeAgentId and activeTopicId', () => {
       const state: Partial<ChatStore> = {
         activeAgentId: 'testId',
         activeTopicId: 'topicId',
@@ -306,7 +306,7 @@ describe('displayMessageSelectors', () => {
       expect(result).toBe(messageMapKey({ agentId: 'testId', topicId: 'topicId' }));
     });
 
-    it('should generate key with undefined activeId', () => {
+    it('should generate key with undefined activeAgentId', () => {
       const state: Partial<ChatStore> = {
         activeAgentId: undefined,
         activeTopicId: 'topicId',
@@ -315,7 +315,7 @@ describe('displayMessageSelectors', () => {
       expect(result).toBe(messageMapKey({ agentId: undefined as any, topicId: 'topicId' }));
     });
 
-    it('should generate key with empty string activeId', () => {
+    it('should generate key with empty string activeAgentId', () => {
       const state: Partial<ChatStore> = {
         activeAgentId: '',
         activeTopicId: undefined,

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

@@ -381,18 +381,27 @@ describe('ChatPluginAction', () => {
   });
 
   describe('invokeBuiltinTool', () => {
-    it('should invoke the builtin tool action with parsed arguments', async () => {
+    it('should invoke Tool Store executor with parsed arguments', async () => {
       const payload = {
+        identifier: 'test-tool',
         apiName: 'mockBuiltinAction',
         arguments: JSON.stringify({ input: 'test', value: 123 }),
       } as ChatToolPayload;
 
       const messageId = 'message-id';
-      const mockActionFn = vi.fn().mockResolvedValue(undefined);
+      const mockInvokeBuiltinTool = vi.fn().mockResolvedValue({
+        content: 'result',
+        success: true,
+      });
 
-      useChatStore.setState({
-        mockBuiltinAction: mockActionFn,
-      } as any);
+      // Mock hasExecutor to return true
+      const hasExecutorModule = await import('@/store/tool/slices/builtin/executors');
+      vi.spyOn(hasExecutorModule, 'hasExecutor').mockReturnValue(true);
+
+      // Mock Tool Store's invokeBuiltinTool
+      vi.spyOn(useToolStore.getState(), 'invokeBuiltinTool').mockImplementation(
+        mockInvokeBuiltinTool,
+      );
 
       const { result } = renderHook(() => useChatStore());
 
@@ -400,52 +409,70 @@ describe('ChatPluginAction', () => {
         await result.current.invokeBuiltinTool(messageId, payload);
       });
 
-      // Verify that the builtin action was called with correct arguments
-      expect(mockActionFn).toHaveBeenCalledWith(messageId, { input: 'test', value: 123 });
+      // Verify that Tool Store's invokeBuiltinTool was called with correct arguments
+      expect(mockInvokeBuiltinTool).toHaveBeenCalledWith(
+        'test-tool',
+        'mockBuiltinAction',
+        { input: 'test', value: 123 },
+        expect.objectContaining({
+          messageId,
+        }),
+      );
     });
 
-    it('should not invoke action if apiName does not exist in store', async () => {
+    it('should not throw error if executor does not exist', async () => {
       const payload = {
+        identifier: 'non-existent-tool',
         apiName: 'nonExistentAction',
         arguments: JSON.stringify({ key: 'value' }),
       } as ChatToolPayload;
 
       const messageId = 'message-id';
 
+      // Mock hasExecutor to return false
+      const hasExecutorModule = await import('@/store/tool/slices/builtin/executors');
+      vi.spyOn(hasExecutorModule, 'hasExecutor').mockReturnValue(false);
+
+      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
       const { result } = renderHook(() => useChatStore());
 
       await act(async () => {
         await result.current.invokeBuiltinTool(messageId, payload);
       });
 
-      // Should not throw error, just return early
+      // Should log error but not throw
+      expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('No executor found'));
+
+      consoleErrorSpy.mockRestore();
     });
 
-    it('should not invoke action if arguments cannot be parsed', async () => {
+    it('should return error result if arguments cannot be parsed', async () => {
       const payload = {
+        identifier: 'test-tool',
         apiName: 'mockBuiltinAction',
         arguments: 'invalid json',
       } as ChatToolPayload;
 
       const messageId = 'message-id';
-      const mockActionFn = vi.fn().mockResolvedValue(undefined);
-
-      useChatStore.setState({
-        mockBuiltinAction: mockActionFn,
-      } as any);
 
       const { result } = renderHook(() => useChatStore());
 
+      let returnValue: any;
       await act(async () => {
-        await result.current.invokeBuiltinTool(messageId, payload);
+        returnValue = await result.current.invokeBuiltinTool(messageId, payload);
       });
 
-      // Should not call the action if arguments can't be parsed
-      expect(mockActionFn).not.toHaveBeenCalled();
+      // Should return error result for invalid JSON
+      expect(returnValue).toEqual({ error: 'Invalid arguments', success: false });
     });
 
     describe('registerAfterCompletion with Tool Store executor', () => {
       it('should create registerAfterCompletion when root execAgentRuntime operation exists', async () => {
+        // Mock hasExecutor to return true
+        const hasExecutorModule = await import('@/store/tool/slices/builtin/executors');
+        vi.spyOn(hasExecutorModule, 'hasExecutor').mockReturnValue(true);
+
         // Setup: Create operation hierarchy
         // execAgentRuntime -> toolCalling -> executeToolCall
         const { result } = renderHook(() => useChatStore());
@@ -527,6 +554,10 @@ describe('ChatPluginAction', () => {
       });
 
       it('should not pass registerAfterCompletion when no root operation exists', async () => {
+        // Mock hasExecutor to return true
+        const hasExecutorModule = await import('@/store/tool/slices/builtin/executors');
+        vi.spyOn(hasExecutorModule, 'hasExecutor').mockReturnValue(true);
+
         const { result } = renderHook(() => useChatStore());
         const messageId = 'tool-message-id';
 
@@ -558,6 +589,10 @@ describe('ChatPluginAction', () => {
       });
 
       it('should find root operation through multiple levels of hierarchy', async () => {
+        // Mock hasExecutor to return true
+        const hasExecutorModule = await import('@/store/tool/slices/builtin/executors');
+        vi.spyOn(hasExecutorModule, 'hasExecutor').mockReturnValue(true);
+
         const { result } = renderHook(() => useChatStore());
 
         let execAgentRuntimeOpId: string;
@@ -1147,7 +1182,7 @@ describe('ChatPluginAction', () => {
         });
       });
 
-      it('should fallback to activeId/activeTopicId when context not provided', async () => {
+      it('should fallback to activeAgentId/activeTopicId when context not provided', async () => {
         const { result } = renderHook(() => useChatStore());
         const messageId = 'message-id';
         const pluginState = { key: 'value' };