@lobehub/lobehub 2.1.13 → 2.1.15

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

@@ -48,7 +48,32 @@ export const messageRouter = router({
       return ctx.messageService.addFilesToMessage(id, fileIds, resolved);
     }),
 
-  count: messageProcedure
+  /**
+   * Cancel compression by deleting the compression group and restoring original messages
+   */
+cancelCompression: messageProcedure
+    .input(
+      z.object({
+        agentId: z.string(),
+        groupId: z.string().nullable().optional(),
+        messageGroupId: z.string(),
+        threadId: z.string().nullable().optional(),
+        topicId: z.string(),
+      }),
+    )
+    .mutation(async ({ input, ctx }) => {
+      const { messageGroupId, agentId, groupId, threadId, topicId } = input;
+
+      return ctx.messageService.cancelCompression(messageGroupId, {
+        agentId,
+        groupId,
+        threadId,
+        topicId,
+      });
+    }),
+
+  
+count: messageProcedure
     .input(
       z
         .object({
@@ -62,7 +87,9 @@ export const messageRouter = router({
       return ctx.messageModel.count(input);
     }),
 
-  countWords: messageProcedure
+  
+  
+countWords: messageProcedure
     .input(
       z
         .object({
@@ -76,12 +103,13 @@ export const messageRouter = router({
       return ctx.messageModel.countWords(input);
     }),
 
-  /**
+  
+/**
    * Create a compression group for old messages
    * Creates a placeholder group, marks messages as compressed
    * Returns messages to summarize for frontend AI generation
    */
-  createCompressionGroup: messageProcedure
+createCompressionGroup: messageProcedure
     .input(
       z.object({
         agentId: z.string(),
@@ -102,7 +130,9 @@ export const messageRouter = router({
       });
     }),
 
-  createMessage: messageProcedure
+  
+  
+createMessage: messageProcedure
     .input(CreateNewMessageParamsSchema)
     .mutation(async ({ input, ctx }) => {
       // If there's no agentId but has sessionId, resolve agentId from sessionId
@@ -115,10 +145,11 @@ export const messageRouter = router({
       return ctx.messageService.createMessage({ ...input, agentId } as any);
     }),
 
+  
   /**
    * Finalize compression by updating the group with generated summary
    */
-  finalizeCompression: messageProcedure
+finalizeCompression: messageProcedure
     .input(
       z.object({
         agentId: z.string(),

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

@@ -745,6 +745,7 @@ export class DiscoverService {
           title: item.name || item.identifier,
           tokenUsage: item.tokenUsage || 0,
           type: item.type,
+          updatedAt: item.updatedAt,
           userName: normalizedAuthor.userName,
         };
       });
@@ -1710,6 +1711,8 @@ export class DiscoverService {
         locale,
       })) as UserInfoResponse & {
         agentGroups?: any[];
+        favoriteAgentGroups?: any[];
+        favoriteAgents?: any[];
         forkedAgentGroups?: any[];
         forkedAgents?: any[];
       };
@@ -1719,7 +1722,7 @@ export class DiscoverService {
         return undefined;
       }
 
-      const { user, agents, agentGroups, forkedAgents, forkedAgentGroups } = response;
+      const { user, agents, agentGroups, forkedAgents, forkedAgentGroups, favoriteAgents, favoriteAgentGroups } = response;
 
       // Transform agents to DiscoverAssistantItem format
       const transformedAgents: DiscoverAssistantItem[] = (agents || []).map((agent: any) => ({
@@ -1811,9 +1814,59 @@ export class DiscoverService {
         updatedAt: group.updatedAt,
       }));
 
+      // Transform favoriteAgents to DiscoverAssistantItem format
+      const transformedFavoriteAgents: DiscoverAssistantItem[] = (favoriteAgents || []).map(
+        (agent: any) => ({
+          author: agent.author || '',
+          avatar: agent.avatar || '',
+          category: agent.category as any,
+          config: {} as any,
+          createdAt: agent.createdAt,
+          description: agent.description || '',
+          forkCount: agent.forkCount || 0,
+          forkedFromAgentId: agent.forkedFromAgentId || null,
+          homepage: `https://lobehub.com/discover/assistant/${agent.identifier}`,
+          identifier: agent.identifier,
+          installCount: agent.installCount,
+          isValidated: agent.isValidated,
+          knowledgeCount: agent.knowledgeCount || 0,
+          pluginCount: agent.pluginCount || 0,
+          schemaVersion: 1,
+          status: agent.status,
+          tags: agent.tags || [],
+          title: agent.name || agent.identifier,
+          tokenUsage: agent.tokenUsage || 0,
+        }),
+      );
+
+      // Transform favoriteAgentGroups to DiscoverGroupAgentItem format
+      const transformedFavoriteAgentGroups = (favoriteAgentGroups || []).map((group: any) => ({
+        author: group.author || '',
+        avatar: group.avatar || '👥',
+        category: group.category as any,
+        createdAt: group.createdAt,
+        description: group.description || '',
+        forkCount: group.forkCount || 0,
+        forkedFromGroupId: group.forkedFromGroupId || null,
+        homepage: `https://lobehub.com/discover/group_agent/${group.identifier}`,
+        identifier: group.identifier,
+        installCount: group.installCount || 0,
+        isFeatured: group.isFeatured || false,
+        isOfficial: group.isOfficial || false,
+        isValidated: group.isValidated,
+        memberCount: 0, // Will be populated from memberAgents in detail view
+        schemaVersion: 1,
+        status: group.status,
+        tags: group.tags || [],
+        title: group.name || group.identifier,
+        updatedAt: group.updatedAt,
+      }));
+
       const result: DiscoverUserProfile = {
         agentGroups: transformedAgentGroups,
         agents: transformedAgents,
+        favoriteAgentGroups: transformedFavoriteAgentGroups,
+        favoriteAgents: transformedFavoriteAgents,
         forkedAgentGroups: transformedForkedAgentGroups,
         forkedAgents: transformedForkedAgents,
         user: {
@@ -1833,11 +1886,13 @@ export class DiscoverService {
       };
 
       log(
-        'getUserInfo: returning user profile with %d agents, %d groups, %d forked agents, %d forked groups',
+        'getUserInfo: returning user profile with %d agents, %d groups, %d forked agents, %d forked groups, %d favorite agents, %d favorite groups',
         result.agents.length,
         result.agentGroups?.length || 0,
         result.forkedAgents?.length || 0,
         result.forkedAgentGroups?.length || 0,
+        result.favoriteAgents?.length || 0,
+        result.favoriteAgentGroups?.length || 0,
       );
       return result;
     } catch (error) {

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

@@ -359,4 +359,23 @@ export class MessageService {
 
     return { messages };
   }
+
+  /**
+   * Cancel compression by deleting the compression group and restoring original messages
+   *
+   * @param messageGroupId - The compression group ID to cancel
+   * @param context - Query options for returning updated messages
+   */
+  async cancelCompression(
+    messageGroupId: string,
+    context: QueryOptions,
+  ): Promise<{ messages: UIChatMessage[]; success: boolean }> {
+    // Delete compression group (this also unmarks messages)
+    await this.compressionRepository.deleteCompressionGroup(messageGroupId);
+
+    // Query updated messages
+    const messages = await this.messageModel.query(context, this.getQueryOptions());
+
+    return { messages, success: true };
+  }
 }

package/src/services/message/index.ts

@@ -276,6 +276,20 @@ export class MessageService {
       messages: (result.messages || []) as unknown as UIChatMessage[],
     };
   };
+
+  /**
+   * Cancel compression by deleting the compression group and restoring original messages
+   */
+  cancelCompression = async (params: {
+    agentId: string;
+    groupId?: string | null;
+    messageGroupId: string;
+    threadId?: string | null;
+    topicId: string;
+  }): Promise<{ messages: UIChatMessage[] }> => {
+    const result = await lambdaClient.message.cancelCompression.mutate(params);
+    return { messages: (result.messages || []) as unknown as UIChatMessage[] };
+  };
 }
 
 export const messageService = new MessageService();

package/src/services/models.ts

@@ -75,7 +75,6 @@ export class ModelsService {
       const runtimeProvider = resolveRuntimeProvider(provider);
       const enableFetchOnClient = isEnableFetchOnClient(provider);
 
-      console.log('enableFetchOnClient：', enableFetchOnClient);
       let res: Response;
       if (enableFetchOnClient) {
         const agentRuntime = await initializeWithClientStore({

package/src/services/social.ts

@@ -1,6 +1,6 @@
 import { lambdaClient } from '@/libs/trpc/client';
 
-export type SocialTargetType = 'agent' | 'plugin';
+export type SocialTargetType = 'agent' | 'plugin' | 'agent-group';
 
 export interface FollowStatus {
   isFollowing: boolean;