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

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

@@ -0,0 +1,296 @@
+import { TRPCError } from '@trpc/server';
+import debug from 'debug';
+import { customAlphabet } from 'nanoid/non-secure';
+import { z } from 'zod';
+
+import { authedProcedure, router } from '@/libs/trpc/lambda';
+import { marketSDK, marketUserInfo, serverDatabase } from '@/libs/trpc/lambda/middleware';
+import { type TrustedClientUserInfo, generateTrustedClientToken } from '@/libs/trusted-client';
+
+const MARKET_BASE_URL = process.env.NEXT_PUBLIC_MARKET_BASE_URL || 'https://market.lobehub.com';
+
+interface MarketUserInfo {
+  accountId: number;
+  sub: string;
+}
+
+const log = debug('lambda-router:market:agent-group');
+
+/**
+ * Generate a market identifier (8-character lowercase alphanumeric string)
+ * Format: [a-z0-9]{8}
+ */
+const generateMarketIdentifier = () => {
+  const alphabet = '0123456789abcdefghijklmnopqrstuvwxyz';
+  const generate = customAlphabet(alphabet, 8);
+  return generate();
+};
+
+interface FetchMarketUserInfoOptions {
+  accessToken?: string;
+  userInfo?: TrustedClientUserInfo;
+}
+
+/**
+ * Fetch Market user info using either trustedClientToken or accessToken
+ * Returns the Market accountId which is different from LobeChat userId
+ */
+const fetchMarketUserInfo = async (
+  options: FetchMarketUserInfoOptions,
+): Promise<MarketUserInfo | null> => {
+  const { userInfo, accessToken } = options;
+
+  try {
+    const userInfoUrl = `${MARKET_BASE_URL}/lobehub-oidc/userinfo`;
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+    };
+
+    if (userInfo) {
+      const trustedClientToken = generateTrustedClientToken(userInfo);
+      if (trustedClientToken) {
+        headers['x-lobe-trust-token'] = trustedClientToken;
+        log('Using trustedClientToken for user info fetch');
+      }
+    }
+
+    if (!headers['x-lobe-trust-token'] && accessToken) {
+      headers['Authorization'] = `Bearer ${accessToken}`;
+      log('Using accessToken for user info fetch');
+    }
+
+    if (!headers['x-lobe-trust-token'] && !headers['Authorization']) {
+      log('No authentication method available for fetching user info');
+      return null;
+    }
+
+    const response = await fetch(userInfoUrl, {
+      headers,
+      method: 'GET',
+    });
+
+    if (!response.ok) {
+      log('Failed to fetch Market user info: %s %s', response.status, response.statusText);
+      return null;
+    }
+
+    return (await response.json()) as MarketUserInfo;
+  } catch (error) {
+    log('Error fetching Market user info: %O', error);
+    return null;
+  }
+};
+
+// Authenticated procedure for agent group management
+const agentGroupProcedure = authedProcedure
+  .use(serverDatabase)
+  .use(marketUserInfo)
+  .use(marketSDK)
+  .use(async ({ ctx, next }) => {
+    const { UserModel } = await import('@/database/models/user');
+    const userModel = new UserModel(ctx.serverDB, ctx.userId);
+
+    let marketOidcAccessToken: string | undefined;
+    try {
+      const userState = await userModel.getUserState(async () => ({}));
+      marketOidcAccessToken = userState.settings?.market?.accessToken;
+      log('marketOidcAccessToken from DB exists=%s', !!marketOidcAccessToken);
+    } catch (error) {
+      log('Failed to get marketOidcAccessToken from DB: %O', error);
+    }
+
+    return next({
+      ctx: {
+        marketOidcAccessToken,
+      },
+    });
+  });
+
+// Schema definitions
+const memberAgentSchema = z.object({
+  avatar: z.string().nullish(),
+  category: z.string().optional(),
+  config: z.record(z.any()),
+  description: z.string(),
+  displayOrder: z.number().optional(),
+  identifier: z.string(),
+  name: z.string(),
+  role: z.enum(['supervisor', 'participant']),
+  url: z.string(),
+});
+
+const publishOrCreateGroupSchema = z.object({
+  avatar: z.string().nullish(),
+  backgroundColor: z.string().nullish(),
+  category: z.string().optional(),
+  changelog: z.string().optional(),
+  config: z
+    .object({
+      allowDM: z.boolean().optional(),
+      openingMessage: z.string().optional(),
+      openingQuestions: z.array(z.string()).optional(),
+      revealDM: z.boolean().optional(),
+      systemPrompt: z.string().optional(),
+    })
+    .optional(),
+  description: z.string(),
+  identifier: z.string().optional(),
+  memberAgents: z.array(memberAgentSchema),
+  name: z.string(),
+  visibility: z.enum(['public', 'private', 'internal']).optional(),
+});
+
+export const agentGroupRouter = router({
+  /**
+   * Check if current user owns the specified group
+   */
+  checkOwnership: agentGroupProcedure
+    .input(z.object({ identifier: z.string() }))
+    .query(async ({ input, ctx }) => {
+      log('checkOwnership input: %O', input);
+
+      try {
+        const groupDetail = await ctx.marketSDK.agentGroups.getAgentGroupDetail(input.identifier);
+
+        if (!groupDetail) {
+          return {
+            exists: false,
+            isOwner: false,
+            originalGroup: null,
+          };
+        }
+
+        const userInfo = ctx.marketUserInfo as TrustedClientUserInfo | undefined;
+        const accessToken = (ctx as { marketOidcAccessToken?: string }).marketOidcAccessToken;
+        let currentAccountId: number | null = null;
+
+        const marketUserInfoResult = await fetchMarketUserInfo({ accessToken, userInfo });
+        currentAccountId = marketUserInfoResult?.accountId ?? null;
+
+        const ownerId = groupDetail.group.ownerId;
+        const isOwner = currentAccountId !== null && `${ownerId}` === `${currentAccountId}`;
+
+        log(
+          'checkOwnership result: isOwner=%s, currentAccountId=%s, ownerId=%s',
+          isOwner,
+          currentAccountId,
+          ownerId,
+        );
+
+        return {
+          exists: true,
+          isOwner,
+          originalGroup: isOwner
+            ? null
+            : {
+                // TODO: Add author info from group detail
+                author: undefined,
+                avatar: groupDetail.group.avatar,
+                identifier: groupDetail.group.identifier,
+                name: groupDetail.group.name,
+              },
+        };
+      } catch (error) {
+        log('Error checking ownership: %O', error);
+        return {
+          exists: false,
+          isOwner: false,
+          originalGroup: null,
+        };
+      }
+    }),
+
+  /**
+   * Unified publish or create agent group flow
+   * 1. Check if identifier exists and if current user is owner
+   * 2. If not owner or no identifier, create new group
+   * 3. Create new version for the group if updating
+   */
+  publishOrCreate: agentGroupProcedure
+    .input(publishOrCreateGroupSchema)
+    .mutation(async ({ input, ctx }) => {
+      log('publishOrCreate input: %O', input);
+
+      const { identifier: inputIdentifier, name, memberAgents, ...groupData } = input;
+      let finalIdentifier = inputIdentifier;
+      let isNewGroup = false;
+
+      try {
+        // Step 1: Check ownership if identifier is provided
+        if (inputIdentifier) {
+          try {
+            const groupDetail =
+              await ctx.marketSDK.agentGroups.getAgentGroupDetail(inputIdentifier);
+            log('Group detail for ownership check: ownerId=%s', groupDetail?.group.ownerId);
+
+            const userInfo = ctx.marketUserInfo as TrustedClientUserInfo | undefined;
+            const accessToken = (ctx as { marketOidcAccessToken?: string }).marketOidcAccessToken;
+            let currentAccountId: number | null = null;
+
+            const marketUserInfoResult = await fetchMarketUserInfo({ accessToken, userInfo });
+            currentAccountId = marketUserInfoResult?.accountId ?? null;
+            log('Market user info: accountId=%s', currentAccountId);
+
+            const ownerId = groupDetail?.group.ownerId;
+
+            log('Ownership check: currentAccountId=%s, ownerId=%s', currentAccountId, ownerId);
+
+            if (!currentAccountId || `${ownerId}` !== `${currentAccountId}`) {
+              // Not the owner, need to create a new group
+              log('User is not owner, will create new group');
+              finalIdentifier = undefined;
+              isNewGroup = true;
+            }
+          } catch (detailError) {
+            // Group not found or error, create new
+            log('Group not found or error, will create new: %O', detailError);
+            finalIdentifier = undefined;
+            isNewGroup = true;
+          }
+        } else {
+          isNewGroup = true;
+        }
+
+        // Step 2: Create new group or update existing
+        if (!finalIdentifier || isNewGroup) {
+          // Generate a unique 8-character identifier
+          finalIdentifier = generateMarketIdentifier();
+          isNewGroup = true;
+
+          log('Creating new group with identifier: %s', finalIdentifier);
+
+          await ctx.marketSDK.agentGroups.createAgentGroup({
+            ...groupData,
+            identifier: finalIdentifier,
+            // @ts-ignore
+            memberAgents,
+            name,
+          });
+        } else {
+          // Update existing group - create new version
+          log('Creating new version for group: %s', finalIdentifier);
+
+          await ctx.marketSDK.agentGroups.createAgentGroupVersion({
+            ...groupData,
+            identifier: finalIdentifier,
+            // @ts-ignore
+            memberAgents,
+            name,
+          });
+        }
+
+        return {
+          identifier: finalIdentifier,
+          isNewGroup,
+          success: true,
+        };
+      } catch (error) {
+        log('Error in publishOrCreate: %O', error);
+        throw new TRPCError({
+          cause: error,
+          code: 'INTERNAL_SERVER_ERROR',
+          message: error instanceof Error ? error.message : 'Failed to publish group',
+        });
+      }
+    }),
+});

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);
+    }
+  };
 }