@lobehub/lobehub 2.0.0-next.304 → 2.0.0-next.306

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/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/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());

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

@@ -234,6 +234,27 @@ const isAgentRuntimeRunningByContext =
   };
 
 // === Backward Compatibility ===
+
+/**
+ * Check if a specific agent has running AI runtime operations
+ * Used for agent list item loading states where we need per-agent granularity
+ */
+const isAgentRunning =
+  (agentId: string) =>
+  (s: ChatStoreState): boolean => {
+    for (const type of AI_RUNTIME_OPERATION_TYPES) {
+      const operationIds = s.operationsByType[type] || [];
+      const hasRunning = operationIds.some((id) => {
+        const op = s.operations[id];
+        return (
+          op && op.status === 'running' && !op.metadata.isAborting && op.context.agentId === agentId
+        );
+      });
+      if (hasRunning) return true;
+    }
+    return false;
+  };
+
 /**
  * Check if agent runtime is running (including both main window and thread)
  * Checks both client-side (execAgentRuntime) and server-side (execServerAgentRuntime) operations
@@ -477,6 +498,7 @@ export const operationSelectors = {
 
   isAborting,
 
+  isAgentRunning,
   isAgentRuntimeRunning,
   isAgentRuntimeRunningByContext,
   isAnyMessageLoading,

package/src/utils/errorResponse.ts

@@ -1,6 +1,16 @@
 import { AgentRuntimeErrorType, type ILobeAgentRuntimeErrorType } from '@lobechat/model-runtime';
 import { ChatErrorType, type ErrorResponse, type ErrorType } from '@lobechat/types';
 
+/**
+ * Error types that indicate a real authentication failure.
+ * When these errors occur, the response will include X-Auth-Required header
+ * to signal the client that re-authentication is needed.
+ */
+const AUTH_REQUIRED_ERROR_TYPES = new Set<ErrorType>([
+  ChatErrorType.Unauthorized,
+  ChatErrorType.InvalidClerkUser,
+]);
+
 const getStatus = (errorType: ILobeAgentRuntimeErrorType | ErrorType) => {
   // InvalidAccessCode / InvalidAzureAPIKey / InvalidOpenAIAPIKey / InvalidZhipuAPIKey ....
   if (errorType.toString().includes('Invalid')) return 401;
@@ -71,5 +81,15 @@ export const createErrorResponse = (
     );
   }
 
-  return new Response(JSON.stringify(data), { status: statusCode });
+  const headers: Record<string, string> = {
+    'Content-Type': 'application/json',
+  };
+
+  // Add X-Auth-Required header for real authentication failures
+  // This allows the client to distinguish between auth failures and other 401 errors (e.g., invalid API keys)
+  if (AUTH_REQUIRED_ERROR_TYPES.has(errorType as ErrorType)) {
+    headers['X-Auth-Required'] = 'true';
+  }
+
+  return new Response(JSON.stringify(data), { headers, status: statusCode });
 };