@lobehub/lobehub 2.0.0-next.305 → 2.0.0-next.307

package/src/services/chat/mecha/modelParamsResolver.test.ts

@@ -800,4 +800,215 @@ describe('resolveModelExtendParams', () => {
       expect(modelExtendParamsSpy).toHaveBeenCalledWith('test-model', 'test-provider');
     });
   });
+
+  describe('parameter precedence and conflicts', () => {
+    beforeEach(() => {
+      vi.spyOn(aiModelSelectors.aiModelSelectors, 'isModelHasExtendParams').mockReturnValue(
+        () => true,
+      );
+    });
+
+    describe('reasoning effort variants precedence', () => {
+      it('should give precedence to later reasoning effort variants when multiple are configured', () => {
+        vi.spyOn(aiModelSelectors.aiModelSelectors, 'modelExtendParams').mockReturnValue(() => [
+          'reasoningEffort',
+          'gpt5ReasoningEffort',
+          'gpt5_1ReasoningEffort',
+        ]);
+
+        const result = resolveModelExtendParams({
+          chatConfig: {
+            gpt5_1ReasoningEffort: 'high',
+            gpt5ReasoningEffort: 'medium',
+            reasoningEffort: 'low',
+          } as any,
+          model: 'gpt-5.1',
+          provider: 'openai',
+        });
+
+        // gpt5_1ReasoningEffort should win as it's processed last
+        expect(result.reasoning_effort).toBe('high');
+      });
+
+      it('should handle mixed reasoning effort variants with only some configured', () => {
+        vi.spyOn(aiModelSelectors.aiModelSelectors, 'modelExtendParams').mockReturnValue(() => [
+          'reasoningEffort',
+          'gpt5ReasoningEffort',
+          'gpt5_2ReasoningEffort',
+          'gpt5_2ProReasoningEffort',
+        ]);
+
+        const result = resolveModelExtendParams({
+          chatConfig: {
+            gpt5_2ProReasoningEffort: undefined,
+            gpt5_2ReasoningEffort: 'medium',
+            gpt5ReasoningEffort: undefined,
+            reasoningEffort: 'low',
+          } as any,
+          model: 'gpt-5.2',
+          provider: 'openai',
+        });
+
+        // gpt5_2ReasoningEffort should be set, others are undefined
+        expect(result.reasoning_effort).toBe('medium');
+      });
+
+      it('should use the last supported variant in processing order', () => {
+        vi.spyOn(aiModelSelectors.aiModelSelectors, 'modelExtendParams').mockReturnValue(() => [
+          'reasoningEffort',
+          'gpt5_2ProReasoningEffort',
+        ]);
+
+        const result = resolveModelExtendParams({
+          chatConfig: {
+            gpt5_2ProReasoningEffort: 'high',
+            reasoningEffort: 'low',
+          } as any,
+          model: 'gpt-5.2-pro',
+          provider: 'openai',
+        });
+
+        // gpt5_2ProReasoningEffort is processed after reasoningEffort
+        expect(result.reasoning_effort).toBe('high');
+      });
+    });
+
+    describe('thinking configuration conflicts', () => {
+      it('should allow thinking type param to overwrite enableReasoning thinking config', () => {
+        vi.spyOn(aiModelSelectors.aiModelSelectors, 'modelExtendParams').mockReturnValue(() => [
+          'enableReasoning',
+          'thinking',
+        ]);
+
+        const result = resolveModelExtendParams({
+          chatConfig: {
+            enableReasoning: true,
+            reasoningBudgetToken: 2048,
+            thinking: 'extended',
+          } as any,
+          model: 'model',
+          provider: 'provider',
+        });
+
+        // thinking param overwrites enableReasoning's thinking config
+        expect(result.thinking).toEqual({
+          type: 'extended',
+        });
+      });
+
+      it('should handle reasoningBudgetToken with thinking type param', () => {
+        vi.spyOn(aiModelSelectors.aiModelSelectors, 'modelExtendParams').mockReturnValue(() => [
+          'reasoningBudgetToken',
+          'thinking',
+        ]);
+
+        const result = resolveModelExtendParams({
+          chatConfig: {
+            reasoningBudgetToken: 4096,
+            thinking: 'basic',
+          } as any,
+          model: 'model',
+          provider: 'provider',
+        });
+
+        // thinking param should overwrite the entire thinking config
+        expect(result.thinking).toEqual({
+          type: 'basic',
+        });
+      });
+
+      it('should combine independent thinking params without conflict', () => {
+        vi.spyOn(aiModelSelectors.aiModelSelectors, 'modelExtendParams').mockReturnValue(() => [
+          'thinking',
+          'thinkingBudget',
+          'thinkingLevel',
+        ]);
+
+        const result = resolveModelExtendParams({
+          chatConfig: {
+            thinking: 'enabled',
+            thinkingBudget: 5000,
+            thinkingLevel: 'advanced',
+          } as any,
+          model: 'model',
+          provider: 'provider',
+        });
+
+        // These are independent params and should all be set
+        expect(result.thinking).toEqual({ type: 'enabled' });
+        expect(result.thinkingBudget).toBe(5000);
+        expect(result.thinkingLevel).toBe('advanced');
+      });
+    });
+
+    describe('complex multi-parameter scenarios', () => {
+      it('should handle all reasoning variants with context caching and verbosity', () => {
+        vi.spyOn(aiModelSelectors.aiModelSelectors, 'modelExtendParams').mockReturnValue(() => [
+          'enableReasoning',
+          'reasoningEffort',
+          'gpt5ReasoningEffort',
+          'disableContextCaching',
+          'textVerbosity',
+        ]);
+
+        const result = resolveModelExtendParams({
+          chatConfig: {
+            disableContextCaching: true,
+            enableReasoning: true,
+            gpt5ReasoningEffort: 'high',
+            reasoningBudgetToken: 3000,
+            reasoningEffort: 'medium',
+            textVerbosity: 'verbose',
+          } as any,
+          model: 'gpt-5',
+          provider: 'openai',
+        });
+
+        expect(result).toEqual({
+          enabledContextCaching: false,
+          reasoning_effort: 'high',
+          thinking: {
+            budget_tokens: 3000,
+            type: 'enabled',
+          },
+          verbosity: 'verbose',
+        });
+      });
+
+      it('should handle all params when none are configured', () => {
+        vi.spyOn(aiModelSelectors.aiModelSelectors, 'modelExtendParams').mockReturnValue(() => [
+          'enableReasoning',
+          'reasoningEffort',
+          'textVerbosity',
+          'thinking',
+          'thinkingBudget',
+          'thinkingLevel',
+          'urlContext',
+          'imageAspectRatio',
+          'imageResolution',
+          'disableContextCaching',
+        ]);
+
+        const result = resolveModelExtendParams({
+          chatConfig: {} as any,
+          model: 'model',
+          provider: 'provider',
+        });
+
+        // Only enableReasoning should set thinking to disabled, others should be undefined
+        expect(result.thinking).toEqual({
+          budget_tokens: 0,
+          type: 'disabled',
+        });
+        expect(result.reasoning_effort).toBeUndefined();
+        expect(result.verbosity).toBeUndefined();
+        expect(result.thinkingBudget).toBeUndefined();
+        expect(result.thinkingLevel).toBeUndefined();
+        expect(result.urlContext).toBeUndefined();
+        expect(result.imageAspectRatio).toBeUndefined();
+        expect(result.imageResolution).toBeUndefined();
+        expect(result.enabledContextCaching).toBeUndefined();
+      });
+    });
+  });
 });

