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

package/e2e/src/steps/community/interactions.steps.ts

@@ -446,8 +446,8 @@ Then('I should be navigated to the assistant detail page', async function (this:
 Then('I should see the assistant detail content', async function (this: CustomWorld) {
   await this.page.waitForLoadState('networkidle', { timeout: 30_000 });
 
-  // Look for detail page elements (e.g., title, description, etc.)
-  const detailContent = this.page.locator('[data-testid="detail-content"], main, article').first();
+  // Look for assistant detail page content
+  const detailContent = this.page.locator('[data-testid="assistant-detail-content"]');
   await expect(detailContent).toBeVisible({ timeout: 30_000 });
 });
 
@@ -561,8 +561,8 @@ Then('I should be navigated to the MCP detail page', async function (this: Custo
 Then('I should see the MCP detail content', async function (this: CustomWorld) {
   await this.page.waitForLoadState('networkidle', { timeout: 30_000 });
 
-  // Look for detail page elements
-  const detailContent = this.page.locator('[data-testid="detail-content"], main, article').first();
+  // Look for MCP detail page content
+  const detailContent = this.page.locator('[data-testid="mcp-detail-content"]');
   await expect(detailContent).toBeVisible({ timeout: 30_000 });
 });
 

package/locales/en-US/auth.json

@@ -28,6 +28,11 @@
   "apikey.list.columns.status": "Enabled Status",
   "apikey.list.title": "API Key List",
   "apikey.validation.required": "This field cannot be empty",
+  "authModal.description": "Your login session has expired. Please sign in again to continue using cloud sync features.",
+  "authModal.later": "Later",
+  "authModal.signIn": "Sign In Again",
+  "authModal.signingIn": "Signing in...",
+  "authModal.title": "Session Expired",
   "betterAuth.errors.confirmPasswordRequired": "Please confirm your password",
   "betterAuth.errors.emailExists": "This email is already registered. Please sign in instead",
   "betterAuth.errors.emailInvalid": "Please enter a valid email address or username",

package/locales/zh-CN/auth.json

@@ -28,6 +28,11 @@
   "apikey.list.columns.status": "启用状态",
   "apikey.list.title": "API Key 列表",
   "apikey.validation.required": "内容不得为空",
+  "authModal.description": "您的登录会话已过期，请重新登录以继续使用云同步功能。",
+  "authModal.later": "稍后",
+  "authModal.signIn": "重新登录",
+  "authModal.signingIn": "登录中...",
+  "authModal.title": "登录已过期",
   "betterAuth.errors.confirmPasswordRequired": "请确认密码",
   "betterAuth.errors.emailExists": "该邮箱已注册，请直接登录",
   "betterAuth.errors.emailInvalid": "请输入有效的邮箱地址或用户名",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/lobehub",
-  "version": "2.0.0-next.304",
+  "version": "2.0.0-next.306",
   "description": "LobeHub - an open-source,comprehensive AI Agent framework that supports speech synthesis, multimodal, and extensible Function Call plugin system. Supports one-click free deployment of your private ChatGPT/LLM web application.",
   "keywords": [
     "framework",
@@ -35,18 +35,19 @@
     "prebuild": "tsx scripts/prebuild.mts && npm run lint",
     "build": "cross-env NODE_OPTIONS=--max-old-space-size=8192 next build --webpack",
     "postbuild": "npm run build-sitemap && npm run build-migrate-db",
-    "build-migrate-db": "bun run db:migrate",
-    "build-sitemap": "tsx ./scripts/buildSitemapIndex/index.ts",
     "build:analyze": "NODE_OPTIONS=--max-old-space-size=81920 ANALYZE=true next build --webpack",
     "build:docker": "npm run prebuild && NODE_OPTIONS=--max-old-space-size=8192 DOCKER=true next build --webpack && npm run build-sitemap",
     "build:electron": "cross-env NODE_OPTIONS=--max-old-space-size=8192 NEXT_PUBLIC_IS_DESKTOP_APP=1 tsx scripts/electronWorkflow/buildNextApp.mts",
     "build:vercel": "npm run prebuild && cross-env NODE_OPTIONS=--max-old-space-size=6144 next build --webpack && npm run postbuild",
+    "build-migrate-db": "bun run db:migrate",
+    "build-sitemap": "tsx ./scripts/buildSitemapIndex/index.ts",
     "clean:node_modules": "bash -lc 'set -e; echo \"Removing all node_modules...\"; rm -rf node_modules; pnpm -r exec rm -rf node_modules; rm -rf apps/desktop/node_modules; echo \"All node_modules removed.\"'",
     "db:generate": "drizzle-kit generate && npm run workflow:dbml",
     "db:migrate": "MIGRATION_DB=1 tsx ./scripts/migrateServerDB/index.ts",
     "db:studio": "drizzle-kit studio",
     "db:visualize": "dbdocs build docs/development/database-schema.dbml --project lobe-chat",
     "desktop:build": "npm run desktop:build-next && npm run desktop:prepare-dist && npm run desktop:build-electron",
+    "desktop:build-channel": "tsx scripts/electronWorkflow/buildDesktopChannel.ts",
     "desktop:build-electron": "tsx scripts/electronWorkflow/buildElectron.ts",
     "desktop:build-local": "npm run desktop:build-next && npm run desktop:prepare-dist && npm run build-local --prefix=./apps/desktop",
     "desktop:build-next": "npm run build:electron",
@@ -86,11 +87,11 @@
     "start": "next start -p 3210",
     "stylelint": "stylelint \"src/**/*.{js,jsx,ts,tsx}\" --fix",
     "test": "npm run test-app && npm run test-server",
-    "test-app": "vitest run",
-    "test-app:coverage": "vitest --coverage --silent='passed-only'",
     "test:e2e": "pnpm --filter @lobechat/e2e-tests test",
     "test:e2e:smoke": "pnpm --filter @lobechat/e2e-tests test:smoke",
     "test:update": "vitest -u",
+    "test-app": "vitest run",
+    "test-app:coverage": "vitest --coverage --silent='passed-only'",
     "tunnel:cloudflare": "cloudflared tunnel --url http://localhost:3010",
     "tunnel:ngrok": "ngrok http http://localhost:3011",
     "type-check": "tsgo --noEmit",

package/packages/builtin-tool-agent-builder/src/ExecutionRuntime/index.ts

@@ -344,7 +344,139 @@ export class AgentBuilderExecutionRuntime {
   }
 
   /**
-   * Open OAuth window and wait for authentication completion
+   * Open OAuth window and wait for LobehubSkill authentication completion
+   * Returns a Promise that resolves when OAuth completes or fails
+   */
+  private openLobehubSkillOAuthWindowAndWait(
+    oauthUrl: string,
+    provider: string,
+  ): Promise<{ cancelled: boolean; success: boolean }> {
+    return new Promise((resolve) => {
+      // Configuration
+      const WINDOW_CHECK_INTERVAL_MS = 500;
+      const POLL_INTERVAL_MS = 1000;
+      const POLL_TIMEOUT_MS = 300_000; // 5 minutes timeout
+
+      let pollInterval: ReturnType<typeof setInterval> | null = null;
+      let pollTimeout: ReturnType<typeof setTimeout> | null = null;
+      let windowCheckInterval: ReturnType<typeof setInterval> | null = null;
+      let messageHandler: ((event: MessageEvent) => void) | null = null;
+      let resolved = false;
+
+      const cleanup = () => {
+        if (windowCheckInterval) {
+          clearInterval(windowCheckInterval);
+          windowCheckInterval = null;
+        }
+        if (pollInterval) {
+          clearInterval(pollInterval);
+          pollInterval = null;
+        }
+        if (pollTimeout) {
+          clearTimeout(pollTimeout);
+          pollTimeout = null;
+        }
+        if (messageHandler) {
+          window.removeEventListener('message', messageHandler);
+          messageHandler = null;
+        }
+      };
+
+      const resolveOnce = (result: { cancelled: boolean; success: boolean }) => {
+        if (resolved) return;
+        resolved = true;
+        cleanup();
+        resolve(result);
+      };
+
+      // Listen for OAuth success message from popup window
+      messageHandler = async (event: MessageEvent) => {
+        // Verify origin for security
+        if (event.origin !== window.location.origin) return;
+
+        if (
+          event.data?.type === 'LOBEHUB_SKILL_AUTH_SUCCESS' &&
+          event.data?.provider === provider
+        ) {
+          console.log('[LobehubSkill] OAuth success message received for provider:', provider);
+
+          // Refresh status to get the connected state
+          const server = await getToolStoreState().checkLobehubSkillStatus(provider);
+          const isConnected = server?.status === LobehubSkillStatus.CONNECTED;
+
+          resolveOnce({ cancelled: false, success: isConnected });
+        }
+      };
+
+      window.addEventListener('message', messageHandler);
+
+      // eslint-disable-next-line unicorn/consistent-function-scoping
+      const checkAuthStatus = async (): Promise<boolean> => {
+        try {
+          // Check LobehubSkill status
+          const server = await getToolStoreState().checkLobehubSkillStatus(provider);
+          return server?.status === LobehubSkillStatus.CONNECTED;
+        } catch (error) {
+          console.error('[LobehubSkill] Failed to check auth status:', error);
+          return false;
+        }
+      };
+
+      const startFallbackPolling = () => {
+        if (pollInterval) return;
+
+        pollInterval = setInterval(async () => {
+          const isConnected = await checkAuthStatus();
+          if (isConnected) {
+            resolveOnce({ cancelled: false, success: true });
+          }
+        }, POLL_INTERVAL_MS);
+
+        // Timeout after 5 minutes
+        pollTimeout = setTimeout(() => {
+          resolveOnce({ cancelled: true, success: false });
+        }, POLL_TIMEOUT_MS);
+      };
+
+      // Open OAuth window
+      const oauthWindow = window.open(oauthUrl, '_blank', 'width=600,height=700');
+
+      if (oauthWindow) {
+        // Monitor window close
+        windowCheckInterval = setInterval(async () => {
+          try {
+            if (oauthWindow.closed) {
+              if (windowCheckInterval) {
+                clearInterval(windowCheckInterval);
+                windowCheckInterval = null;
+              }
+
+              // Window closed, check auth status
+              const isConnected = await checkAuthStatus();
+              resolveOnce({ cancelled: !isConnected, success: isConnected });
+            }
+          } catch {
+            // COOP blocked window.closed access, fall back to polling
+            console.log(
+              '[LobehubSkill] COOP blocked window.closed access, falling back to polling',
+            );
+            if (windowCheckInterval) {
+              clearInterval(windowCheckInterval);
+              windowCheckInterval = null;
+            }
+            startFallbackPolling();
+          }
+        }, WINDOW_CHECK_INTERVAL_MS);
+      } else {
+        // Window was blocked, use polling
+        console.log('[LobehubSkill] OAuth window was blocked, falling back to polling');
+        startFallbackPolling();
+      }
+    });
+  }
+
+  /**
+   * Open OAuth window and wait for Klavis authentication completion
    * Returns a Promise that resolves when OAuth completes or fails
    */
   private openOAuthWindowAndWait(
@@ -777,34 +909,187 @@ export class AgentBuilderExecutionRuntime {
                   success: true,
                 };
               } else {
-                // Server exists but not connected - need to reconnect
+                // Server exists but not connected - need to reconnect via OAuth
+                try {
+                  // Get OAuth authorization URL with correct redirectUri
+                  const redirectUri =
+                    typeof window !== 'undefined'
+                      ? `${window.location.origin}/oauth/callback/success?provider=${encodeURIComponent(identifier)}`
+                      : undefined;
+                  const authInfo = await getToolStoreState().getLobehubSkillAuthorizeUrl(
+                    identifier,
+                    {
+                      redirectUri,
+                    },
+                  );
+
+                  if (!authInfo.authorizeUrl) {
+                    return {
+                      content: `LobehubSkill provider "${lobehubSkillProviderInfo.label}" requires OAuth authorization but no authorization URL is available.`,
+                      state: {
+                        installed: false,
+                        isLobehubSkill: true,
+                        pluginId: identifier,
+                        pluginName: lobehubSkillProviderInfo.label,
+                        serverStatus: lobehubSkillServer.status,
+                        success: false,
+                      } as InstallPluginState,
+                      success: false,
+                    };
+                  }
+
+                  // Open OAuth window and wait for authorization
+                  const authResult = await this.openLobehubSkillOAuthWindowAndWait(
+                    authInfo.authorizeUrl,
+                    identifier,
+                  );
+
+                  if (authResult.success) {
+                    // OAuth successful, enable the plugin
+                    const agentState = getAgentStoreState();
+                    const currentPlugins =
+                      agentSelectors.getAgentConfigById(agentId)(agentState).plugins || [];
+
+                    if (!currentPlugins.includes(identifier)) {
+                      await getAgentStoreState().optimisticUpdateAgentConfig(agentId, {
+                        plugins: [...currentPlugins, identifier],
+                      });
+                    }
+
+                    return {
+                      content: `Successfully reconnected and enabled LobehubSkill provider: ${lobehubSkillProviderInfo.label}`,
+                      state: {
+                        installed: true,
+                        isLobehubSkill: true,
+                        pluginId: identifier,
+                        pluginName: lobehubSkillProviderInfo.label,
+                        serverStatus: 'connected',
+                        success: true,
+                      } as InstallPluginState,
+                      success: true,
+                    };
+                  } else {
+                    // OAuth cancelled or failed
+                    return {
+                      content: `OAuth authorization was cancelled or failed for LobehubSkill provider: ${lobehubSkillProviderInfo.label}. Please try again.`,
+                      state: {
+                        installed: false,
+                        isLobehubSkill: true,
+                        pluginId: identifier,
+                        pluginName: lobehubSkillProviderInfo.label,
+                        serverStatus: lobehubSkillServer.status,
+                        success: false,
+                      } as InstallPluginState,
+                      success: false,
+                    };
+                  }
+                } catch (authError) {
+                  const err = authError as Error;
+                  return {
+                    content: `Failed to reconnect LobehubSkill provider "${lobehubSkillProviderInfo.label}": ${err.message}`,
+                    error: authError,
+                    state: {
+                      error: err.message,
+                      installed: false,
+                      isLobehubSkill: true,
+                      pluginId: identifier,
+                      pluginName: lobehubSkillProviderInfo.label,
+                      serverStatus: lobehubSkillServer.status,
+                      success: false,
+                    } as InstallPluginState,
+                    success: false,
+                  };
+                }
+              }
+            } else {
+              // Server doesn't exist - need to initiate OAuth authorization
+              try {
+                // Get OAuth authorization URL with correct redirectUri
+                const redirectUri =
+                  typeof window !== 'undefined'
+                    ? `${window.location.origin}/oauth/callback/success?provider=${encodeURIComponent(identifier)}`
+                    : undefined;
+                const authInfo = await getToolStoreState().getLobehubSkillAuthorizeUrl(identifier, {
+                  redirectUri,
+                });
+
+                if (!authInfo.authorizeUrl) {
+                  return {
+                    content: `LobehubSkill provider "${lobehubSkillProviderInfo.label}" requires OAuth authorization but no authorization URL is available.`,
+                    state: {
+                      installed: false,
+                      isLobehubSkill: true,
+                      pluginId: identifier,
+                      pluginName: lobehubSkillProviderInfo.label,
+                      serverStatus: 'not_connected',
+                      success: false,
+                    } as InstallPluginState,
+                    success: false,
+                  };
+                }
+
+                // Open OAuth window and wait for authorization
+                const authResult = await this.openLobehubSkillOAuthWindowAndWait(
+                  authInfo.authorizeUrl,
+                  identifier,
+                );
+
+                if (authResult.success) {
+                  // OAuth successful, enable the plugin
+                  const agentState = getAgentStoreState();
+                  const currentPlugins =
+                    agentSelectors.getAgentConfigById(agentId)(agentState).plugins || [];
+
+                  if (!currentPlugins.includes(identifier)) {
+                    await getAgentStoreState().optimisticUpdateAgentConfig(agentId, {
+                      plugins: [...currentPlugins, identifier],
+                    });
+                  }
+
+                  return {
+                    content: `Successfully connected and enabled LobehubSkill provider: ${lobehubSkillProviderInfo.label}`,
+                    state: {
+                      installed: true,
+                      isLobehubSkill: true,
+                      pluginId: identifier,
+                      pluginName: lobehubSkillProviderInfo.label,
+                      serverStatus: 'connected',
+                      success: true,
+                    } as InstallPluginState,
+                    success: true,
+                  };
+                } else {
+                  // OAuth cancelled or failed
+                  return {
+                    content: `OAuth authorization was cancelled or failed for LobehubSkill provider: ${lobehubSkillProviderInfo.label}. Please try again.`,
+                    state: {
+                      installed: false,
+                      isLobehubSkill: true,
+                      pluginId: identifier,
+                      pluginName: lobehubSkillProviderInfo.label,
+                      serverStatus: 'not_connected',
+                      success: false,
+                    } as InstallPluginState,
+                    success: false,
+                  };
+                }
+              } catch (authError) {
+                const err = authError as Error;
                 return {
-                  content: `LobehubSkill provider "${lobehubSkillProviderInfo.label}" is not connected. Please reconnect it from the tools settings.`,
+                  content: `Failed to authorize LobehubSkill provider "${lobehubSkillProviderInfo.label}": ${err.message}`,
+                  error: authError,
                   state: {
+                    error: err.message,
                     installed: false,
                     isLobehubSkill: true,
                     pluginId: identifier,
                     pluginName: lobehubSkillProviderInfo.label,
-                    serverStatus: lobehubSkillServer.status,
+                    serverStatus: 'not_connected',
                     success: false,
                   } as InstallPluginState,
                   success: false,
                 };
               }
-            } else {
-              // Server doesn't exist - need to connect first
-              return {
-                content: `LobehubSkill provider "${lobehubSkillProviderInfo.label}" is not connected. Please connect it from the tools settings first.`,
-                state: {
-                  installed: false,
-                  isLobehubSkill: true,
-                  pluginId: identifier,
-                  pluginName: lobehubSkillProviderInfo.label,
-                  serverStatus: 'not_connected',
-                  success: false,
-                } as InstallPluginState,
-                success: false,
-              };
             }
           }
         }
@@ -878,18 +1163,65 @@ export class AgentBuilderExecutionRuntime {
         };
       }
 
-      // Plugin needs to be installed - return state requiring approval
-      // The actual installation will happen when user approves
-      return {
-        content: `MCP plugin "${identifier}" will be installed. Please approve to continue.`,
-        state: {
-          awaitingApproval: true,
-          installed: false,
-          pluginId: identifier,
-          success: true,
-        } as InstallPluginState,
-        success: true,
-      };
+      // Plugin needs to be installed - trigger actual installation from market
+      try {
+        // Call the store's installMCPPlugin to trigger the real installation flow
+        const installSuccess = await getToolStoreState().installMCPPlugin(identifier);
+
+        if (installSuccess) {
+          // Installation successful, enable it for the agent
+          const agentState = getAgentStoreState();
+          const currentPlugins =
+            agentSelectors.getAgentConfigById(agentId)(agentState).plugins || [];
+
+          if (!currentPlugins.includes(identifier)) {
+            await getAgentStoreState().optimisticUpdateAgentConfig(agentId, {
+              plugins: [...currentPlugins, identifier],
+            });
+          }
+
+          // Refresh tool state to get the installed plugin info
+          await getToolStoreState().refreshPlugins();
+          const freshToolState = getToolStoreState();
+          const installedPlugin =
+            pluginSelectors.getInstalledPluginById(identifier)(freshToolState);
+
+          return {
+            content: `Successfully installed and enabled MCP plugin "${installedPlugin?.manifest?.meta?.title || identifier}".`,
+            state: {
+              installed: true,
+              pluginId: identifier,
+              pluginName: installedPlugin?.manifest?.meta?.title || identifier,
+              success: true,
+            } as InstallPluginState,
+            success: true,
+          };
+        } else {
+          // Installation failed or was cancelled
+          return {
+            content: `Failed to install MCP plugin "${identifier}". Installation was cancelled or configuration is needed.`,
+            state: {
+              installed: false,
+              pluginId: identifier,
+              success: false,
+            } as InstallPluginState,
+            success: false,
+          };
+        }
+      } catch (installError) {
+        const err = installError as Error;
+        return {
+          content: `Failed to install MCP plugin "${identifier}": ${err.message}`,
+          error: installError,
+          state: {
+            error: err.message,
+            installed: false,
+            pluginId: identifier,
+            success: false,
+          } as InstallPluginState,
+          success: false,
+        };
+      }
     } catch (error) {
       const err = error as Error;
       return {

package/packages/builtin-tool-agent-builder/src/client/Intervention/InstallPlugin.tsx

@@ -12,6 +12,7 @@ import { useToolStore } from '@/store/tool';
 import {
   klavisStoreSelectors,
   lobehubSkillStoreSelectors,
+  mcpStoreSelectors,
   pluginSelectors,
 } from '@/store/tool/selectors';
 import { KlavisServerStatus } from '@/store/tool/slices/klavisStore/types';
@@ -44,6 +45,14 @@ const InstallPluginIntervention = memo<BuiltinInterventionProps<InstallPluginPar
       lobehubSkillStoreSelectors.getServers(s).find((srv) => srv.identifier === identifier),
     );
 
+    // Get Market MCP plugin info
+    const marketPlugin = useToolStore((s) => mcpStoreSelectors.getPluginById(identifier)(s));
+
+    // Get Builtin tool info
+    const builtinTool = useToolStore((s) =>
+      s.builtinTools.find((tool) => tool.identifier === identifier),
+    );
+
     // Check if it's a Klavis tool
     const klavisTypeInfo = KLAVIS_SERVER_TYPES.find((t) => t.identifier === identifier);
     const isKlavis = source === 'official' && !!klavisTypeInfo;
@@ -166,19 +175,34 @@ const InstallPluginIntervention = memo<BuiltinInterventionProps<InstallPluginPar
       );
     }
 
