@lobehub/lobehub 2.0.0-next.295 → 2.0.0-next.297

package/src/server/routers/lambda/market/index.ts

@@ -17,6 +17,7 @@ import {
 } from '@/types/discover';
 
 import { agentRouter } from './agent';
+import { agentGroupRouter } from './agentGroup';
 import { oidcRouter } from './oidc';
 import { socialRouter } from './social';
 import { userRouter } from './user';
@@ -44,6 +45,9 @@ export const marketRouter = router({
   // ============================== Agent Management (authenticated) ==============================
   agent: agentRouter,
 
+  // ============================== Agent Group Management (authenticated) ==============================
+  agentGroup: agentGroupRouter,
+
   // ============================== Assistant Market ==============================
   getAssistantCategories: marketProcedure
     .input(
@@ -120,6 +124,7 @@ export const marketRouter = router({
         .object({
           category: z.string().optional(),
           connectionType: z.nativeEnum(McpConnectionType).optional(),
+          includeAgentGroup: z.boolean().optional(),
           locale: z.string().optional(),
           order: z.enum(['asc', 'desc']).optional(),
           ownerId: z.string().optional(),
@@ -145,6 +150,95 @@ export const marketRouter = router({
       }
     }),
 
+  // ============================== Group Agent Market (Discovery) ==============================
+  getGroupAgentCategories: marketProcedure
+    .input(
+      z
+        .object({
+          locale: z.string().optional(),
+          q: z.string().optional(),
+        })
+        .optional(),
+    )
+    .query(async ({ input, ctx }) => {
+      log('getGroupAgentCategories input: %O', input);
+
+      try {
+        return await ctx.discoverService.getGroupAgentCategories(input);
+      } catch (error) {
+        log('Error fetching group agent categories: %O', error);
+        throw new TRPCError({
+          code: 'INTERNAL_SERVER_ERROR',
+          message: 'Failed to fetch group agent categories',
+        });
+      }
+    }),
+
+  getGroupAgentDetail: marketProcedure
+    .input(
+      z.object({
+        identifier: z.string(),
+        locale: z.string().optional(),
+        version: z.string().optional(),
+      }),
+    )
+    .query(async ({ input, ctx }) => {
+      log('getGroupAgentDetail input: %O', input);
+
+      try {
+        return await ctx.discoverService.getGroupAgentDetail(input);
+      } catch (error) {
+        log('Error fetching group agent detail: %O', error);
+        throw new TRPCError({
+          code: 'INTERNAL_SERVER_ERROR',
+          message: 'Failed to fetch group agent detail',
+        });
+      }
+    }),
+
+  getGroupAgentIdentifiers: marketProcedure.query(async ({ ctx }) => {
+    log('getGroupAgentIdentifiers called');
+
+    try {
+      return await ctx.discoverService.getGroupAgentIdentifiers();
+    } catch (error) {
+      log('Error fetching group agent identifiers: %O', error);
+      throw new TRPCError({
+        code: 'INTERNAL_SERVER_ERROR',
+        message: 'Failed to fetch group agent identifiers',
+      });
+    }
+  }),
+
+  getGroupAgentList: marketProcedure
+    .input(
+      z
+        .object({
+          category: z.string().optional(),
+          locale: z.string().optional(),
+          order: z.enum(['asc', 'desc']).optional(),
+          ownerId: z.string().optional(),
+          page: z.number().optional(),
+          pageSize: z.number().optional(),
+          q: z.string().optional(),
+          sort: z.enum(['createdAt', 'updatedAt', 'name', 'recommended']).optional(),
+        })
+        .optional(),
+    )
+    .query(async ({ input, ctx }) => {
+      log('getGroupAgentList input: %O', input);
+
+      try {
+        return await ctx.discoverService.getGroupAgentList(input);
+      } catch (error) {
+        log('Error fetching group agent list: %O', error);
+        throw new TRPCError({
+          code: 'INTERNAL_SERVER_ERROR',
+          message: 'Failed to fetch group agent list',
+        });
+      }
+    }),
+
   getLegacyPluginList: marketProcedure
     .input(
       z
@@ -167,7 +261,7 @@ export const marketRouter = router({
     }),
 
   // ============================== MCP Market ==============================
-getMcpCategories: marketProcedure
+  getMcpCategories: marketProcedure
     .input(
       z
         .object({
@@ -351,7 +445,7 @@ getMcpCategories: marketProcedure
     }),
 
   // ============================== Plugin Market ==============================
-getPluginCategories: marketProcedure
+  getPluginCategories: marketProcedure
     .input(
       z
         .object({
@@ -439,7 +533,7 @@ getPluginCategories: marketProcedure
     }),
 
   // ============================== Providers ==============================
-getProviderDetail: marketProcedure
+  getProviderDetail: marketProcedure
     .input(
       z.object({
         identifier: z.string(),
@@ -503,7 +597,7 @@ getProviderDetail: marketProcedure
     }),
 
   // ============================== User Profile ==============================
-getUserInfo: marketProcedure
+  getUserInfo: marketProcedure
     .input(
       z.object({
         locale: z.string().optional(),
@@ -675,6 +769,42 @@ getUserInfo: marketProcedure
       }
     }),
 
+  reportGroupAgentEvent: marketProcedure
+    .input(
+      z.object({
+        event: z.enum(['add', 'chat', 'click']),
+        identifier: z.string(),
+        source: z.string().optional(),
+      }),
+    )
+    .mutation(async ({ input, ctx }) => {
+      log('reportGroupAgentEvent input: %O', input);
+
+      try {
+        await ctx.discoverService.createGroupAgentEvent(input);
+        return { success: true };
+      } catch (error) {
+        console.error('Error reporting Group Agent event: %O', error);
+        return { success: false };
+      }
+    }),
+
+  reportGroupAgentInstall: marketProcedure
+    .input(
+      z.object({
+        identifier: z.string(),
+      }),
+    )
+    .mutation(async ({ input, ctx }) => {
+      log('reportGroupAgentInstall input: %O', input);
+      try {
+        await ctx.discoverService.increaseGroupAgentInstallCount(input.identifier);
+        return { success: true };
+      } catch (error) {
+        log('Error reporting group agent installation: %O', error);
+        return { success: false };
+      }
+    }),
 
   reportMcpEvent: marketProcedure
     .input(

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

@@ -33,7 +33,7 @@ import {
   type ModelQueryParams,
   ModelSorts,
   type PluginListResponse,
-  type PluginQueryParams as PluginQueryParams,
+  type PluginQueryParams,
   PluginSorts,
   type ProviderListResponse,
   type ProviderQueryParams,
@@ -718,6 +718,7 @@ export class DiscoverService {
       q,
       sort = AssistantSorts.CreatedAt,
       ownerId,
+      includeAgentGroup,
     } = rest;
 
     try {
@@ -740,9 +741,10 @@ export class DiscoverService {
         }
       }
 
-      // @ts-ignore
       const data = await this.market.agents.getAgentList({
         category,
+        // includeAgentGroup may not be in SDK type definition yet, using 'as any'
+        includeAgentGroup,
         locale: normalizedLocale,
         order,
         ownerId,
@@ -752,7 +754,7 @@ export class DiscoverService {
         sort: apiSort,
         status: 'published',
         visibility: 'public',
-      });
+      } as any);
 
       const transformedItems: DiscoverAssistantItem[] = (data.items || []).map((item: any) => {
         const normalizedAuthor = this.normalizeAuthorField(item.author);
@@ -773,6 +775,7 @@ export class DiscoverService {
           tags: item.tags || [],
           title: item.name || item.identifier,
           tokenUsage: item.tokenUsage || 0,
+          type: item.type,
           userName: normalizedAuthor.userName,
         };
       });
@@ -922,7 +925,6 @@ export class DiscoverService {
     await this.market.plugins.createEvent(params);
   };
 
-
   /**
    * report plugin call result to marketplace
    */
@@ -1735,14 +1737,18 @@ export class DiscoverService {
 
     try {
       // Call Market SDK to get user info
-      const response: UserInfoResponse = await this.market.user.getUserInfo(username, { locale });
+      const response = (await this.market.user.getUserInfo(username, {
+        locale,
+      })) as UserInfoResponse & {
+        agentGroups?: any[];
+      };
 
       if (!response?.user) {
         log('getUserInfo: user not found for username=%s', username);
         return undefined;
       }
 
-      const { user, agents } = response;
+      const { user, agents, agentGroups } = response;
 
       // Transform agents to DiscoverAssistantItem format
       const transformedAgents: DiscoverAssistantItem[] = (agents || []).map((agent: any) => ({
@@ -1763,7 +1769,27 @@ export class DiscoverService {
         tokenUsage: agent.tokenUsage || 0,
       }));
 
+      // Transform agentGroups to DiscoverGroupAgentItem format
+      const transformedAgentGroups = (agentGroups || []).map((group: any) => ({
+        author: user.displayName || user.userName || user.namespace || '',
+        avatar: group.avatar || '👥',
+        category: group.category as any,
+        createdAt: group.createdAt,
+        description: group.description || '',
+        homepage: `https://lobehub.com/discover/group_agent/${group.identifier}`,
+        identifier: group.identifier,
+        installCount: group.installCount || 0,
+        isFeatured: group.isFeatured || false,
+        isOfficial: group.isOfficial || false,
+        memberCount: 0, // Will be populated from memberAgents in detail view
+        schemaVersion: 1,
+        tags: group.tags || [],
+        title: group.name || group.identifier,
+        updatedAt: group.updatedAt,
+      }));
+
       const result: DiscoverUserProfile = {
+        agentGroups: transformedAgentGroups,
         agents: transformedAgents,
         user: {
           avatarUrl: user.avatarUrl || null,
@@ -1781,11 +1807,101 @@ export class DiscoverService {
         },
       };
 
-      log('getUserInfo: returning user profile with %d agents', result.agents.length);
+      log(
+        'getUserInfo: returning user profile with %d agents and %d groups',
+        result.agents.length,
+        result.agentGroups?.length || 0,
+      );
       return result;
     } catch (error) {
       log('getUserInfo: error fetching user info: %O', error);
       return undefined;
     }
   };
+
+  // ============================== Group Agent Market Methods ==============================
+
+  getGroupAgentCategories = async (params?: CategoryListQuery) => {
+    try {
+      // TODO: SDK method not yet available, using fallback
+      const response = await (this.market.agentGroups as any).getAgentGroupCategories?.(params);
+      return response || { items: [] };
+    } catch (error) {
+      log('getGroupAgentCategories: error: %O', error);
+      return { items: [] };
+    }
+  };
+
+  getGroupAgentDetail = async (params: {
+    identifier: string;
+    locale?: string;
+    version?: string;
+  }) => {
+    try {
+      const response = await this.market.agentGroups.getAgentGroupDetail(params.identifier, {
+        locale: params.locale,
+        version: params.version ? Number(params.version) : undefined,
+      });
+      return response;
+    } catch (error) {
+      log('getGroupAgentDetail: error: %O', error);
+      throw error;
+    }
+  };
+
+  getGroupAgentIdentifiers = async () => {
+    try {
+      // TODO: SDK method not yet available, using fallback
+      const response = await (this.market.agentGroups as any).getAgentGroupIdentifiers?.();
+      return response || { identifiers: [] };
+    } catch (error) {
+      log('getGroupAgentIdentifiers: error: %O', error);
+      return { identifiers: [] };
+    }
+  };
+
+  getGroupAgentList = async (params?: {
+    category?: string;
+    locale?: string;
+    order?: 'asc' | 'desc';
+    ownerId?: string;
+    page?: number;
+    pageSize?: number;
+    q?: string;
+    sort?: 'createdAt' | 'updatedAt' | 'name' | 'recommended';
+  }) => {
+    try {
+      const response = await this.market.agentGroups.getAgentGroupList({
+        ...params,
+        status: 'published' as any,
+        visibility: 'public' as any,
+      });
+      return response;
+    } catch (error) {
+      log('getGroupAgentList: error: %O', error);
+      return { currentPage: 1, items: [], totalCount: 0, totalPages: 1 };
+    }
+  };
+
+  createGroupAgentEvent = async (params: {
+    event: 'add' | 'chat' | 'click';
+    identifier: string;
+    source?: string;
+  }) => {
+    try {
+      // TODO: SDK method not yet available
+      await (this.market.agentGroups as any).createAgentGroupEvent?.(params);
+    } catch (error) {
+      log('createGroupAgentEvent: error: %O', error);
+    }
+  };
+
+  increaseGroupAgentInstallCount = async (identifier: string) => {
+    try {
+      // TODO: SDK method not yet available
+      await (this.market.agentGroups as any).increaseInstallCount?.(identifier);
+    } catch (error) {
+      log('increaseGroupAgentInstallCount: error: %O', error);
+    }
+  };
 }

package/src/services/discover.ts

@@ -20,6 +20,7 @@ import {
   type DiscoverPluginDetail,
   type DiscoverProviderDetail,
   type DiscoverUserProfile,
+  type GroupAgentQueryParams,
   type IdentifiersResponse,
   type McpListResponse,
   type McpQueryParams,
@@ -448,6 +449,60 @@ class DiscoverService {
     }
     return null;
   }
+
+  // ============================== Group Agent Market ==============================
+
+  getGroupAgentCategories = async (params: CategoryListQuery = {}): Promise<CategoryItem[]> => {
+    const locale = globalHelpers.getCurrentLanguage();
+    return lambdaClient.market.getGroupAgentCategories.query({
+      ...params,
+      locale,
+    });
+  };
+
+  getGroupAgentDetail = async (params: {
+    identifier: string;
+    locale?: string;
+    version?: string;
+  }): Promise<any> => {
+    const locale = globalHelpers.getCurrentLanguage();
+    return lambdaClient.market.getGroupAgentDetail.query({
+      identifier: params.identifier,
+      locale,
+      version: params.version,
+    });
+  };
+
+  getGroupAgentIdentifiers = async (): Promise<IdentifiersResponse> => {
+    return lambdaClient.market.getGroupAgentIdentifiers.query();
+  };
+
+  getGroupAgentList = async (
+    params: GroupAgentQueryParams = {},
+  ): Promise<any> => {
+    const locale = globalHelpers.getCurrentLanguage();
+    return lambdaClient.market.getGroupAgentList.query(
+      {
+        ...params,
+        locale,
+        page: params.page ? Number(params.page) : 1,
+        pageSize: params.pageSize ? Number(params.pageSize) : 20,
+      },
+      { context: { showNotification: false } },
+    );
+  };
+
+  reportGroupAgentEvent = async (params: {
+    event: 'add' | 'chat' | 'click';
+    identifier: string;
+    source?: string;
+  }): Promise<void> => {
+    await lambdaClient.market.reportGroupAgentEvent.mutate(params);
+  };
+
+  reportGroupAgentInstall = async (identifier: string): Promise<void> => {
+    await lambdaClient.market.reportGroupAgentInstall.mutate({ identifier });
+  };
 }
 
 export const discoverService = new DiscoverService();

package/src/store/chat/slices/message/selectors/dbMessage.test.ts

@@ -5,7 +5,7 @@ import { selectTodosFromMessages } from './dbMessage';
 
 describe('selectTodosFromMessages', () => {
   const createGTDToolMessage = (todos: {
-    items: Array<{ text: string; completed: boolean }>;
+    items: Array<{ text: string; status: 'todo' | 'processing' | 'completed' }>;
     updatedAt: string;
   }): UIChatMessage =>
     ({
@@ -30,7 +30,7 @@ describe('selectTodosFromMessages', () => {
         content: 'Create a todo list',
       } as UIChatMessage,
       createGTDToolMessage({
-        items: [{ text: 'Buy milk', completed: false }],
+        items: [{ text: 'Buy milk', status: 'todo' }],
         updatedAt: '2024-06-01T00:00:00.000Z',
       }),
     ];
@@ -40,13 +40,13 @@ describe('selectTodosFromMessages', () => {
     expect(result).toBeDefined();
     expect(result?.items).toHaveLength(1);
     expect(result?.items[0].text).toBe('Buy milk');
-    expect(result?.items[0].completed).toBe(false);
+    expect(result?.items[0].status).toBe('todo');
   });
 
   it('should return the most recent todos when multiple GTD messages exist', () => {
     const messages: UIChatMessage[] = [
       createGTDToolMessage({
-        items: [{ text: 'Old task', completed: false }],
+        items: [{ text: 'Old task', status: 'todo' }],
         updatedAt: '2024-01-01T00:00:00.000Z',
       }),
       {
@@ -56,8 +56,8 @@ describe('selectTodosFromMessages', () => {
       } as UIChatMessage,
       createGTDToolMessage({
         items: [
-          { text: 'Old task', completed: true },
-          { text: 'New task', completed: false },
+          { text: 'Old task', status: 'completed' },
+          { text: 'New task', status: 'todo' },
         ],
         updatedAt: '2024-06-01T00:00:00.000Z',
       }),
@@ -69,7 +69,7 @@ describe('selectTodosFromMessages', () => {
     expect(result?.items).toHaveLength(2);
     // Should be from the latest message
     expect(result?.items[0].text).toBe('Old task');
-    expect(result?.items[0].completed).toBe(true);
+    expect(result?.items[0].status).toBe('completed');
     expect(result?.items[1].text).toBe('New task');
   });
 
@@ -155,7 +155,7 @@ describe('selectTodosFromMessages', () => {
         },
         pluginState: {
           todos: {
-            items: [{ text: 'Task', completed: false }],
+            items: [{ text: 'Task', status: 'todo' }],
             // No updatedAt
           },
         },
@@ -184,8 +184,8 @@ describe('selectTodosFromMessages', () => {
         pluginState: {
           // Legacy format: direct array
           todos: [
-            { text: 'Task 1', completed: false },
-            { text: 'Task 2', completed: true },
+            { text: 'Task 1', status: 'todo' },
+            { text: 'Task 2', status: 'completed' },
           ],
         },
       } as unknown as UIChatMessage,
@@ -196,6 +196,6 @@ describe('selectTodosFromMessages', () => {
     expect(result).toBeDefined();
     expect(result?.items).toHaveLength(2);
     expect(result?.items[0].text).toBe('Task 1');
-    expect(result?.items[1].completed).toBe(true);
+    expect(result?.items[1].status).toBe('completed');
   });
 });

package/src/store/discover/slices/groupAgent/action.ts

@@ -0,0 +1,80 @@
+import { type CategoryItem, type CategoryListQuery } from '@lobehub/market-sdk';
+import useSWR, { type SWRResponse } from 'swr';
+import type { StateCreator } from 'zustand/vanilla';
+
+import { discoverService } from '@/services/discover';
+import { type DiscoverStore } from '@/store/discover';
+import { globalHelpers } from '@/store/global/helpers';
+import {
+  type DiscoverGroupAgentDetail,
+  type GroupAgentListResponse,
+  type GroupAgentQueryParams,
+  type IdentifiersResponse,
+} from '@/types/discover';
+
+export interface GroupAgentAction {
+  useGroupAgentCategories: (params?: CategoryListQuery) => SWRResponse<CategoryItem[]>;
+  useGroupAgentDetail: (params: {
+    identifier: string;
+    version?: string;
+  }) => SWRResponse<DiscoverGroupAgentDetail | undefined>;
+  useGroupAgentIdentifiers: () => SWRResponse<IdentifiersResponse>;
+  useGroupAgentList: (params?: GroupAgentQueryParams) => SWRResponse<GroupAgentListResponse>;
+}
+
+export const createGroupAgentSlice: StateCreator<
+  DiscoverStore,
+  [['zustand/devtools', never]],
+  [],
+  GroupAgentAction
+> = () => ({
+  useGroupAgentCategories: (params = {}) => {
+    const locale = globalHelpers.getCurrentLanguage();
+    return useSWR(
+      ['group-agent-categories', locale, ...Object.values(params)].filter(Boolean).join('-'),
+      async () => discoverService.getGroupAgentCategories(params),
+      {
+        revalidateOnFocus: false,
+      },
+    );
+  },
+
+  useGroupAgentDetail: (params) => {
+    const locale = globalHelpers.getCurrentLanguage();
+    return useSWR(
+      ['group-agent-details', locale, params.identifier, params.version]
+        .filter(Boolean)
+        .join('-'),
+      async () => discoverService.getGroupAgentDetail(params),
+      {
+        revalidateOnFocus: false,
+      },
+    );
+  },
+
+  useGroupAgentIdentifiers: () => {
+    return useSWR(
+      'group-agent-identifiers',
+      async () => discoverService.getGroupAgentIdentifiers(),
+      {
+        revalidateOnFocus: false,
+      },
+    );
+  },
+
+  useGroupAgentList: (params = {}) => {
+    const locale = globalHelpers.getCurrentLanguage();
+    return useSWR(
+      ['group-agent-list', locale, ...Object.values(params)].filter(Boolean).join('-'),
+      async () =>
+        discoverService.getGroupAgentList({
+          ...params,
+          page: params.page ? Number(params.page) : 1,
+          pageSize: params.pageSize ? Number(params.pageSize) : 20,
+        }),
+      {
+        revalidateOnFocus: false,
+      },
+    );
+  },
+});

package/src/store/discover/store.ts

@@ -4,6 +4,7 @@ import { type StateCreator } from 'zustand/vanilla';
 
 import { createDevtools } from '../middleware/createDevtools';
 import { type AssistantAction, createAssistantSlice } from './slices/assistant/action';
+import { type GroupAgentAction, createGroupAgentSlice } from './slices/groupAgent/action';
 import { type MCPAction, createMCPSlice } from './slices/mcp';
 import { type ModelAction, createModelSlice } from './slices/model/action';
 import { type PluginAction, createPluginSlice } from './slices/plugin/action';
@@ -15,6 +16,7 @@ import { type UserAction, createUserSlice } from './slices/user';
 
 export type DiscoverStore = MCPAction &
   AssistantAction &
+  GroupAgentAction &
   ProviderAction &
   ModelAction &
   PluginAction &
@@ -26,6 +28,7 @@ const createStore: StateCreator<DiscoverStore, [['zustand/devtools', never]]> =
 ) => ({
   ...createMCPSlice(...parameters),
   ...createAssistantSlice(...parameters),
+  ...createGroupAgentSlice(...parameters),
   ...createProviderSlice(...parameters),
   ...createModelSlice(...parameters),
   ...createPluginSlice(...parameters),

package/src/store/file/slices/resource/action.ts

@@ -239,9 +239,11 @@ export const createResourceSlice: StateCreator<
         'deleteResource/optimistic',
       );
 
-      // 2. Enqueue sync (background)
+      // 2. Enqueue sync and await completion.
+      // Important: if callers revalidate the list immediately, doing so before the server-side
+      // deletion finishes can re-introduce the item from a still-stale query response.
       const syncEngine = getSyncEngine();
-      syncEngine.enqueue({
+      await syncEngine.enqueue({
         id: `sync-${id}-${Date.now()}`,
         payload: {},
         resourceId: id,

package/src/tools/inspectors.ts

@@ -23,6 +23,7 @@ import {
   LocalSystemInspectors,
   LocalSystemManifest,
 } from '@lobechat/builtin-tool-local-system/client';
+import { MemoryInspectors, MemoryManifest } from '@lobechat/builtin-tool-memory/client';
 import { NotebookInspectors, NotebookManifest } from '@lobechat/builtin-tool-notebook/client';
 import { PageAgentInspectors, PageAgentManifest } from '@lobechat/builtin-tool-page-agent/client';
 import {
@@ -52,6 +53,7 @@ const BuiltinToolInspectors: Record<string, Record<string, BuiltinInspector>> =
   [GTDManifest.identifier]: GTDInspectors as Record<string, BuiltinInspector>,
   [KnowledgeBaseManifest.identifier]: KnowledgeBaseInspectors as Record<string, BuiltinInspector>,
   [LocalSystemManifest.identifier]: LocalSystemInspectors as Record<string, BuiltinInspector>,
+  [MemoryManifest.identifier]: MemoryInspectors as Record<string, BuiltinInspector>,
   [NotebookManifest.identifier]: NotebookInspectors as Record<string, BuiltinInspector>,
   [PageAgentManifest.identifier]: PageAgentInspectors as Record<string, BuiltinInspector>,
   [WebBrowsingManifest.identifier]: WebBrowsingInspectors as Record<string, BuiltinInspector>,