@lobehub/lobehub 2.1.14 → 2.1.15

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 # Changelog
 
+### [Version 2.1.15](https://github.com/lobehub/lobe-chat/compare/v2.1.14...v2.1.15)
+
+<sup>Released on **2026-02-04**</sup>
+
+#### 🐛 Bug Fixes
+
+- **misc**: Fixed the agents list the show updateAt time error.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### What's fixed
+
+- **misc**: Fixed the agents list the show updateAt time error, closes [#12103](https://github.com/lobehub/lobe-chat/issues/12103) ([3063cee](https://github.com/lobehub/lobe-chat/commit/3063cee))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
 ### [Version 2.1.14](https://github.com/lobehub/lobe-chat/compare/v2.1.13...v2.1.14)
 
 <sup>Released on **2026-02-04**</sup>

package/changelog/v2.json

@@ -1,4 +1,13 @@
 [
+  {
+    "children": {
+      "fixes": [
+        "Fixed the agents list the show updateAt time error."
+      ]
+    },
+    "date": "2026-02-04",
+    "version": "2.1.15"
+  },
   {
     "children": {
       "fixes": [

package/locales/en-US/discover.json

@@ -490,6 +490,15 @@
   "user.noForkedAgentGroups": "No forked Agent Groups yet",
   "user.noForkedAgents": "No forked Agents yet",
   "user.publishedAgents": "Created Agents",
+  "user.publishedGroups": "Created Groups",
+  "user.searchPlaceholder": "Search by name or description...",
+  "user.statusFilter.all": "All",
+  "user.statusFilter.archived": "Archived",
+  "user.statusFilter.deprecated": "Deprecated",
+  "user.statusFilter.favorite": "Favorite",
+  "user.statusFilter.forked": "Forked",
+  "user.statusFilter.published": "Published",
+  "user.statusFilter.unpublished": "Under Review",
   "user.tabs.favorites": "Favorites",
   "user.tabs.forkedAgents": "Forked",
   "user.tabs.publishedAgents": "Created",

package/locales/zh-CN/discover.json

@@ -490,6 +490,15 @@
   "user.noForkedAgentGroups": "尚无已派生的代理组",
   "user.noForkedAgents": "尚无已派生的代理",
   "user.publishedAgents": "创作的助理",
+  "user.publishedGroups": "创作的群组",
+  "user.searchPlaceholder": "搜索名称或描述...",
+  "user.statusFilter.all": "全部",
+  "user.statusFilter.archived": "已归档",
+  "user.statusFilter.deprecated": "已废弃",
+  "user.statusFilter.favorite": "已收藏",
+  "user.statusFilter.forked": "已派生",
+  "user.statusFilter.published": "已发布",
+  "user.statusFilter.unpublished": "审核中",
   "user.tabs.favorites": "收藏",
   "user.tabs.forkedAgents": "已派生",
   "user.tabs.publishedAgents": "创作",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/lobehub",
-  "version": "2.1.14",
+  "version": "2.1.15",
   "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",

package/packages/types/src/discover/assistants.ts

@@ -62,6 +62,7 @@ export interface DiscoverAssistantItem extends Omit<LobeAgentSettings, 'meta'>,
   status?: AgentStatus;
   tokenUsage: number;
   type?: AgentType;
+  updatedAt?: string;
   userName?: string;
 }
 

package/packages/types/src/discover/index.ts

@@ -67,6 +67,14 @@ export interface DiscoverUserInfo {
 export interface DiscoverUserProfile {
   agentGroups?: DiscoverGroupAgentItem[];
   agents: DiscoverAssistantItem[];
+  /**
+   * Agent groups favorited by the user
+   */
+  favoriteAgentGroups?: DiscoverGroupAgentItem[];
+  /**
+   * Agents favorited by the user
+   */
+  favoriteAgents?: DiscoverAssistantItem[];
   /**
    * Agent groups forked by the user
    */

package/packages/utils/src/chunkers/trimBatchProbe/trimBatchProbe.ts

@@ -202,7 +202,7 @@ export const handleSingle = async (
  *    to avoid breaking structured XML/JSON-like content mid-way.
  *
  * Bisection example (8 segments, keep newest):
- *   try 4 (fits?) → yes → try 6 → no → try 5 → yes ⇒ best=5
+ *   try 4 (fits?) -> yes -> try 6 -> no -> try 5 -> yes => best=5
  *   if compact retry needed, repeat with build(true) and pick the better fit.
  *
  * This minimizes structural breakage by preferring whole built segments and only truncating the last one as a last resort.

package/packages/utils/src/pricing.ts

@@ -2,9 +2,9 @@ import { Pricing, PricingUnit, PricingUnitName } from 'model-bank';
 
 /**
  * Internal helper to extract the displayed unit rate from a pricing unit by strategy
- * - fixed → rate
- * - tiered → tiers[0].rate
- * - lookup → first price value
+ * - fixed: rate
+ * - tiered: tiers[0].rate
+ * - lookup: first price value
  */
 const getRateFromUnit = (unit: PricingUnit): number | undefined => {
   switch (unit.strategy) {
@@ -39,9 +39,9 @@ export const getUnitRateByName = (
 
 /**
  * Get text input unit rate from pricing
- * - fixed → rate
- * - tiered → tiers[0].rate
- * - lookup → Object.values(lookup.prices)[0]
+ * - fixed: rate
+ * - tiered: tiers[0].rate
+ * - lookup: Object.values(lookup.prices)[0]
  */
 export function getTextInputUnitRate(pricing?: Pricing): number | undefined {
   return getUnitRateByName(pricing, 'textInput');

package/src/app/[variants]/(main)/community/(detail)/group_agent/features/Header.tsx

@@ -75,7 +75,7 @@ const Header = memo<{ mobile?: boolean }>(({ mobile: isMobile }) => {
   // Fetch favorite status
   const { data: favoriteStatus, mutate: mutateFavorite } = useSWR(
     identifier && isAuthenticated ? ['favorite-status', 'agent', identifier] : null,
-    () => socialService.checkFavoriteStatus('agent', identifier!),
+    () => socialService.checkFavoriteStatus('agent-group', identifier!),
     { revalidateOnFocus: false },
   );
 
@@ -100,10 +100,10 @@ const Header = memo<{ mobile?: boolean }>(({ mobile: isMobile }) => {
     setFavoriteLoading(true);
     try {
       if (isFavorited) {
-        await socialService.removeFavorite('agent', identifier);
+        await socialService.removeFavorite('agent-group', identifier);
         message.success(t('assistant.unfavoriteSuccess'));
       } else {
-        await socialService.addFavorite('agent', identifier);
+        await socialService.addFavorite('agent-group', identifier);
         message.success(t('assistant.favoriteSuccess'));
       }
       await mutateFavorite();

package/src/app/[variants]/(main)/community/(detail)/user/features/DetailProvider.tsx

@@ -13,6 +13,8 @@ export interface UserDetailContextConfig {
   agentCount: number;
   agentGroups?: DiscoverGroupAgentItem[];
   agents: DiscoverAssistantItem[];
+  favoriteAgentGroups?: DiscoverGroupAgentItem[];
+  favoriteAgents?: DiscoverAssistantItem[];
   forkedAgentGroups?: DiscoverGroupAgentItem[];
   forkedAgents?: DiscoverAssistantItem[];
   groupCount: number;

package/src/app/[variants]/(main)/community/(detail)/user/features/StatusFilter.tsx

@@ -0,0 +1,36 @@
+'use client';
+
+import { Select } from 'antd';
+import { memo } from 'react';
+import { useTranslation } from 'react-i18next';
+
+export type StatusFilterValue = 'published' | 'unpublished' | 'deprecated' | 'archived' | 'forked' | 'favorite';
+
+interface StatusFilterProps {
+  onChange: (value: StatusFilterValue) => void;
+  value: StatusFilterValue;
+}
+
+const StatusFilter = memo<StatusFilterProps>(({ value, onChange }) => {
+  const { t } = useTranslation('discover');
+
+  const options = [
+    { label: t('user.statusFilter.published'), value: 'published' as const },
+    { label: t('user.statusFilter.unpublished'), value: 'unpublished' as const },
+    { label: t('user.statusFilter.deprecated'), value: 'deprecated' as const },
+    { label: t('user.statusFilter.archived'), value: 'archived' as const },
+    { label: t('user.statusFilter.forked'), value: 'forked' as const },
+    { label: t('user.statusFilter.favorite'), value: 'favorite' as const },
+  ];
+
+  return (
+    <Select
+      onChange={onChange}
+      options={options}
+      style={{ minWidth: 120 }}
+      value={value}
+    />
+  );
+});
+
+export default StatusFilter;

package/src/app/[variants]/(main)/community/(detail)/user/features/UserAgentList.tsx

@@ -1,12 +1,13 @@
 'use client';
 
 import { Flexbox, Grid, Tag, Text } from '@lobehub/ui';
-import { Pagination } from 'antd';
+import { Input, Pagination } from 'antd';
 import { memo, useMemo, useState } from 'react';
 import { useTranslation } from 'react-i18next';
 
 import AssistantEmpty from '../../../features/AssistantEmpty';
 import { useUserDetailContext } from './DetailProvider';
+import StatusFilter, { type StatusFilterValue } from './StatusFilter';
 import UserAgentCard from './UserAgentCard';
 
 interface UserAgentListProps {
@@ -14,27 +15,82 @@ interface UserAgentListProps {
   rows?: number;
 }
 
-const UserAgentList = memo<UserAgentListProps>(({ rows = 4, pageSize = 10 }) => {
+const UserAgentList = memo<UserAgentListProps>(({ rows = 4, pageSize = 8 }) => {
   const { t } = useTranslation('discover');
-  const { agents, agentCount } = useUserDetailContext();
+  const { agents, agentCount, forkedAgents = [], favoriteAgents = [], isOwner } = useUserDetailContext();
   const [currentPage, setCurrentPage] = useState(1);
+  const [statusFilter, setStatusFilter] = useState<StatusFilterValue>('published');
+  const [searchQuery, setSearchQuery] = useState('');
+
+  // Combine agents and forked agents, then filter based on status and search
+  const filteredAgents = useMemo(() => {
+    let allAgents = [...agents];
+
+    if (statusFilter === 'forked') {
+      // Show only forked agents (those with forkedFromAgentId)
+      allAgents = forkedAgents;
+    } else if (statusFilter === 'favorite') {
+      // Show only favorited agents
+      allAgents = favoriteAgents;
+    } else {
+      // Filter by status for non-forked agents
+      allAgents = allAgents.filter((agent) => {
+        return agent.status === statusFilter;
+      });
+    }
+
+    // Apply search filter
+    if (searchQuery.trim()) {
+      const query = searchQuery.toLowerCase();
+      allAgents = allAgents.filter((agent) => {
+        console.log('agent', agent);
+        const name = agent?.title?.toLowerCase() || '';
+        const description = agent?.description?.toLowerCase() || '';
+        return name.includes(query) || description.includes(query);
+      });
+    }
+
+    return allAgents;
+  }, [agents, forkedAgents, statusFilter, searchQuery]);
 
   const paginatedAgents = useMemo(() => {
     const startIndex = (currentPage - 1) * pageSize;
-    return agents.slice(startIndex, startIndex + pageSize);
-  }, [agents, currentPage, pageSize]);
+    return filteredAgents.slice(startIndex, startIndex + pageSize);
+  }, [filteredAgents, currentPage, pageSize]);
+
+  // Reset to page 1 when filter or search changes
+  useMemo(() => {
+    setCurrentPage(1);
+  }, [statusFilter, searchQuery]);
 
-  if (agents.length === 0) return <AssistantEmpty />;
+  if (agents.length === 0 && forkedAgents.length === 0) return <AssistantEmpty />;
 
-  const showPagination = agents.length > pageSize;
+  const showPagination = filteredAgents.length > pageSize;
 
   return (
     <Flexbox gap={16}>
-      <Flexbox align={'center'} gap={8} horizontal>
-        <Text fontSize={16} weight={500}>
-          {t('user.publishedAgents')}
-        </Text>
-        {agentCount > 0 && <Tag>{agentCount}</Tag>}
+      <Flexbox align={'center'} gap={8} horizontal justify={'space-between'}>
+        <Flexbox align={'center'} gap={8} horizontal>
+          <Text fontSize={16} weight={500}>
+            {t('user.publishedAgents')}
+          </Text>
+          {agentCount > 0 && <Tag>{filteredAgents.length}</Tag>}
+        </Flexbox>
+        {isOwner && (
+          <Flexbox align={'center'} gap={8} horizontal>
+            <Input.Search
+              allowClear
+              onChange={(e) => setSearchQuery(e.target.value)}
+              placeholder={t('user.searchPlaceholder')}
+              style={{ width: 200 }}
+              value={searchQuery}
+            />
+            <StatusFilter
+              onChange={(value) => setStatusFilter(value)}
+              value={statusFilter}
+            />
+          </Flexbox>
+        )}
       </Flexbox>
       <Grid rows={rows} width={'100%'}>
         {paginatedAgents.map((item, index) => (
@@ -48,7 +104,7 @@ const UserAgentList = memo<UserAgentListProps>(({ rows = 4, pageSize = 10 }) =>
             onChange={(page) => setCurrentPage(page)}
             pageSize={pageSize}
             showSizeChanger={false}
-            total={agents.length}
+            total={filteredAgents.length}
           />
         </Flexbox>
       )}

package/src/app/[variants]/(main)/community/(detail)/user/features/UserContent.tsx

@@ -3,25 +3,14 @@
 import { Flexbox } from '@lobehub/ui';
 import { memo } from 'react';
 
-import { useUserDetailContext } from './DetailProvider';
 import UserAgentList from './UserAgentList';
-import UserFavoriteAgents from './UserFavoriteAgents';
-import UserFavoritePlugins from './UserFavoritePlugins';
-import UserForkedAgentGroups from './UserForkedAgentGroups';
-import UserForkedAgents from './UserForkedAgents';
 import UserGroupList from './UserGroupList';
 
 const UserContent = memo(() => {
-  const { forkedAgents, forkedAgentGroups } = useUserDetailContext();
-
   return (
     <Flexbox gap={32}>
       <UserAgentList />
       <UserGroupList />
-      <UserForkedAgents agents={forkedAgents} />
-      <UserForkedAgentGroups agentGroups={forkedAgentGroups} />
-      <UserFavoriteAgents />
-      <UserFavoritePlugins />
     </Flexbox>
   );
 });

package/src/app/[variants]/(main)/community/(detail)/user/features/UserGroupList.tsx

@@ -1,11 +1,12 @@
 'use client';
 
 import { Flexbox, Grid, Tag, Text } from '@lobehub/ui';
-import { Pagination } from 'antd';
+import { Input, Pagination } from 'antd';
 import { memo, useMemo, useState } from 'react';
 import { useTranslation } from 'react-i18next';
 
 import { useUserDetailContext } from './DetailProvider';
+import StatusFilter, { type StatusFilterValue } from './StatusFilter';
 import UserGroupCard from './UserGroupCard';
 
 interface UserGroupListProps {
@@ -13,28 +14,81 @@ interface UserGroupListProps {
   rows?: number;
 }
 
-const UserGroupList = memo<UserGroupListProps>(({ rows = 4, pageSize = 10 }) => {
+const UserGroupList = memo<UserGroupListProps>(({ rows = 4, pageSize = 8 }) => {
   const { t } = useTranslation('discover');
-  const { agentGroups, groupCount } = useUserDetailContext();
+  const { agentGroups = [], groupCount, forkedAgentGroups = [], favoriteAgentGroups = [], isOwner } = useUserDetailContext();
   const [currentPage, setCurrentPage] = useState(1);
+  const [statusFilter, setStatusFilter] = useState<StatusFilterValue>('published');
+  const [searchQuery, setSearchQuery] = useState('');
+
+  // Combine groups and forked groups, then filter based on status and search
+  const filteredGroups = useMemo(() => {
+    let allGroups = [...agentGroups];
+
+    if (statusFilter === 'forked') {
+      // Show only forked groups (those with forkedFromAgentId)
+      allGroups = forkedAgentGroups;
+    } else if (statusFilter === 'favorite') {
+      // Show only favorited groups
+      allGroups = favoriteAgentGroups;
+    } else {
+      // Filter by status for non-forked groups
+      allGroups = allGroups.filter((group) => {
+        return group.status === statusFilter;
+      });
+    }
+
+    // Apply search filter
+    if (searchQuery.trim()) {
+      const query = searchQuery.toLowerCase();
+      allGroups = allGroups.filter((group) => {
+        const name = group?.title?.toLowerCase() || '';
+        const description = group?.description?.toLowerCase() || '';
+        return name.includes(query) || description.includes(query);
+      });
+    }
+
+    return allGroups;
+  }, [agentGroups, forkedAgentGroups, statusFilter, searchQuery]);
 
   const paginatedGroups = useMemo(() => {
-    if (!agentGroups) return [];
     const startIndex = (currentPage - 1) * pageSize;
-    return agentGroups.slice(startIndex, startIndex + pageSize);
-  }, [agentGroups, currentPage, pageSize]);
+    return filteredGroups.slice(startIndex, startIndex + pageSize);
+  }, [filteredGroups, currentPage, pageSize]);
+
+  // Reset to page 1 when filter or search changes
+  useMemo(() => {
+    setCurrentPage(1);
+  }, [statusFilter, searchQuery]);
 
-  if (!agentGroups || agentGroups.length === 0) return null;
+  if (agentGroups.length === 0 && forkedAgentGroups.length === 0) return null;
 
-  const showPagination = agentGroups.length > pageSize;
+  const showPagination = filteredGroups.length > pageSize;
 
   return (
     <Flexbox gap={16}>
-      <Flexbox align={'center'} gap={8} horizontal>
-        <Text fontSize={16} weight={500}>
-          {t('user.publishedGroups', { defaultValue: '创作的群组' })}
-        </Text>
-        {groupCount > 0 && <Tag>{groupCount}</Tag>}
+      <Flexbox align={'center'} gap={8} horizontal justify={'space-between'}>
+        <Flexbox align={'center'} gap={8} horizontal>
+          <Text fontSize={16} weight={500}>
+            {t('user.publishedGroups', { defaultValue: '创作的群组' })}
+          </Text>
+          {groupCount > 0 && <Tag>{filteredGroups.length}</Tag>}
+        </Flexbox>
+        {isOwner && (
+          <Flexbox align={'center'} gap={8} horizontal>
+            <Input.Search
+              allowClear
+              onChange={(e) => setSearchQuery(e.target.value)}
+              placeholder={t('user.searchPlaceholder')}
+              style={{ width: 200 }}
+              value={searchQuery}
+            />
+            <StatusFilter
+              onChange={(value) => setStatusFilter(value)}
+              value={statusFilter}
+            />
+          </Flexbox>
+        )}
       </Flexbox>
       <Grid rows={rows} width={'100%'}>
         {paginatedGroups.map((item, index) => (
@@ -48,7 +102,7 @@ const UserGroupList = memo<UserGroupListProps>(({ rows = 4, pageSize = 10 }) =>
             onChange={(page) => setCurrentPage(page)}
             pageSize={pageSize}
             showSizeChanger={false}
-            total={agentGroups.length}
+            total={filteredGroups.length}
           />
         </Flexbox>
       )}

package/src/app/[variants]/(main)/community/(detail)/user/index.tsx

@@ -61,12 +61,14 @@ const UserDetailPage = memo<UserDetailPageProps>(({ mobile }) => {
 
   const contextConfig = useMemo(() => {
     if (!data || !data.user) return null;
-    const { user, agents, agentGroups, forkedAgents, forkedAgentGroups } = data;
+    const { user, agents, agentGroups, forkedAgents, forkedAgentGroups, favoriteAgents, favoriteAgentGroups } = data;
     const totalInstalls = agents.reduce((sum, agent) => sum + (agent.installCount || 0), 0);
     return {
       agentCount: agents.length,
       agentGroups: agentGroups || [],
       agents,
+      favoriteAgentGroups: favoriteAgentGroups || [],
+      favoriteAgents: favoriteAgents || [],
       forkedAgentGroups: forkedAgentGroups || [],
       forkedAgents: forkedAgents || [],
       groupCount: agentGroups?.length || 0,

package/src/app/[variants]/(main)/community/(list)/agent/features/List/Item.tsx

@@ -56,6 +56,7 @@ const styles = createStaticStyles(({ css, cssVar }) => {
 const AssistantItem = memo<DiscoverAssistantItem>(
   ({
     createdAt,
+    updatedAt,
     author,
     avatar,
     title,
@@ -225,7 +226,7 @@ const AssistantItem = memo<DiscoverAssistantItem>(
               <Icon icon={ClockIcon} size={14} />
               <PublishedTime
                 className={styles.secondaryDesc}
-                date={createdAt}
+                date={updatedAt || createdAt}
                 template={'MMM DD, YYYY'}
               />
             </Flexbox>

package/src/locales/default/discover.ts

@@ -891,6 +891,18 @@ export default {
 
   'user.publishedAgents': 'Created Agents',
 
+  'user.publishedGroups': 'Created Groups',
+
+  'user.searchPlaceholder': 'Search by name or description...',
+
+  'user.statusFilter.all': 'All',
+  'user.statusFilter.archived': 'Archived',
+  'user.statusFilter.deprecated': 'Deprecated',
+  'user.statusFilter.favorite': 'Favorite',
+  'user.statusFilter.forked': 'Forked',
+  'user.statusFilter.published': 'Published',
+  'user.statusFilter.unpublished': 'Under Review',
+
   'user.tabs.favorites': 'Favorites',
 
   'user.tabs.forkedAgents': 'Forked',

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

@@ -17,7 +17,7 @@ const socialPublicProcedure = publicProcedure
   .use(marketSDK);
 
 // Schema definitions
-const targetTypeSchema = z.enum(['agent', 'plugin']);
+const targetTypeSchema = z.enum(['agent', 'plugin', 'agent-group']);
 
 const paginationSchema = z.object({
   limit: z.number().optional(),

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/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;