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

package/packages/prompts/src/prompts/userMemory/__snapshots__/index.test.ts.snap

@@ -120,15 +120,9 @@ exports[`promptUserMemory > identities only > should format identities grouped b
 "<user_memory>
 <instruction>The following are memories about this user retrieved from previous conversations. Use this information to personalize your responses and maintain continuity.</instruction>
 <identities count="3">
-  <personal count="1">
-    <identity role="Father">User is a father of two children</identity>
-  </personal>
-  <professional count="1">
-    <identity role="Software Engineer">User is a senior software engineer</identity>
-  </professional>
-  <demographic count="1">
-    <identity>User is based in Shanghai</identity>
-  </demographic>
+  <identity type="personal" role="Father" id="id-1">User is a father of two children</identity>
+  <identity type="professional" role="Software Engineer" id="id-2">User is a senior software engineer</identity>
+  <identity type="demographic" id="id-3">User is based in Shanghai</identity>
 </identities>
 </user_memory>"
 `;
@@ -137,10 +131,8 @@ exports[`promptUserMemory > identities only > should format single type identiti
 "<user_memory>
 <instruction>The following are memories about this user retrieved from previous conversations. Use this information to personalize your responses and maintain continuity.</instruction>
 <identities count="2">
-  <demographic count="2">
-    <identity>User is 35 years old</identity>
-    <identity>User speaks Mandarin and English</identity>
-  </demographic>
+  <identity type="demographic" id="id-1">User is 35 years old</identity>
+  <identity type="demographic" id="id-2">User speaks Mandarin and English</identity>
 </identities>
 </user_memory>"
 `;
@@ -149,10 +141,8 @@ exports[`promptUserMemory > identities only > should format single type identiti
 "<user_memory>
 <instruction>The following are memories about this user retrieved from previous conversations. Use this information to personalize your responses and maintain continuity.</instruction>
 <identities count="2">
-  <personal count="2">
-    <identity>User is married</identity>
-    <identity>User has a pet dog</identity>
-  </personal>
+  <identity type="personal" id="id-1">User is married</identity>
+  <identity type="personal" id="id-2">User has a pet dog</identity>
 </identities>
 </user_memory>"
 `;
@@ -161,9 +151,7 @@ exports[`promptUserMemory > identities only > should format single type identiti
 "<user_memory>
 <instruction>The following are memories about this user retrieved from previous conversations. Use this information to personalize your responses and maintain continuity.</instruction>
 <identities count="1">
-  <professional count="1">
-    <identity role="CTO">User works at a tech startup</identity>
-  </professional>
+  <identity type="professional" role="CTO" id="id-1">User works at a tech startup</identity>
 </identities>
 </user_memory>"
 `;
@@ -172,9 +160,7 @@ exports[`promptUserMemory > identities only > should handle identity with null v
 "<user_memory>
 <instruction>The following are memories about this user retrieved from previous conversations. Use this information to personalize your responses and maintain continuity.</instruction>
 <identities count="1">
-  <personal count="1">
-    <identity></identity>
-  </personal>
+  <identity type="personal" id="id-1"></identity>
 </identities>
 </user_memory>"
 `;
@@ -183,9 +169,7 @@ exports[`promptUserMemory > identities only > should handle identity without rol
 "<user_memory>
 <instruction>The following are memories about this user retrieved from previous conversations. Use this information to personalize your responses and maintain continuity.</instruction>
 <identities count="1">
-  <personal count="1">
-    <identity>User enjoys hiking</identity>
-  </personal>
+  <identity type="personal" id="id-1">User enjoys hiking</identity>
 </identities>
 </user_memory>"
 `;
@@ -194,9 +178,7 @@ exports[`promptUserMemory > mixed memory types > should format all memory types
 "<user_memory>
 <instruction>The following are memories about this user retrieved from previous conversations. Use this information to personalize your responses and maintain continuity.</instruction>
 <identities count="1">
-  <professional count="1">
-    <identity role="Tech Lead">User is a tech lead at a startup</identity>
-  </professional>
+  <identity type="professional" role="Tech Lead" id="id-1">User is a tech lead at a startup</identity>
 </identities>
 <contexts count="1">
   <context id="ctx-1" title="Experience Level">Senior developer with 10 years experience</context>
@@ -217,15 +199,9 @@ exports[`promptUserMemory > mixed memory types > should format all memory types
 "<user_memory>
 <instruction>The following are memories about this user retrieved from previous conversations. Use this information to personalize your responses and maintain continuity.</instruction>
 <identities count="3">
-  <personal count="1">
-    <identity role="Father">User is a father</identity>
-  </personal>
-  <professional count="1">
-    <identity role="Senior Engineer">User is a senior engineer</identity>
-  </professional>
-  <demographic count="1">
-    <identity>User lives in Beijing</identity>
-  </demographic>
+  <identity type="personal" role="Father" id="id-1">User is a father</identity>
+  <identity type="professional" role="Senior Engineer" id="id-2">User is a senior engineer</identity>
+  <identity type="demographic" id="id-3">User lives in Beijing</identity>
 </identities>
 <contexts count="1">
   <context id="ctx-1" title="Current Work">Working on AI products</context>

package/packages/prompts/src/prompts/userMemory/index.ts

@@ -98,29 +98,10 @@ const isValidIdentityItem = (item: UserMemoryIdentityItem): boolean => {
  * Formats a single identity memory item
  */
 const formatIdentityItem = (item: UserMemoryIdentityItem): string => {
+  const typeAttr = item.type ? ` type="${item.type}"` : '';
   const roleAttr = item.role ? ` role="${item.role}"` : '';
-  return `    <identity${roleAttr}>${item.description || ''}</identity>`;
-};
-
-/**
- * Format identities grouped by type as XML
- * Types: personal (角色), professional (职业), demographic (属性)
- */
-const formatIdentitiesSection = (identities: UserMemoryIdentityItem[]): string => {
-  const personal = identities.filter((i) => i.type === 'personal');
-  const professional = identities.filter((i) => i.type === 'professional');
-  const demographic = identities.filter((i) => i.type === 'demographic');
-
-  return [
-    personal.length > 0 &&
-      `  <personal count="${personal.length}">\n${personal.map(formatIdentityItem).join('\n')}\n  </personal>`,
-    professional.length > 0 &&
-      `  <professional count="${professional.length}">\n${professional.map(formatIdentityItem).join('\n')}\n  </professional>`,
-    demographic.length > 0 &&
-      `  <demographic count="${demographic.length}">\n${demographic.map(formatIdentityItem).join('\n')}\n  </demographic>`,
-  ]
-    .filter(Boolean)
-    .join('\n');
+  const idAttr = item.id ? ` id="${item.id}"` : '';
+  return `  <identity${typeAttr}${roleAttr}${idAttr}>${item.description || ''}</identity>`;
 };
 
 /**
@@ -156,9 +137,9 @@ export const promptUserMemory = ({ memories }: PromptUserMemoryOptions): string
     '<instruction>The following are memories about this user retrieved from previous conversations. Use this information to personalize your responses and maintain continuity.</instruction>',
   );
 
-  // Add identities section (user's identity information, grouped by type)
+  // Add identities section (user's identity information)
   if (hasIdentities) {
-    const identitiesXml = formatIdentitiesSection(identities);
+    const identitiesXml = identities.map((item) => formatIdentityItem(item)).join('\n');
     contentParts.push(`<identities count="${identities.length}">
 ${identitiesXml}
 </identities>`);

package/src/app/[variants]/(main)/community/(detail)/assistant/index.tsx

@@ -40,7 +40,7 @@ const AssistantDetailPage = memo<AssistantDetailPageProps>(({ mobile }) => {
   return (
     <TocProvider>
       <DetailProvider config={data}>
-        <Flexbox gap={16}>
+        <Flexbox data-testid="assistant-detail-content" gap={16}>
           <Header mobile={mobile} />
           <Details mobile={mobile} />
         </Flexbox>

package/src/app/[variants]/(main)/community/(detail)/mcp/index.tsx

@@ -35,7 +35,7 @@ const McpDetailPage = memo<McpDetailPageProps>(({ mobile }) => {
   return (
     <TocProvider>
       <DetailProvider config={data}>
-        <Flexbox gap={16}>
+        <Flexbox data-testid="mcp-detail-content" gap={16}>
           <Header mobile={mobile} />
           <Details mobile={mobile} />
         </Flexbox>

package/src/app/[variants]/(main)/group/features/Conversation/MainChatInput/index.tsx

@@ -11,10 +11,10 @@ import { useSendMenuItems } from './useSendMenuItems';
 const leftActions: ActionKeys[] = [
   'model',
   'search',
-  'typo',
   'fileUpload',
+  'tools',
   '---',
-  ['tools', 'params', 'clear'],
+  ['typo', 'params', 'clear'],
   'mainToken',
 ];
 

package/src/app/[variants]/(main)/home/_layout/Body/Agent/List/AgentItem/index.tsx

@@ -37,8 +37,8 @@ const AgentItem = memo<AgentItemProps>(({ item, style, className }) => {
     s.agentUpdatingId === id,
   ]);
 
-  // Separate loading state from chat store - only subscribe if this session is active
-  const isLoading = useChatStore(operationSelectors.isAgentRuntimeRunning);
+  // Separate loading state from chat store - only show loading for this specific agent
+  const isLoading = useChatStore(operationSelectors.isAgentRunning(id));
 
   // Get display title with fallback
   const displayTitle = title || t('untitledAgent');

package/src/features/Conversation/Messages/Supervisor/index.tsx

@@ -55,7 +55,8 @@ const GroupMessage = memo<GroupMessageProps>(({ id, index, disableEditing, isLat
 
   // Get editing state from ConversationStore
   const creating = useConversationStore(messageStateSelectors.isMessageCreating(id));
-  const newScreen = useNewScreen({ creating, isLatestItem });
+  const generating = useConversationStore(messageStateSelectors.isMessageGenerating(id));
+  const newScreen = useNewScreen({ creating: creating || generating, isLatestItem });
 
   const setMessageItemActionElementPortialContext = useSetMessageItemActionElementPortialContext();
   const setMessageItemActionTypeContext = useSetMessageItemActionTypeContext();

package/src/features/Conversation/Messages/components/ContentLoading.tsx

@@ -18,10 +18,11 @@ interface ContentLoadingProps {
 const ContentLoading = memo<ContentLoadingProps>(({ id }) => {
   const { t } = useTranslation('chat');
   const runningOp = useChatStore(operationSelectors.getDeepestRunningOperationByMessage(id));
+  console.log('runningOp', runningOp);
   const [elapsedSeconds, setElapsedSeconds] = useState(0);
+  const [startTime, setStartTime] = useState(runningOp?.metadata?.startTime);
 
   const operationType = runningOp?.type as OperationType | undefined;
-  const startTime = runningOp?.metadata?.startTime;
 
   // Track elapsed time, reset when operation type changes
   useEffect(() => {
@@ -39,7 +40,12 @@ const ContentLoading = memo<ContentLoadingProps>(({ id }) => {
     const interval = setInterval(updateElapsed, 1000);
 
     return () => clearInterval(interval);
-  }, [startTime, operationType]);
+  }, [startTime]);
+
+  useEffect(() => {
+    setElapsedSeconds(0);
+    setStartTime(Date.now());
+  }, [operationType, id]);
 
   // Get localized label based on operation type
   const operationLabel = operationType

package/src/services/chat/mecha/agentConfigResolver.ts

@@ -5,6 +5,7 @@ import {
   type LobeAgentConfig,
   type MessageMapScope,
 } from '@lobechat/types';
+import debug from 'debug';
 import { produce } from 'immer';
 
 import { getAgentStoreState } from '@/store/agent';
@@ -12,6 +13,8 @@ import { agentSelectors, chatConfigByIdSelectors } from '@/store/agent/selectors
 import { getChatGroupStoreState } from '@/store/agentGroup';
 import { agentGroupByIdSelectors, agentGroupSelectors } from '@/store/agentGroup/selectors';
 
+const log = debug('mecha:agentConfigResolver');
+
 /**
  * Applies params adjustments based on chatConfig settings.
  *
@@ -99,6 +102,8 @@ export interface ResolvedAgentConfig {
 export const resolveAgentConfig = (ctx: AgentConfigResolverContext): ResolvedAgentConfig => {
   const { agentId, model, documentContent, plugins, targetAgentConfig } = ctx;
 
+  log('resolveAgentConfig called with agentId: %s, scope: %s', agentId, ctx.scope);
+
   const agentStoreState = getAgentStoreState();
 
   // Get base config from store
@@ -111,19 +116,46 @@ export const resolveAgentConfig = (ctx: AgentConfigResolverContext): ResolvedAge
   // Check if this is a builtin agent
   // First check agent store, then check if this is a supervisor agent in agentGroup store
   let slug = agentSelectors.getAgentSlugById(agentId)(agentStoreState);
+  log('slug from agentStore: %s (agentId: %s)', slug, agentId);
 
   // If not found in agent store, check if this is a supervisor agent in any group
   // Supervisor agents have their slug stored in agentGroup store, not agent store
   if (!slug) {
     const groupStoreState = getChatGroupStoreState();
+    const groupMap = groupStoreState.groupMap;
+    const groupMapKeys = Object.keys(groupMap);
+    log(
+      'checking groupStore for supervisor - groupMap has %d groups: %o',
+      groupMapKeys.length,
+      groupMapKeys.map((key) => ({
+        groupId: key,
+        supervisorAgentId: groupMap[key]?.supervisorAgentId,
+        title: groupMap[key]?.title,
+      })),
+    );
+
     const group = agentGroupByIdSelectors.groupBySupervisorAgentId(agentId)(groupStoreState);
+    log(
+      'groupBySupervisorAgentId result for agentId %s: %o',
+      agentId,
+      group
+        ? {
+            groupId: group.id,
+            supervisorAgentId: group.supervisorAgentId,
+            title: group.title,
+          }
+        : null,
+    );
+
     if (group) {
       // This is a supervisor agent - use the builtin slug
       slug = BUILTIN_AGENT_SLUGS.groupSupervisor;
+      log('agentId %s identified as group supervisor, assigned slug: %s', agentId, slug);
     }
   }
 
   if (!slug) {
+    log('agentId %s is not a builtin agent (no slug found)', agentId);
     // Regular agent - use provided plugins if available, fallback to agent's plugins
     const finalPlugins = plugins && plugins.length > 0 ? plugins : basePlugins;
 
@@ -183,18 +215,45 @@ export const resolveAgentConfig = (ctx: AgentConfigResolverContext): ResolvedAge
   // Build groupSupervisorContext if this is a group-supervisor agent
   let groupSupervisorContext;
   if (slug === BUILTIN_AGENT_SLUGS.groupSupervisor) {
+    log('building groupSupervisorContext for agentId: %s', agentId);
     const groupStoreState = getChatGroupStoreState();
     // Find the group by supervisor agent ID
     const group = agentGroupSelectors.getGroupBySupervisorAgentId(agentId)(groupStoreState);
 
+    log(
+      'getGroupBySupervisorAgentId result: %o',
+      group
+        ? {
+            agentsCount: group.agents?.length,
+            groupId: group.id,
+            supervisorAgentId: group.supervisorAgentId,
+            title: group.title,
+          }
+        : null,
+    );
+
     if (group) {
       const groupMembers = agentGroupSelectors.getGroupMembers(group.id)(groupStoreState);
+      log(
+        'groupMembers for groupId %s: %o',
+        group.id,
+        groupMembers.map((m) => ({ id: m.id, isSupervisor: m.isSupervisor, title: m.title })),
+      );
+
       groupSupervisorContext = {
         availableAgents: groupMembers.map((agent) => ({ id: agent.id, title: agent.title })),
         groupId: group.id,
         groupTitle: group.title || 'Group Chat',
         systemPrompt: agentConfig.systemRole,
       };
+      log('groupSupervisorContext built: %o', {
+        availableAgentsCount: groupSupervisorContext.availableAgents.length,
+        groupId: groupSupervisorContext.groupId,
+        groupTitle: groupSupervisorContext.groupTitle,
+        hasSystemPrompt: !!groupSupervisorContext.systemPrompt,
+      });
+    } else {
+      log('WARNING: group not found for supervisor agentId: %s', agentId);
     }
   }
 
@@ -258,6 +317,12 @@ export const resolveAgentConfig = (ctx: AgentConfigResolverContext): ResolvedAge
   // Apply params adjustments based on chatConfig
   const finalAgentConfig = applyParamsFromChatConfig(resolvedAgentConfig, resolvedChatConfig);
 
+  log('resolveAgentConfig completed for agentId: %s, result: %o', agentId, {
+    isBuiltinAgent: true,
+    pluginsCount: finalPlugins.length,
+    slug,
+  });
+
   return {
     agentConfig: finalAgentConfig,
     chatConfig: resolvedChatConfig,

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(