@lobehub/lobehub 2.0.0-next.343 → 2.0.0-next.345

package/src/libs/trpc/middleware/userAuth.ts

@@ -1,6 +1,6 @@
 import { TRPCError } from '@trpc/server';
 
-import { enableBetterAuth, enableClerk, enableNextAuth } from '@/envs/auth';
+import { enableBetterAuth, enableNextAuth } from '@/envs/auth';
 
 import { trpc } from '../lambda/init';
 
@@ -9,9 +9,7 @@ export const userAuth = trpc.middleware(async (opts) => {
 
   // `ctx.user` is nullable
   if (!ctx.userId) {
-    if (enableClerk) {
-      console.log('clerk auth:', ctx.clerkAuth);
-    } else if (enableBetterAuth) {
+    if (enableBetterAuth) {
       console.log('better auth: no session found in context');
     } else if (enableNextAuth) {
       console.log('next auth:', ctx.nextAuth);

package/src/libs/trusted-client/getSessionUser.ts

@@ -1,30 +1,15 @@
-import { enableBetterAuth, enableClerk, enableNextAuth } from '@/envs/auth';
+import { enableBetterAuth, enableNextAuth } from '@/envs/auth';
 
 import type { TrustedClientUserInfo } from './index';
 
 /**
  * Get user info from the current session for trusted client authentication
- * This works with different authentication providers (Clerk, BetterAuth, NextAuth)
+ * This works with different authentication providers (BetterAuth, NextAuth)
  *
  * @returns User info or undefined if not authenticated
  */
 export const getSessionUser = async (): Promise<TrustedClientUserInfo | undefined> => {
   try {
-    if (enableClerk) {
-      const { currentUser } = await import('@clerk/nextjs/server');
-      const user = await currentUser();
-
-      if (!user?.id || !user?.primaryEmailAddress?.emailAddress) {
-        return undefined;
-      }
-
-      return {
-        email: user.primaryEmailAddress.emailAddress,
-        name: user.fullName || user.firstName || undefined,
-        userId: user.id,
-      };
-    }
-
     if (enableBetterAuth) {
       const { headers } = await import('next/headers');
       const { auth } = await import('@/auth');

package/src/locales/default/error.ts

@@ -1,10 +1,6 @@
 import { businessErrorsLocales } from '@/business/locales/errors';
 
 export default {
-  'clerkAuth.loginSuccess.action': 'Continue Session',
-  'clerkAuth.loginSuccess.desc':
-    "{{greeting}}, it's great to continue serving you. Let's pick up where we left off.",
-  'clerkAuth.loginSuccess.title': 'Welcome back, {{nickName}}',
   'error.backHome': 'Back to Home',
   'error.desc': 'Give it a try later, or go back to the known world.',
   'error.retry': 'Reload',
@@ -143,8 +139,6 @@ export default {
     'Invalid access code or empty. Please enter the correct access code or add a custom API Key.',
   'response.InvalidBedrockCredentials':
     'Bedrock authentication failed. Please check the AccessKeyId/SecretAccessKey and retry.',
-  'response.InvalidClerkUser':
-    'Sorry, you are not currently logged in. Please log in or register an account to continue.',
   'response.InvalidComfyUIArgs':
     'Invalid ComfyUI configuration. Please check the settings and try again.',
   'response.InvalidGithubToken':

package/src/locales/default/index.ts

@@ -5,7 +5,6 @@ import auth from './auth';
 import authError from './authError';
 import changelog from './changelog';
 import chat from './chat';
-import clerk from './clerk';
 import color from './color';
 import common from './common';
 import components from './components';
@@ -47,7 +46,6 @@ const resources = {
   authError,
   changelog,
   chat,
-  clerk,
   color,
   common,
   components,

package/src/proxy.ts

@@ -31,7 +31,6 @@ export const config = {
     '/desktop-onboarding(.*)',
     '/onboarding',
 
-    '/login(.*)',
     '/signup(.*)',
     '/signin(.*)',
     '/verify-email(.*)',

package/src/server/routers/lambda/__tests__/user.test.ts

@@ -5,7 +5,6 @@ import { MessageModel } from '@/database/models/message';
 import { SessionModel } from '@/database/models/session';
 import { UserModel, UserNotFoundError } from '@/database/models/user';
 import { serverDB } from '@/database/server';
-import { enableClerk } from '@/envs/auth';
 import { KeyVaultsGateKeeper } from '@/server/modules/KeyVaultsEncrypt';
 import { NextAuthUserService } from '@/server/services/nextAuthUser';
 import { UserService } from '@/server/services/user';
@@ -13,10 +12,6 @@ import { UserService } from '@/server/services/user';
 import { userRouter } from '../user';
 
 // Mock modules
-vi.mock('@clerk/nextjs/server', () => ({
-  currentUser: vi.fn(),
-}));
-
 vi.mock('@/database/server', () => ({
   serverDB: {},
 }));
@@ -30,7 +25,6 @@ vi.mock('@/server/services/user');
 vi.mock('@/server/services/nextAuthUser');
 vi.mock('@/envs/auth', () => ({
   enableBetterAuth: false,
-  enableClerk: true,
   enableNextAuth: false,
 }));
 
@@ -129,71 +123,6 @@ describe('userRouter', () => {
       });
     });
 
-    it('should create new user when user not found (clerk enabled)', async () => {
-      const mockClerkUser = {
-        id: mockUserId,
-        createdAt: new Date(),
-        emailAddresses: [{ id: 'email-1', emailAddress: 'test@example.com' }],
-        firstName: 'Test',
-        lastName: 'User',
-        imageUrl: 'avatar.jpg',
-        phoneNumbers: [],
-        primaryEmailAddressId: 'email-1',
-        primaryPhoneNumberId: null,
-        username: 'testuser',
-      };
-
-      const { currentUser } = await import('@clerk/nextjs/server');
-      vi.mocked(currentUser).mockResolvedValue(mockClerkUser as any);
-
-      vi.mocked(UserService).mockImplementation(
-        () =>
-          ({
-            createUser: vi.fn().mockResolvedValue({ success: true }),
-          }) as any,
-      );
-
-      vi.mocked(UserModel).mockImplementation(
-        () =>
-          ({
-            getUserState: vi
-              .fn()
-              .mockRejectedValueOnce(new UserNotFoundError())
-              .mockResolvedValueOnce({
-                isOnboarded: false,
-                preference: { telemetry: null },
-                settings: {},
-              }),
-            updateUser: vi.fn().mockResolvedValue({ rowCount: 1 }),
-          }) as any,
-      );
-
-      vi.mocked(MessageModel).mockImplementation(
-        () =>
-          ({
-            countUpTo: vi.fn().mockResolvedValue(0),
-          }) as any,
-      );
-
-      vi.mocked(SessionModel).mockImplementation(
-        () =>
-          ({
-            hasMoreThanN: vi.fn().mockResolvedValue(false),
-          }) as any,
-      );
-
-      const result = await userRouter.createCaller({ ...mockCtx } as any).getUserState();
-
-      expect(result).toMatchObject({
-        isOnboard: false,
-        preference: { telemetry: null },
-        settings: {},
-        hasConversation: false,
-        canEnablePWAGuide: false,
-        canEnableTrace: false,
-        userId: mockUserId,
-      });
-    });
   });
 
   describe('makeUserOnboarded', () => {

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

@@ -1,4 +1,3 @@
-import { type UserJSON } from '@clerk/backend';
 import { isDesktop } from '@lobechat/const';
 import {
   NextAuthAccountSchame,
@@ -24,17 +23,13 @@ import {
 } from '@/business/server/user';
 import { MessageModel } from '@/database/models/message';
 import { SessionModel } from '@/database/models/session';
-import { UserModel, UserNotFoundError } from '@/database/models/user';
-import { enableClerk } from '@/envs/auth';
-import { ClerkAuth } from '@/libs/clerk-auth';
-import { pino } from '@/libs/logger';
+import { UserModel } from '@/database/models/user';
 import { authedProcedure, router } from '@/libs/trpc/lambda';
 import { serverDatabase } from '@/libs/trpc/lambda/middleware';
 import { KeyVaultsGateKeeper } from '@/server/modules/KeyVaultsEncrypt';
 import { FileS3 } from '@/server/modules/S3';
 import { FileService } from '@/server/services/file';
 import { NextAuthUserService } from '@/server/services/nextAuthUser';
-import { UserService } from '@/server/services/user';
 
 const usernameSchema = z
   .string()
@@ -45,7 +40,6 @@ const usernameSchema = z
 const userProcedure = authedProcedure.use(serverDatabase).use(async ({ ctx, next }) => {
   return next({
     ctx: {
-      clerkAuth: new ClerkAuth(),
       fileService: new FileService(ctx.serverDB, ctx.userId),
       messageModel: new MessageModel(ctx.serverDB, ctx.userId),
       nextAuthUserService: new NextAuthUserService(ctx.serverDB),
@@ -77,61 +71,10 @@ export const userRouter = router({
       // `after` may fail outside request scope (e.g., in tests), ignore silently
     }
 
-    // Helper function to get or create user state
-    const getOrCreateUserState = async () => {
-      let state: Awaited<ReturnType<UserModel['getUserState']>> | undefined;
-
-      // get or create first-time user
-      while (!state) {
-        try {
-          state = await ctx.userModel.getUserState(KeyVaultsGateKeeper.getUserKeyVaults);
-        } catch (error) {
-          // user not create yet
-          if (error instanceof UserNotFoundError) {
-            // if in clerk auth mode
-            if (enableClerk) {
-              const user = await ctx.clerkAuth.getCurrentUser();
-              if (user) {
-                const userService = new UserService(ctx.serverDB);
-
-                await userService.createUser(user.id, {
-                  created_at: user.createdAt,
-                  email_addresses: user.emailAddresses.map((e) => ({
-                    email_address: e.emailAddress,
-                    id: e.id,
-                  })),
-                  first_name: user.firstName,
-                  id: user.id,
-                  image_url: user.imageUrl,
-                  last_name: user.lastName,
-                  phone_numbers: user.phoneNumbers.map((e) => ({
-                    id: e.id,
-                    phone_number: e.phoneNumber,
-                  })),
-                  primary_email_address_id: user.primaryEmailAddressId,
-                  primary_phone_number_id: user.primaryPhoneNumberId,
-                  username: user.username,
-                } as UserJSON);
-
-                continue;
-              }
-            }
-
-            // if in desktop mode, make sure desktop user exist
-            else if (isDesktop) {
-              await UserModel.makeSureUserExist(ctx.serverDB, ctx.userId);
-              pino.info('create desktop user');
-              continue;
-            }
-          }
-
-          console.error('getUserState:', error);
-          throw error;
-        }
-      }
-
-      return state;
-    };
+    // For desktop mode, ensure user exists before getting state
+    if (isDesktop) {
+      await UserModel.makeSureUserExist(ctx.serverDB, ctx.userId);
+    }
 
     // Run user state fetch and count queries in parallel
     const [
@@ -143,7 +86,7 @@ export const userRouter = router({
       isInWaitList,
       isInviteCodeRequired,
     ] = await Promise.all([
-      getOrCreateUserState(),
+      ctx.userModel.getUserState(KeyVaultsGateKeeper.getUserKeyVaults),
       ctx.messageModel.countUpTo(5),
       ctx.sessionModel.hasMoreThanN(1),
       getReferralStatus(ctx.userId),

package/src/server/services/changelog/index.test.ts

@@ -19,8 +19,9 @@ vi.mock('gray-matter', () => ({
   })),
 }));
 
-vi.mock('markdown-to-txt', () => ({
-  markdownToTxt: vi.fn().mockImplementation((text) => text),
+vi.mock('@/utils/markdownToTxt', () => ({
+  default: vi.fn().mockImplementation((text: string) => text),
+  markdownToTxt: vi.fn().mockImplementation((text: string) => text),
 }));
 
 vi.mock('semver', async (importOriginal) => {

package/src/server/services/changelog/index.ts

@@ -1,13 +1,13 @@
 import dayjs from 'dayjs';
 import { template } from 'es-toolkit/compat';
 import matter from 'gray-matter';
-import { markdownToTxt } from 'markdown-to-txt';
 import semver from 'semver';
 import urlJoin from 'url-join';
 
 import { FetchCacheTag } from '@/const/cacheControl';
 import { type Locales } from '@/locales/resources';
 import { type ChangelogIndexItem } from '@/types/changelog';
+import { markdownToTxt } from '@/utils/markdownToTxt';
 
 const URL_TEMPLATE = 'https://raw.githubusercontent.com/{{user}}/{{repo}}/{{branch}}/{{path}}';
 const LAST_MODIFIED = new Date().toISOString();

package/src/server/services/user/index.ts

@@ -1,6 +1,4 @@
- 
 import { ENABLE_BUSINESS_FEATURES } from '@lobechat/business-const';
-import { type UserJSON } from '@clerk/backend';
 import { type LobeChatDatabase } from '@lobechat/database';
 
 import { initNewUserForBusiness } from '@/business/server/user';
@@ -54,87 +52,6 @@ export class UserService {
     });
   }
 
-  createUser = async (id: string, params: UserJSON) => {
-    // Check if user already exists
-    const res = await UserModel.findById(this.db, id);
-
-    // If user already exists, skip creating a new user
-    if (res)
-      return {
-        message: 'user not created due to user already existing in the database',
-        success: false,
-      };
-
-    const email = params.email_addresses.find((e) => e.id === params.primary_email_address_id);
-
-    const phone = params.phone_numbers.find((e, index) => {
-      if (!!params.primary_phone_number_id) return e.id === params.primary_phone_number_id;
-
-      return index === 0;
-    });
-
-    // 2. create user in database
-    await UserModel.createUser(this.db, {
-      avatar: params.image_url,
-      clerkCreatedAt: new Date(params.created_at),
-      email: email?.email_address,
-      firstName: params.first_name,
-      id,
-      lastName: params.last_name,
-      phone: phone?.phone_number,
-      username: params.username,
-    });
-
-    await this.initUser({
-      email: email?.email_address,
-      firstName: params.first_name,
-      id,
-      lastName: params.last_name,
-      phone: phone?.phone_number,
-      username: params.username,
-    });
-
-    return { message: 'user created', success: true };
-  };
-
-  deleteUser = async (id: string) => {
-    await UserModel.deleteUser(this.db, id);
-  };
-
-  updateUser = async (id: string, params: UserJSON) => {
-    const userModel = new UserModel(this.db, id);
-
-    // Check if user already exists
-    const res = await UserModel.findById(this.db, id);
-
-    // If user not exists, skip update the user
-    if (!res)
-      return {
-        message: "user not updated due to the user don't existing in the database",
-        success: false,
-      };
-
-    pino.info('updating user due to clerk webhook');
-
-    const email = params.email_addresses.find((e) => e.id === params.primary_email_address_id);
-    const phone = params.phone_numbers.find((e, index) => {
-      if (params.primary_phone_number_id) return e.id === params.primary_phone_number_id;
-      return index === 0;
-    });
-
-    await userModel.updateUser({
-      avatar: params.image_url,
-      email: email?.email_address,
-      firstName: params.first_name,
-      id,
-      lastName: params.last_name,
-      phone: phone?.phone_number,
-      username: params.username,
-    });
-
-    return { message: 'user updated', success: true };
-  };
-
   getUserApiKeys = async (id: string) => {
     return UserModel.getUserApiKeys(this.db, id, KeyVaultsGateKeeper.getUserKeyVaults);
   };

package/src/services/chat/index.ts

@@ -24,7 +24,6 @@ import { merge } from 'es-toolkit/compat';
 import { ModelProvider } from 'model-bank';
 
 import { DEFAULT_AGENT_CONFIG } from '@/const/settings';
-import { enableAuth } from '@/envs/auth';
 import { getSearchConfig } from '@/helpers/getSearchConfig';
 import { createAgentToolsEngine } from '@/helpers/toolEngineering';
 import { getAgentStoreState } from '@/store/agent';
@@ -542,7 +541,7 @@ class ChatService {
      * if enable login and not signed in, return unauthorized error
      */
     const userStore = useUserStore.getState();
-    if (enableAuth && !userStore.isSignedIn) {
+    if (!userStore.isSignedIn) {
       throw AgentRuntimeError.createError(ChatErrorType.InvalidAccessCode);
     }
 

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

@@ -444,6 +444,49 @@ describe('resolveAgentConfig', () => {
         expect(result.plugins).toContain(NotebookIdentifier);
         expect(result.plugins).toContain('user-plugin');
       });
+
+      it('should use basePlugins from agentConfig when ctx.plugins is not provided', () => {
+        // This test verifies the fix for the issue where INBOX agent lost user-configured plugins
+        // when resolveAgentConfig was called without the plugins parameter.
+        // The runtime function should receive basePlugins (from agentConfig) as fallback.
+        const userConfiguredPlugins = ['web-search', 'memory', 'custom-tool'];
+
+        vi.spyOn(agentSelectors.agentSelectors, 'getAgentConfigById').mockReturnValue(
+          () =>
+            ({
+              ...mockAgentConfig,
+              plugins: userConfiguredPlugins,
+            }) as any,
+        );
+
+        // Simulate INBOX runtime behavior: merges builtin tools with ctx.plugins
+        const getAgentRuntimeConfigSpy = vi
+          .spyOn(builtinAgents, 'getAgentRuntimeConfig')
+          .mockImplementation((slug, ctx) => ({
+            // This simulates the actual INBOX runtime: [GTDIdentifier, NotebookIdentifier, ...(ctx.plugins || [])]
+            plugins: [GTDIdentifier, NotebookIdentifier, ...(ctx.plugins || [])],
+            systemRole: 'Inbox system role',
+          }));
+
+        // Call WITHOUT plugins parameter - this is how internal_createAgentState calls it
+        const result = resolveAgentConfig({ agentId: 'inbox-agent' });
+
+        // Verify getAgentRuntimeConfig received basePlugins as fallback
+        expect(getAgentRuntimeConfigSpy).toHaveBeenCalledWith(
+          'inbox',
+          expect.objectContaining({
+            plugins: userConfiguredPlugins,
+          }),
+        );
+
+        // Verify final plugins include both builtin tools AND user-configured plugins
+        expect(result.plugins).toContain(GTDIdentifier);
+        expect(result.plugins).toContain(NotebookIdentifier);
+        expect(result.plugins).toContain('web-search');
+        expect(result.plugins).toContain('memory');
+        expect(result.plugins).toContain('custom-tool');
+        expect(result.plugins).toHaveLength(5); // 2 builtin + 3 user plugins
+      });
     });
   });
 

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

@@ -297,11 +297,13 @@ export const resolveAgentConfig = (ctx: AgentConfigResolverContext): ResolvedAge
   }
 
   // Builtin agent - merge runtime config
+  // Use basePlugins as fallback when ctx.plugins is not provided
+  // This ensures builtin agents (e.g., INBOX) receive user-configured plugins for merging
   const runtimeConfig = getAgentRuntimeConfig(slug, {
     documentContent,
     groupSupervisorContext,
     model,
-    plugins,
+    plugins: plugins || basePlugins,
     targetAgentConfig,
   });
 

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

@@ -446,18 +446,20 @@ describe('StreamingExecutor actions', () => {
     });
 
     describe('effectiveAgentId for group orchestration', () => {
-      it('should pass pre-resolved config for sub-agent when subAgentId is set in operation context', async () => {
+      it('should use subAgentId as agentId when groupId is present (group orchestration)', async () => {
         const { result } = renderHook(() => useChatStore());
         const messages = [createMockMessage({ role: 'user' })];
         const supervisorAgentId = 'supervisor-agent-id';
         const subAgentId = 'sub-agent-id';
+        const groupId = 'test-group-id';
 
-        // Create operation with subAgentId in context (simulating group orchestration)
+        // Create operation with groupId and subAgentId (group orchestration scenario)
         const { operationId } = result.current.startOperation({
           type: 'execAgentRuntime',
           context: {
             agentId: supervisorAgentId,
             subAgentId: subAgentId,
+            groupId: groupId, // groupId present = group orchestration
             topicId: TEST_IDS.TOPIC_ID,
             messageId: TEST_IDS.ASSISTANT_MESSAGE_ID,
           },
@@ -484,14 +486,12 @@ describe('StreamingExecutor actions', () => {
           });
         });
 
-        // With the new architecture:
-        // - agentId param is for context/tracing (supervisor ID)
-        // - resolvedAgentConfig contains the sub-agent's config (passed in by caller)
+        // In group orchestration (groupId present), subAgentId should be used as agentId
         expect(streamSpy).toHaveBeenCalledWith(
           expect.objectContaining({
             params: expect.objectContaining({
-              agentId: supervisorAgentId, // For context/tracing purposes
-              resolvedAgentConfig: subAgentConfig, // Pre-resolved sub-agent config
+              agentId: subAgentId, // subAgentId used for context injection in group orchestration
+              resolvedAgentConfig: subAgentConfig,
             }),
           }),
         );
@@ -499,6 +499,52 @@ describe('StreamingExecutor actions', () => {
         streamSpy.mockRestore();
       });
 
+      it('should use agentId when subAgentId is present but groupId is not (non-group scenario)', async () => {
+        const { result } = renderHook(() => useChatStore());
+        const messages = [createMockMessage({ role: 'user' })];
+        const agentId = 'normal-agent-id';
+        const subAgentId = 'sub-agent-id';
+
+        // Create operation with subAgentId but NO groupId (not a group orchestration scenario)
+        const { operationId } = result.current.startOperation({
+          type: 'execAgentRuntime',
+          context: {
+            agentId: agentId,
+            subAgentId: subAgentId, // subAgentId present but no groupId
+            topicId: TEST_IDS.TOPIC_ID,
+            messageId: TEST_IDS.ASSISTANT_MESSAGE_ID,
+          },
+          label: 'Test Non-Group with SubAgentId',
+        });
+
+        const streamSpy = vi
+          .spyOn(chatService, 'createAssistantMessageStream')
+          .mockImplementation(async ({ onFinish }) => {
+            await onFinish?.(TEST_CONTENT.AI_RESPONSE, {});
+          });
+
+        await act(async () => {
+          await result.current.internal_fetchAIChatMessage({
+            messages,
+            messageId: TEST_IDS.ASSISTANT_MESSAGE_ID,
+            model: 'gpt-4o-mini',
+            provider: 'openai',
+            operationId,
+            agentConfig: createMockResolvedAgentConfig(),
+          });
+        });
+
+        // Without groupId, should use agentId even if subAgentId is present
+        expect(streamSpy).toHaveBeenCalledWith(
+          expect.objectContaining({
+            // agentId used since no groupId
+            params: expect.objectContaining({ agentId }),
+          }),
+        );
+
+        streamSpy.mockRestore();
+      });
+
       it('should pass agentId to chatService when no subAgentId is set (normal chat)', async () => {
         const { result } = renderHook(() => useChatStore());
         const messages = [createMockMessage({ role: 'user' })];
@@ -545,7 +591,7 @@ describe('StreamingExecutor actions', () => {
         streamSpy.mockRestore();
       });
 
-      it('should pass resolvedAgentConfig through chatService when subAgentId is present', async () => {
+      it('should pass resolvedAgentConfig through chatService in group orchestration speak scenario', async () => {
         const { result } = renderHook(() => useChatStore());
         const messages = [createMockMessage({ role: 'user' })];
         const supervisorAgentId = 'supervisor-agent-id';
@@ -588,15 +634,13 @@ describe('StreamingExecutor actions', () => {
           });
         });
 
-        // With the new architecture, config is pre-resolved and passed via resolvedAgentConfig.
-        // The agentId param is for context/tracing only.
-        // The speaking agent's config is ensured by the caller (internal_createAgentState)
-        // resolving config with subAgentId and passing it as agentConfig param.
+        // In group orchestration (groupId present), subAgentId is used as agentId for context injection
+        // The speaking agent's config is passed via resolvedAgentConfig
         expect(streamSpy).toHaveBeenCalledWith(
           expect.objectContaining({
             params: expect.objectContaining({
-              // agentId is supervisor for context purposes
-              agentId: supervisorAgentId,
+              // subAgentId used as agentId in group orchestration
+              agentId: subAgentId,
               // resolvedAgentConfig contains the speaking agent's config
               resolvedAgentConfig: speakingAgentConfig,
             }),

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

@@ -344,13 +344,21 @@ export const streamingExecutor: StateCreator<
         log('[internal_fetchAIChatMessage] ERROR: Operation not found: %s', operationId);
         throw new Error(`Operation not found: ${operationId}`);
       }
-      agentId = operation.context.agentId!;
-      subAgentId = operation.context.subAgentId;
       topicId = operation.context.topicId;
       threadId = operation.context.threadId ?? undefined;
       groupId = operation.context.groupId;
       scope = operation.context.scope;
+      subAgentId = operation.context.subAgentId;
       abortController = operation.abortController; // 👈 Use operation's abortController
+
+      // In group orchestration scenarios (has groupId), subAgentId is the actual responding agent
+      // Use it for context injection instead of the session agentId
+      if (groupId && subAgentId) {
+        agentId = subAgentId;
+      } else {
+        agentId = operation.context.agentId!;
+      }
+
       log(
         '[internal_fetchAIChatMessage] get context from operation %s: agentId=%s, subAgentId=%s, topicId=%s, groupId=%s, aborted=%s',
         operationId,