package/src/services/chatGroup/index.ts

@@ -20,6 +20,18 @@ export interface GroupMemberConfig {
   title?: string;
 }
 
+export interface SupervisorConfig {
+  avatar?: string;
+  backgroundColor?: string;
+  description?: string;
+  model?: string;
+  params?: any;
+  provider?: string;
+  systemRole?: string;
+  tags?: string[];
+  title?: string;
+}
+
 class ChatGroupService {
   /**
    * Create a group with a supervisor agent.
@@ -42,6 +54,7 @@ class ChatGroupService {
   createGroupWithMembers = (
     groupConfig: Omit<NewChatGroup, 'userId'>,
     members: GroupMemberConfig[],
+    supervisorConfig?: SupervisorConfig,
   ): Promise<{ agentIds: string[]; groupId: string; supervisorAgentId: string }> => {
     return lambdaClient.group.createGroupWithMembers.mutate({
       groupConfig: {
@@ -49,6 +62,7 @@ class ChatGroupService {
         config: groupConfig.config as any,
       },
       members: members as Partial<AgentItem>[],
+      supervisorConfig,
     });
   };
 

package/src/store/agentGroup/action.ts

@@ -48,6 +48,12 @@ export interface ChatGroupInternalAction {
           type: string;
         },
   ) => void;
+  /**
+   * Fetch group detail directly and update store.
+   * Unlike refreshGroupDetail which uses SWR mutate, this method fetches immediately
+   * and is useful when SWR hook is not yet mounted (e.g., after createGroup).
+   */
+  internal_fetchGroupDetail: (groupId: string) => Promise<void>;
   internal_updateGroupMaps: (groups: ChatGroupItem[]) => void;
   loadGroups: () => Promise<void>;
   refreshGroupDetail: (groupId: string) => Promise<void>;
@@ -91,6 +97,30 @@ const chatGroupInternalSlice: StateCreator<
   return {
     internal_dispatchChatGroup: dispatch,
 
+    internal_fetchGroupDetail: async (groupId: string) => {
+      const groupDetail = await chatGroupService.getGroupDetail(groupId);
+      if (!groupDetail) return;
+
+      // Update groupMap with full group detail including supervisorAgentId and agents
+      dispatch({ payload: { id: groupDetail.id, value: groupDetail }, type: 'updateGroup' });
+
+      // Sync group agents to agentStore for builtin agent resolution
+      const agentStore = getAgentStoreState();
+      for (const agent of groupDetail.agents) {
+        agentStore.internal_dispatchAgentMap(agent.id, agent as any);
+      }
+
+      // Set activeAgentId to supervisor for correct model resolution
+      if (groupDetail.supervisorAgentId) {
+        agentStore.setActiveAgentId(groupDetail.supervisorAgentId);
+        useChatStore.setState(
+          { activeAgentId: groupDetail.supervisorAgentId },
+          false,
+          'syncActiveAgentIdFromAgentGroup',
+        );
+      }
+    },
+
     internal_updateGroupMaps: (groups) => {
       // Build a candidate map from incoming groups
       const incomingMap = groups.reduce(

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

@@ -10,19 +10,31 @@ vi.mock('@/services/chatGroup', () => ({
   chatGroupService: {
     addAgentsToGroup: vi.fn(),
     createGroup: vi.fn(),
+    getGroupDetail: vi.fn(),
     getGroups: vi.fn(),
   },
 }));
 
-vi.mock('@/store/session', () => ({
-  getSessionStoreState: vi.fn(() => ({
-    activeId: 'some-session-id',
-    refreshSessions: vi.fn().mockResolvedValue(undefined),
-    sessions: [],
-    switchSession: vi.fn(),
+vi.mock('@/store/home', () => ({
+  getHomeStoreState: vi.fn(() => ({
+    refreshAgentList: vi.fn(),
+    switchToGroup: vi.fn(),
   })),
 }));
 
+vi.mock('@/store/agent', () => ({
+  getAgentStoreState: vi.fn(() => ({
+    internal_dispatchAgentMap: vi.fn(),
+    setActiveAgentId: vi.fn(),
+  })),
+}));
+
+vi.mock('@/store/chat', () => ({
+  useChatStore: {
+    setState: vi.fn(),
+  },
+}));
+
 describe('ChatGroupLifecycleSlice', () => {
   beforeEach(() => {
     vi.clearAllMocks();
@@ -47,12 +59,17 @@ describe('ChatGroupLifecycleSlice', () => {
         title: 'Test Group',
         userId: 'user-1',
       };
+      const mockGroupDetail = {
+        ...mockGroup,
+        agents: [],
+        supervisorAgentId: 'supervisor-1',
+      };
 
       vi.mocked(chatGroupService.createGroup).mockResolvedValue({
         group: mockGroup as any,
         supervisorAgentId: 'supervisor-1',
       });
-      vi.mocked(chatGroupService.getGroups).mockResolvedValue([mockGroup as any]);
+      vi.mocked(chatGroupService.getGroupDetail).mockResolvedValue(mockGroupDetail as any);
 
       const { result } = renderHook(() => useAgentGroupStore());
 
@@ -71,13 +88,18 @@ describe('ChatGroupLifecycleSlice', () => {
         title: 'Test Group',
         userId: 'user-1',
       };
+      const mockGroupDetail = {
+        ...mockGroup,
+        agents: [],
+        supervisorAgentId: 'supervisor-1',
+      };
 
       vi.mocked(chatGroupService.createGroup).mockResolvedValue({
         group: mockGroup as any,
         supervisorAgentId: 'supervisor-1',
       });
       vi.mocked(chatGroupService.addAgentsToGroup).mockResolvedValue({ added: [], existing: [] });
-      vi.mocked(chatGroupService.getGroups).mockResolvedValue([mockGroup as any]);
+      vi.mocked(chatGroupService.getGroupDetail).mockResolvedValue(mockGroupDetail as any);
 
       const { result } = renderHook(() => useAgentGroupStore());
 
@@ -91,14 +113,46 @@ describe('ChatGroupLifecycleSlice', () => {
       ]);
     });
 
-    it('should not switch session when silent is true', async () => {
-      const mockSwitchSession = vi.fn();
-      const { getSessionStoreState } = await import('@/store/session');
-      vi.mocked(getSessionStoreState).mockReturnValue({
-        activeId: 'some-session-id',
-        refreshSessions: vi.fn().mockResolvedValue(undefined),
-        sessions: [],
-        switchSession: mockSwitchSession,
+    it('should fetch group detail and store supervisorAgentId for tools injection', async () => {
+      const mockGroup = {
+        id: 'new-group-id',
+        title: 'Test Group',
+        userId: 'user-1',
+      };
+      const mockSupervisorAgentId = 'supervisor-agent-123';
+      const mockGroupDetail = {
+        ...mockGroup,
+        agents: [],
+        supervisorAgentId: mockSupervisorAgentId,
+      };
+
+      vi.mocked(chatGroupService.createGroup).mockResolvedValue({
+        group: mockGroup as any,
+        supervisorAgentId: mockSupervisorAgentId,
+      });
+      vi.mocked(chatGroupService.getGroupDetail).mockResolvedValue(mockGroupDetail as any);
+
+      const { result } = renderHook(() => useAgentGroupStore());
+
+      await act(async () => {
+        await result.current.createGroup({ title: 'Test Group' });
+      });
+
+      // Verify getGroupDetail was called to fetch full group info
+      expect(chatGroupService.getGroupDetail).toHaveBeenCalledWith('new-group-id');
+
+      // Verify supervisorAgentId is stored in groupMap for tools injection
+      const groupDetail = result.current.groupMap['new-group-id'];
+      expect(groupDetail).toBeDefined();
+      expect(groupDetail.supervisorAgentId).toBe(mockSupervisorAgentId);
+    });
+
+    it('should not switch to group when silent is true', async () => {
+      const mockSwitchToGroup = vi.fn();
+      const { getHomeStoreState } = await import('@/store/home');
+      vi.mocked(getHomeStoreState).mockReturnValue({
+        refreshAgentList: vi.fn(),
+        switchToGroup: mockSwitchToGroup,
       } as any);
 
       const mockGroup = {
@@ -106,12 +160,17 @@ describe('ChatGroupLifecycleSlice', () => {
         title: 'Test Group',
         userId: 'user-1',
       };
+      const mockGroupDetail = {
+        ...mockGroup,
+        agents: [],
+        supervisorAgentId: 'supervisor-1',
+      };
 
       vi.mocked(chatGroupService.createGroup).mockResolvedValue({
         group: mockGroup as any,
         supervisorAgentId: 'supervisor-1',
       });
-      vi.mocked(chatGroupService.getGroups).mockResolvedValue([mockGroup as any]);
+      vi.mocked(chatGroupService.getGroupDetail).mockResolvedValue(mockGroupDetail as any);
 
       const { result } = renderHook(() => useAgentGroupStore());
 
@@ -119,7 +178,7 @@ describe('ChatGroupLifecycleSlice', () => {
         await result.current.createGroup({ title: 'Test Group' }, [], true);
       });
 
-      expect(mockSwitchSession).not.toHaveBeenCalled();
+      expect(mockSwitchToGroup).not.toHaveBeenCalled();
     });
   });
 });

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

@@ -5,7 +5,7 @@ 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';
+import { getHomeStoreState } from '@/store/home';
 
 export interface ChatGroupLifecycleAction {
   createGroup: (
@@ -14,7 +14,6 @@ export interface ChatGroupLifecycleAction {
     silent?: boolean,
   ) => Promise<string>;
   /**
-   * @deprecated Use switchTopic(undefined) instead
    * Switch to a new topic in the group
    * Clears activeTopicId and navigates to group root
    */
@@ -32,11 +31,8 @@ export const chatGroupLifecycleSlice: StateCreator<
   [],
   ChatGroupLifecycleAction
 > = (_, get) => ({
-  /**
-   * @param silent - if true, do not switch to the new group session
-   */
   createGroup: async (newGroup, agentIds, silent = false) => {
-    const { switchSession } = getSessionStoreState();
+    const { switchToGroup, refreshAgentList } = getHomeStoreState();
 
     const { group } = await chatGroupService.createGroup(newGroup);
 
@@ -52,11 +48,13 @@ export const chatGroupLifecycleSlice: StateCreator<
 
     get().internal_dispatchChatGroup({ payload: group, type: 'addGroup' });
 
-    await get().loadGroups();
-    await getSessionStoreState().refreshSessions();
+    // Fetch full group detail to get supervisorAgentId and agents for tools injection
+    await get().internal_fetchGroupDetail(group.id);
+
+    refreshAgentList();
 
     if (!silent) {
-      switchSession(group.id);
+      switchToGroup(group.id);
     }
 
     return group.id;

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

@@ -160,14 +160,16 @@ export const streamingExecutor: StateCreator<
     // - agentId is used for session ID (message storage location)
     const effectiveAgentId = paramSubAgentId || agentId;
 
-    // Get scope from operation context if available
+    // Get scope and groupId from operation context if available
     const operation = operationId ? get().operations[operationId] : undefined;
     const scope = operation?.context.scope;
+    const groupId = operation?.context.groupId;
 
     // Resolve agent config with builtin agent runtime config merged
     // This ensures runtime plugins (e.g., 'lobe-agent-builder' for Agent Builder) are included
     const { agentConfig: agentConfigData, plugins: pluginIds } = resolveAgentConfig({
       agentId: effectiveAgentId || '',
+      groupId, // Pass groupId for supervisor detection
       scope, // Pass scope from operation context
     });
 
@@ -341,6 +343,7 @@ export const streamingExecutor: StateCreator<
     // - max_tokens/reasoning_effort based on chatConfig settings
     const resolved = resolveAgentConfig({
       agentId: effectiveAgentId,
+      groupId, // Pass groupId for supervisor detection
       scope, // scope is already available from line 329
     });
     const finalAgentConfig = agentConfig || resolved.agentConfig;
@@ -594,7 +597,8 @@ export const streamingExecutor: StateCreator<
     // - max_tokens/reasoning_effort based on chatConfig settings
     const { agentConfig: agentConfigData } = resolveAgentConfig({
       agentId: effectiveAgentId || '',
-      scope: context.scope, // Pass scope from context parameter (available at line 883)
+      groupId, // Pass groupId for supervisor detection
+      scope: context.scope, // Pass scope from context parameter
     });
 
     // Use agent config from agentId

package/src/store/chat/slices/operation/__tests__/selectors.test.ts

@@ -509,6 +509,130 @@ describe('Operation Selectors', () => {
     });
   });
 
+  describe('isAgentRunning', () => {
+    it('should return false when no operations exist', () => {
+      const { result } = renderHook(() => useChatStore());
+
+      expect(operationSelectors.isAgentRunning('agent1')(result.current)).toBe(false);
+    });
+
+    it('should return true only for the agent with running operations', () => {
+      const { result } = renderHook(() => useChatStore());
+
+      act(() => {
+        result.current.startOperation({
+          type: 'execAgentRuntime',
+          context: { agentId: 'agent1' },
+        });
+      });
+
+      expect(operationSelectors.isAgentRunning('agent1')(result.current)).toBe(true);
+      expect(operationSelectors.isAgentRunning('agent2')(result.current)).toBe(false);
+    });
+
+    it('should return false when operation completes', () => {
+      const { result } = renderHook(() => useChatStore());
+
+      let opId: string;
+
+      act(() => {
+        opId = result.current.startOperation({
+          type: 'execAgentRuntime',
+          context: { agentId: 'agent1' },
+        }).operationId;
+      });
+
+      expect(operationSelectors.isAgentRunning('agent1')(result.current)).toBe(true);
+
+      act(() => {
+        result.current.completeOperation(opId!);
+      });
+
+      expect(operationSelectors.isAgentRunning('agent1')(result.current)).toBe(false);
+    });
+
+    it('should exclude aborting operations', () => {
+      const { result } = renderHook(() => useChatStore());
+
+      let opId: string;
+
+      act(() => {
+        opId = result.current.startOperation({
+          type: 'execAgentRuntime',
+          context: { agentId: 'agent1' },
+        }).operationId;
+      });
+
+      expect(operationSelectors.isAgentRunning('agent1')(result.current)).toBe(true);
+
+      act(() => {
+        result.current.updateOperationMetadata(opId!, { isAborting: true });
+      });
+
+      expect(operationSelectors.isAgentRunning('agent1')(result.current)).toBe(false);
+    });
+
+    it('should detect any topic with running operations for the agent', () => {
+      const { result } = renderHook(() => useChatStore());
+
+      act(() => {
+        // Agent 1, topic 1
+        result.current.startOperation({
+          type: 'execAgentRuntime',
+          context: { agentId: 'agent1', topicId: 'topic1' },
+        });
+
+        // Agent 1, topic 2
+        result.current.startOperation({
+          type: 'execAgentRuntime',
+          context: { agentId: 'agent1', topicId: 'topic2' },
+        });
+
+        // Agent 2, topic 3
+        result.current.startOperation({
+          type: 'execAgentRuntime',
+          context: { agentId: 'agent2', topicId: 'topic3' },
+        });
+      });
+
+      // Agent 1 should be running (has 2 topics with operations)
+      expect(operationSelectors.isAgentRunning('agent1')(result.current)).toBe(true);
+      // Agent 2 should also be running
+      expect(operationSelectors.isAgentRunning('agent2')(result.current)).toBe(true);
+      // Agent 3 should not be running
+      expect(operationSelectors.isAgentRunning('agent3')(result.current)).toBe(false);
+    });
+
+    it('should detect server agent runtime operations', () => {
+      const { result } = renderHook(() => useChatStore());
+
+      act(() => {
+        result.current.startOperation({
+          type: 'execServerAgentRuntime',
+          context: { agentId: 'agent1', groupId: 'group1' },
+        });
+      });
+
+      expect(operationSelectors.isAgentRunning('agent1')(result.current)).toBe(true);
+      expect(operationSelectors.isAgentRunning('agent2')(result.current)).toBe(false);
+    });
+
+    it('should not detect non-AI-runtime operations', () => {
+      const { result } = renderHook(() => useChatStore());
+
+      act(() => {
+        // sendMessage is not an AI runtime operation type
+        result.current.startOperation({
+          type: 'sendMessage',
+          context: { agentId: 'agent1' },
+        });
+      });
+
+      // sendMessage is not in AI_RUNTIME_OPERATION_TYPES, so should return false
+      expect(operationSelectors.isAgentRunning('agent1')(result.current)).toBe(false);
+    });
+  });
+
   describe('backward compatibility selectors', () => {
     it('isAgentRuntimeRunning should work', () => {
       const { result } = renderHook(() => useChatStore());