-    // Render MCP marketplace plugin
+    // Render MCP marketplace plugin or Builtin tool
     // Note: The actual installation happens in ExecutionRuntime after user approves
+    const pluginName = marketPlugin?.name || builtinTool?.manifest?.meta?.title || identifier;
+    const pluginIcon = marketPlugin?.icon || builtinTool?.manifest?.meta?.avatar;
+    const pluginType = source === 'market' ? 'MCP Plugin' : 'Builtin Tool';
+
     return (
       <Flexbox
         gap={12}
         style={{ background: 'var(--lobe-fill-tertiary)', borderRadius: 8, padding: 16 }}
       >
         <Flexbox align="center" gap={12} horizontal>
-          <Avatar avatar="🔧" size={40} style={{ borderRadius: 8 }} />
+          {pluginIcon && typeof pluginIcon === 'string' && pluginIcon.startsWith('http') ? (
+            <Image
+              alt={pluginName}
+              height={40}
+              src={pluginIcon}
+              style={{ borderRadius: 8 }}
+              unoptimized
+              width={40}
+            />
+          ) : (
+            <Avatar avatar={pluginIcon || '🔧'} size={40} style={{ borderRadius: 8 }} />
+          )}
           <Flexbox flex={1} gap={4}>
             <Flexbox align="center" gap={8} horizontal>
-              <span style={{ fontWeight: 600 }}>{identifier}</span>
-              <span style={{ color: 'var(--lobe-text-tertiary)', fontSize: 12 }}>MCP Plugin</span>
+              <span style={{ fontWeight: 600 }}>{pluginName}</span>
+              <span style={{ color: 'var(--lobe-text-tertiary)', fontSize: 12 }}>{pluginType}</span>
             </Flexbox>
             <span style={{ color: 'var(--lobe-text-secondary)', fontSize: 12 }}>
               {t('agentBuilder.installPlugin.clickApproveToInstall')}

package/packages/context-engine/src/processors/GroupMessageFlatten.ts

@@ -7,9 +7,9 @@ const log = debug('context-engine:processor:GroupMessageFlattenProcessor');
 
 /**
  * Group Message Flatten Processor
- * Responsible for flattening role=assistantGroup messages into standard assistant + tool message sequences
+ * Responsible for flattening role=assistantGroup and role=supervisor messages into standard assistant + tool message sequences
  *
- * AssistantGroup messages are created when assistant messages with tools are merged with their tool results.
+ * AssistantGroup/Supervisor messages are created when assistant messages with tools are merged with their tool results.
  * This processor converts them back to a flat structure that AI models can understand.
  */
 export class GroupMessageFlattenProcessor extends BaseProcessor {
@@ -31,8 +31,11 @@ export class GroupMessageFlattenProcessor extends BaseProcessor {
 
     // Process each message
     for (const message of clonedContext.messages) {
-      // Check if this is an assistantGroup message with children field
-      if (message.role === 'assistantGroup' && message.children) {
+      // Check if this is an assistantGroup or supervisor message with children field
+      if (
+        (message.role === 'assistantGroup' || message.role === 'supervisor') &&
+        message.children
+      ) {
         // If children array is empty, skip this message entirely (no content to flatten)
         if (message.children.length === 0) {
           continue;
@@ -42,7 +45,7 @@ export class GroupMessageFlattenProcessor extends BaseProcessor {
         groupMessagesFlattened++;
 
         log(
-          `Flattening assistantGroup message ${message.id} with ${message.children.length} children`,
+          `Flattening ${message.role} message ${message.id} with ${message.children.length} children`,
         );
 
         // Flatten each child
@@ -148,7 +151,7 @@ export class GroupMessageFlattenProcessor extends BaseProcessor {
     clonedContext.metadata.toolMessagesCreated = toolMessagesCreated;
 
     log(
-      `AssistantGroup message flatten processing completed: ${groupMessagesFlattened} groups flattened, ${assistantMessagesCreated} assistant messages created, ${toolMessagesCreated} tool messages created`,
+      `AssistantGroup/Supervisor message flatten processing completed: ${groupMessagesFlattened} groups flattened, ${assistantMessagesCreated} assistant messages created, ${toolMessagesCreated} tool messages created`,
     );
 
     return this.markAsExecuted(clonedContext);