@lobehub/lobehub 2.0.0-next.250 → 2.0.0-next.252

package/packages/memory-user-memory/src/prompts/layers/preference.ts

@@ -1,164 +1,164 @@
 export const preferencePrompt = [
-  "You are a focused memory extraction assistant specialized in the **preference**",
-  "layer. When extracting, ensure all the content is using {{ language }}.",
-  "",
-  "\\<user_context>",
-  "Current user: {{ username }}",
-  "Session date: {{ sessionDate }}",
-  "Available memory categories: {{ availableCategories }}",
-  "Target layer: preference",
-  "\\</user_context>",
-  "",
-  "## Retrieved Memory (Top {{ topK }})",
-  "",
-  "Use the list below to de-duplicate and decide whether you need to extract",
-  "anything. Do not copy these verbatim; use them for comparison.",
-  "",
-  "{{ retrievedContext }}",
-  "",
-  "## Your Task",
-  "",
-  "Extract **ALL** preference layer information from the conversation. Capture user",
-  "choices, directives, likes, dislikes, and behavioral guidance for the assistant.",
-  "",
-  "**CRITICAL**: Return an **array** of memory items. One conversation can include",
-  "more than one preference memory. Extract each as a separate item.",
-  "",
-  "Before extracting, review the retrieved similar memories first (top {{ topK }}",
-  "items shown below). Extract items that are NEW or MATERIALLY UPDATED compared to",
-  "retrieved entries. Avoid duplicates or near-duplicates. Prefer manual merging",
-  "over duplication: if content is already covered with no meaningful new detail,",
-  "do not extract it again.",
-  "",
-  "## Name Handling and Neutrality",
-  "",
-  "- Always refer to the user with the exact placeholder token \"User\". Do not",
+  'You are a focused memory extraction assistant specialized in the **preference**',
+  'layer. When extracting, ensure all the content is using {{ language }}.',
+  '',
+  '\\<user_context>',
+  'Current user: {{ username }}',
+  'Session date: {{ sessionDate }}',
+  'Available memory categories: {{ availableCategories }}',
+  'Target layer: preference',
+  '\\</user_context>',
+  '',
+  '## Retrieved Memory (Top {{ topK }})',
+  '',
+  'Use the list below to de-duplicate and decide whether you need to extract',
+  'anything. Do not copy these verbatim; use them for comparison.',
+  '',
+  '{{ retrievedContext }}',
+  '',
+  '## Your Task',
+  '',
+  'Extract **ALL** preference layer information from the conversation. Capture user',
+  'choices, directives, likes, dislikes, and behavioral guidance for the assistant.',
+  '',
+  '**CRITICAL**: Return an **array** of memory items. One conversation can include',
+  'more than one preference memory. Extract each as a separate item.',
+  '',
+  'Before extracting, review the retrieved similar memories first (top {{ topK }}',
+  'items shown below). Extract items that are NEW or MATERIALLY UPDATED compared to',
+  'retrieved entries. Avoid duplicates or near-duplicates. Prefer manual merging',
+  'over duplication: if content is already covered with no meaningful new detail,',
+  'do not extract it again.',
+  '',
+  '## Name Handling and Neutrality',
+  '',
+  '- Always refer to the user with the exact placeholder token "User". Do not',
   "  infer, invent, or translate the user's real name.",
-  "- Do not assign gendered terms or honorifics (e.g., \"先生 / 女士\",",
-  "  \"Mr./Ms.\"). Keep all references neutral during extraction.",
-  "",
-  "## Preference vs. Requirement",
-  "",
-  "- Extract durable, reusable user preferences that guide future assistant",
-  "  behavior.",
-  "- Do NOT extract one-off task requirements, step-by-step implementation plans,",
-  "  or transient instructions tied to the current task or message.",
-  "- Do NOT infer a language preference from the conversation language alone.",
-  "  Extract language preferences when the user explicitly states a persistent",
-  "  request (e.g., \"Always reply in Chinese\").",
-  "",
-  "## Output Format",
-  "",
-  "Return structured JSON data according to the provided schema. The output must",
-  "pass validation against a strict schema including:",
-  "",
-  "- Basic fields: title, summary, details, memoryLayer, memoryType,",
-  "  memoryCategory",
-  "- Preference-specific fields in withPreference: extractedLabels,",
-  "  extractedScopes (array of strings), originContext (trigger, scenario, actor,",
-  "  applicableWhen, notApplicableWhen), appContext (app, surface, feature,",
-  "  route), conclusionDirectives, type, suggestions, scorePriority",
-  "",
-  "`extractedScopes` is a simple string array describing the preference scope.",
-  "",
-  "## Memory Formatting Guidelines",
-  "",
-  "> CRITICAL REQUIREMENT: ALL MEMORY ITEMS MUST BE SELF-CONTAINED",
-  "",
-  "Every memory item you create must be standalone and understandable without",
-  "extra context:",
-  "",
-  "✓ **Required Elements:**",
-  "",
-  "- Use full names and specific subjects—NEVER use pronouns",
-  "  (he/she/they/it/this/that)",
-  "- Include specific names, places, dates, and complete context",
-  "- Preserve the original language from user input—do not translate",
-  "- Capture relevant details, emotions, and outcomes",
-  "- Ensure each item is comprehensible independently",
-  "",
-  "✓ **Good Examples:**",
-  "",
-  "- \"When providing technical answers, {{ username }} prefers concise bullet",
-  "  points and TypeScript code examples; avoid lengthy prose.\"",
-  "- \"For daily planning, {{ username }} wants reminders at 08:00 local time and a",
-  "  single summary message at 21:00 describing completed tasks.\"",
-  "",
-  "✗ **Bad Examples:**",
-  "",
-  "- \"She went to a support group\" → Missing: who, when, what happened, emotional",
-  "  outcome",
-  "- \"They felt happy\" → Missing: who, context, cause of emotion",
-  "- \"The discussion was helpful\" → Missing: participants, topic, specific value",
-  "  gained",
-  "- \"This made them realize something important\" → Vague pronouns and undefined",
-  "  referents",
-  "",
-  "## Layer-Specific Extraction Guidance",
-  "",
-  "Capture actionable rules that guide assistant behavior and decision-making.",
-  "Define `extractedScopes` to clarify applicability (time ranges, contexts,",
-  "channels). Use `originContext` and `appContext` to describe when and where the",
-  "preference applies. Write `conclusionDirectives` as self-contained instructions",
+  '- Do not assign gendered terms or honorifics (e.g., "先生 / 女士",',
+  '  "Mr./Ms."). Keep all references neutral during extraction.',
+  '',
+  '## Preference vs. Requirement',
+  '',
+  '- Extract durable, reusable user preferences that guide future assistant',
+  '  behavior.',
+  '- Do NOT extract one-off task requirements, step-by-step implementation plans,',
+  '  or transient instructions tied to the current task or message.',
+  '- Do NOT infer a language preference from the conversation language alone.',
+  '  Extract language preferences when the user explicitly states a persistent',
+  '  request (e.g., "Always reply in Chinese").',
+  '',
+  '## Output Format',
+  '',
+  'Return structured JSON data according to the provided schema. The output must',
+  'pass validation against a strict schema including:',
+  '',
+  '- Basic fields: title, summary, details, memoryLayer, memoryType,',
+  '  memoryCategory',
+  '- Preference-specific fields in withPreference: extractedLabels,',
+  '  extractedScopes (array of strings), originContext (trigger, scenario, actor,',
+  '  applicableWhen, notApplicableWhen), appContext (app, surface, feature,',
+  '  route), conclusionDirectives, type, suggestions, scorePriority',
+  '',
+  '`extractedScopes` is a simple string array describing the preference scope.',
+  '',
+  '## Memory Formatting Guidelines',
+  '',
+  '> CRITICAL REQUIREMENT: ALL MEMORY ITEMS MUST BE SELF-CONTAINED',
+  '',
+  'Every memory item you create must be standalone and understandable without',
+  'extra context:',
+  '',
+  '✓ **Required Elements:**',
+  '',
+  '- Use full names and specific subjects—NEVER use pronouns',
+  '  (he/she/they/it/this/that)',
+  '- Include specific names, places, dates, and complete context',
+  '- Preserve the original language from user input—do not translate',
+  '- Capture relevant details, emotions, and outcomes',
+  '- Ensure each item is comprehensible independently',
+  '',
+  '✓ **Good Examples:**',
+  '',
+  '- "When providing technical answers, {{ username }} prefers concise bullet',
+  '  points and TypeScript code examples; avoid lengthy prose."',
+  '- "For daily planning, {{ username }} wants reminders at 08:00 local time and a',
+  '  single summary message at 21:00 describing completed tasks."',
+  '',
+  '✗ **Bad Examples:**',
+  '',
+  '- "She went to a support group" → Missing: who, when, what happened, emotional',
+  '  outcome',
+  '- "They felt happy" → Missing: who, context, cause of emotion',
+  '- "The discussion was helpful" → Missing: participants, topic, specific value',
+  '  gained',
+  '- "This made them realize something important" → Vague pronouns and undefined',
+  '  referents',
+  '',
+  '## Layer-Specific Extraction Guidance',
+  '',
+  'Capture actionable rules that guide assistant behavior and decision-making.',
+  'Define `extractedScopes` to clarify applicability (time ranges, contexts,',
+  'channels). Use `originContext` and `appContext` to describe when and where the',
+  'preference applies. Write `conclusionDirectives` as self-contained instructions',
   "from the user's perspective. Use `scorePriority` to mark preferences that should",
-  "override conflicting defaults. Provide `suggestions` for helpful follow-up",
-  "actions. Avoid implementation details; focus on what the assistant should do.",
-  "",
-  "Examples of preference information:",
-  "",
-  "- \"{{ username }} prefers concise, bullet-point responses over long paragraphs",
-  "  when asking technical questions\"",
-  "- \"{{ username }} likes to receive code examples in TypeScript rather than",
-  "  JavaScript\"",
-  "- \"{{ username }} prefers morning workouts at 06:00 and dislikes exercising in",
-  "  the evening\"",
-  "",
-  "Not preferences (do not extract):",
-  "",
-  "- One-off task instructions (e.g., \"帮我把这段话翻译成英文\")",
-  "- Implementation details or step-by-step plans (e.g.,",
-  "  \"先抓取 API，然后解析 JSON…\")",
-  "- Language used in the conversation unless explicitly stated as a persistent",
-  "  preference",
-  "",
-  "## Memory Type Classifications",
-  "",
-  "Choose the appropriate memoryType:",
-  "",
-  "- **activity**: Detailed conversations, interactions, and events with full",
-  "  contextual narrative",
-  "- **event**: Specific time-bound occurrences (dates, milestones, appointments,",
-  "  meetings)",
-  "- **fact**: Factual information, data points, and verifiable knowledge",
-  "- **preference**: User choices, likes, dislikes, and behavioral preferences",
-  "- **context**: Background information, situational details, environmental",
-  "  factors",
-  "- **location**: Geographic information, places, and spatial context",
-  "- **people**: Information about individuals and their relationships",
-  "- **topic**: Subject matter, domains of interest, and knowledge areas",
-  "- **technology**: Tools, platforms, software, and technical systems",
-  "- **other**: Miscellaneous information not fitting other categories",
-  "",
-  "## Security Considerations",
-  "",
-  "**NEVER extract or store sensitive information:**",
-  "",
-  "- Passwords, PINs, or authentication credentials",
-  "- API keys, tokens, or secret keys",
-  "- Financial data (credit cards, bank accounts, SSN)",
-  "- Medical records or protected health information",
-  "- Private encryption keys or certificates",
-  "",
-  "---",
-  "",
-  "## Final Instructions",
-  "",
-  "1. Analyze the conversation for preference layer information",
-  "2. Extract each distinct preference memory as a separate item",
-  "3. Ensure all memories are self-contained (no pronouns, complete context)",
-  "4. Return a JSON array conforming to the schema above",
-  "5. Return `[]` if you find no preference memories",
-  "6. No matter what the language of the retrieved language is, always use {{ language }} for output",
-  "",
-  "Respond with valid JSON without commentary.",
+  'override conflicting defaults. Provide `suggestions` for helpful follow-up',
+  'actions. Avoid implementation details; focus on what the assistant should do.',
+  '',
+  'Examples of preference information:',
+  '',
+  '- "{{ username }} prefers concise, bullet-point responses over long paragraphs',
+  '  when asking technical questions"',
+  '- "{{ username }} likes to receive code examples in TypeScript rather than',
+  '  JavaScript"',
+  '- "{{ username }} prefers morning workouts at 06:00 and dislikes exercising in',
+  '  the evening"',
+  '',
+  'Not preferences (do not extract):',
+  '',
+  '- One-off task instructions (e.g., "帮我把这段话翻译成英文")',
+  '- Implementation details or step-by-step plans (e.g.,',
+  '  "先抓取 API，然后解析 JSON…")',
+  '- Language used in the conversation unless explicitly stated as a persistent',
+  '  preference',
+  '',
+  '## Memory Type Classifications',
+  '',
+  'Choose the appropriate memoryType:',
+  '',
+  '- **activity**: Detailed conversations, interactions, and events with full',
+  '  contextual narrative',
+  '- **event**: Specific time-bound occurrences (dates, milestones, appointments,',
+  '  meetings)',
+  '- **fact**: Factual information, data points, and verifiable knowledge',
+  '- **preference**: User choices, likes, dislikes, and behavioral preferences',
+  '- **context**: Background information, situational details, environmental',
+  '  factors',
+  '- **location**: Geographic information, places, and spatial context',
+  '- **people**: Information about individuals and their relationships',
+  '- **topic**: Subject matter, domains of interest, and knowledge areas',
+  '- **technology**: Tools, platforms, software, and technical systems',
+  '- **other**: Miscellaneous information not fitting other categories',
+  '',
+  '## Security Considerations',
+  '',
+  '**NEVER extract or store sensitive information:**',
+  '',
+  '- Passwords, PINs, or authentication credentials',
+  '- API keys, tokens, or secret keys',
+  '- Financial data (credit cards, bank accounts, SSN)',
+  '- Medical records or protected health information',
+  '- Private encryption keys or certificates',
+  '',
+  '---',
+  '',
+  '## Final Instructions',
+  '',
+  '1. Analyze the conversation for preference layer information',
+  '2. Extract each distinct preference memory as a separate item',
+  '3. Ensure all memories are self-contained (no pronouns, complete context)',
+  '4. Return a JSON array conforming to the schema above',
+  '5. Return `[]` if you find no preference memories',
+  '6. No matter what the language of the retrieved language is, always use {{ language }} for output',
+  '',
+  'Respond with valid JSON without commentary.',
 ].join('\n');

package/packages/memory-user-memory/src/services/extractExecutor.ts

@@ -8,6 +8,7 @@ import {
   layersCallsCounter,
   tracer,
 } from '@lobechat/observability-otel/modules/memory-user-memory';
+import { attributesCommon } from '@lobechat/observability-otel/node';
 import { LayersEnum } from '@lobechat/types';
 
 import {
@@ -20,16 +21,15 @@ import {
 import {
   BaseExtractorDependencies,
   ExtractorOptions,
+  ExtractorRunOptions,
   GatekeeperDecision,
+  GatekeeperOptions,
   MemoryExtractionAgent,
   MemoryExtractionJob,
   MemoryExtractionLLMConfig,
   MemoryExtractionLayerOutputs,
   MemoryExtractionResult,
-  GatekeeperOptions,
-  ExtractorRunOptions,
 } from '../types';
-import { attributesCommon } from '@lobechat/observability-otel/node';
 
 const LAYER_ORDER: LayersEnum[] = [
   'identity' as LayersEnum,
@@ -60,10 +60,10 @@ export interface MemoryExtractionServiceOptions {
 }
 
 export interface MemoryExtractionLayerOutputTypes {
-  [LayersEnum.Context]: Awaited<ReturnType<ContextExtractor['structuredCall']>>
-  [LayersEnum.Experience]: Awaited<ReturnType<ExperienceExtractor['structuredCall']>>
-  [LayersEnum.Preference]: Awaited<ReturnType<PreferenceExtractor['structuredCall']>>
-  [LayersEnum.Identity]: Awaited<ReturnType<IdentityExtractor['structuredCall']>>
+  [LayersEnum.Context]: Awaited<ReturnType<ContextExtractor['structuredCall']>>;
+  [LayersEnum.Experience]: Awaited<ReturnType<ExperienceExtractor['structuredCall']>>;
+  [LayersEnum.Preference]: Awaited<ReturnType<PreferenceExtractor['structuredCall']>>;
+  [LayersEnum.Identity]: Awaited<ReturnType<IdentityExtractor['structuredCall']>>;
 }
 
 export type MemoryExtractionLayerOutputType = {
@@ -216,7 +216,11 @@ export class MemoryExtractionService<RO> {
       const processedLayersCount = {
         context: outputs.context?.data ? outputs.context?.data?.memories?.length : 0,
         experience: outputs.experience?.data ? outputs.experience?.data?.memories?.length : 0,
-        identity: outputs.identity?.data ? (outputs.identity?.data?.add?.length || 0) + (outputs.identity?.data?.update?.length || 0) + (outputs.identity?.data?.remove?.length || 0) : 0,
+        identity: outputs.identity?.data
+          ? (outputs.identity?.data?.add?.length || 0) +
+            (outputs.identity?.data?.update?.length || 0) +
+            (outputs.identity?.data?.remove?.length || 0)
+          : 0,
         preference: outputs.preference?.data ? outputs.preference?.data?.memories?.length : 0,
       };
       const processedErrorsCount = {
@@ -224,7 +228,7 @@ export class MemoryExtractionService<RO> {
         experience: outputs.experience?.error ? 1 : 0,
         identity: outputs.identity?.error ? 1 : 0,
         preference: outputs.preference?.error ? 1 : 0,
-      }
+      };
 
       const processedCount = Object.values(processedLayersCount).reduce((a, b) => a + b, 0);
 
@@ -334,9 +338,7 @@ export class MemoryExtractionService<RO> {
 
     const setLayerOutput = (
       layer: LayersEnum,
-      result:
-        | { data: MemoryExtractionLayerOutputType }
-        | { error: unknown },
+      result: { data: MemoryExtractionLayerOutputType } | { error: unknown },
     ) => {
       switch (layer) {
         case LayersEnum.Context: {
@@ -370,24 +372,25 @@ export class MemoryExtractionService<RO> {
     };
 
     await Promise.all(
-      ([
-        LayersEnum.Context,
-        LayersEnum.Experience,
-        LayersEnum.Preference,
-        LayersEnum.Identity,
-      ] as LayersEnum[])
-        .map(async (layer) => {
-          if (!layers.includes(layer)) {
-            return
-          }
-
-          try {
-            const result = await this.runLayer(job, layer, options);
-            setLayerOutput(layer, { data: result });
-          } catch (error) {
-            setLayerOutput(layer, { error });
-          }
-        }),
+      (
+        [
+          LayersEnum.Context,
+          LayersEnum.Experience,
+          LayersEnum.Preference,
+          LayersEnum.Identity,
+        ] as LayersEnum[]
+      ).map(async (layer) => {
+        if (!layers.includes(layer)) {
+          return;
+        }
+
+        try {
+          const result = await this.runLayer(job, layer, options);
+          setLayerOutput(layer, { data: result });
+        } catch (error) {
+          setLayerOutput(layer, { error });
+        }
+      }),
     );
 
     return outputs as MemoryExtractionLayerOutputs;

package/packages/memory-user-memory/src/types.ts

@@ -30,12 +30,14 @@ export interface ExtractorOptions extends ExtractorTemplateProps {
   additionalMessages?: OpenAIChatMessage[];
   callbacks?: {
     onExtractError?: (agent: MemoryExtractionAgent, error: unknown) => Promise<void> | void;
-    onExtractRequest?: (agent: MemoryExtractionAgent, request: GenerateObjectPayload) =>
-      | Promise<void>
-      | void;
-    onExtractResponse?: <TOutput>(agent: MemoryExtractionAgent, response: TOutput) =>
-      | Promise<void>
-      | void;
+    onExtractRequest?: (
+      agent: MemoryExtractionAgent,
+      request: GenerateObjectPayload,
+    ) => Promise<void> | void;
+    onExtractResponse?: <TOutput>(
+      agent: MemoryExtractionAgent,
+      response: TOutput,
+    ) => Promise<void> | void;
   };
   messageIds?: string[];
   sourceId?: string;
@@ -133,11 +135,11 @@ export type MemoryExtractionLayerOutputs = Partial<{
   identity: {
     data?: Awaited<ReturnType<IdentityExtractor['structuredCall']>>;
     error?: unknown;
-  }
+  };
   preference: {
     data?: Awaited<ReturnType<PreferenceExtractor['structuredCall']>>;
     error?: unknown;
-  }
+  };
 }>;
 
 export interface GatekeeperDecision {

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

@@ -18,7 +18,7 @@ export enum McpCategory {
   Tools = 'tools',
   TravelTransport = 'travel-transport',
   Weather = 'weather',
-  WebSearch = 'web-search',
+  WebSearch = 'web-search'
 }
 
 export enum McpSorts {

package/packages/types/src/topic/topic.ts

@@ -34,6 +34,10 @@ export interface TopicUserMemoryExtractRunState {
 }
 
 export interface ChatTopicMetadata {
+  /**
+   * Cron job ID that triggered this topic creation (if created by scheduled task)
+   */
+  cronJobId?: string;
   model?: string;
   provider?: string;
   userMemoryExtractRunState?: TopicUserMemoryExtractRunState;
@@ -57,6 +61,7 @@ export interface ChatTopic extends Omit<BaseDataModel, 'meta'> {
   metadata?: ChatTopicMetadata;
   sessionId?: string;
   title: string;
+  trigger?: string | null;
 }
 
 export type ChatTopicMap = Record<string, ChatTopic>;
@@ -106,6 +111,10 @@ export interface CreateTopicParams {
 export interface QueryTopicParams {
   agentId?: string | null;
   current?: number;
+  /**
+   * Exclude topics by trigger types (e.g. ['cron'])
+   */
+  excludeTriggers?: string[];
   /**
    * Group ID to filter topics by
    */

package/src/app/[variants]/(main)/chat/_layout/Sidebar/Body.tsx

@@ -2,15 +2,18 @@ import { Accordion, Flexbox } from '@lobehub/ui';
 import React, { memo } from 'react';
 
 import Topic from './Topic';
+import CronTopicList from './Topic/CronTopicList';
 
 export enum ChatSidebarKey {
-  Topic = 'topic',
+  CronTopics = 'cronTopics',
+  Topic = 'topic'
 }
 
 const Body = memo(() => {
   return (
     <Flexbox paddingInline={4}>
       <Accordion defaultExpandedKeys={[ChatSidebarKey.Topic]} gap={8}>
+        <CronTopicList itemKey={ChatSidebarKey.CronTopics} />
         <Topic itemKey={ChatSidebarKey.Topic} />
       </Accordion>
     </Flexbox>

package/src/app/[variants]/(main)/chat/_layout/Sidebar/Topic/CronTopicList/CronTopicGroup.tsx

@@ -0,0 +1,74 @@
+'use client';
+
+import { Flexbox, Icon, Text } from '@lobehub/ui';
+import { cssVar } from 'antd-style';
+import { Clock } from 'lucide-react';
+import { type MouseEvent, memo, useCallback } from 'react';
+import { useParams } from 'react-router-dom';
+
+import { useRouter } from '@/app/[variants]/(main)/hooks/useRouter';
+import type { AgentCronJob } from '@/database/schemas/agentCronJob';
+
+import CronTopicItem from './CronTopicItem';
+
+interface CronTopicGroupProps {
+  cronJob: AgentCronJob | null;
+  cronJobId: string;
+  topics: Array<{
+    createdAt: Date | string;
+    favorite?: boolean | null;
+    historySummary?: string | null;
+    id: string;
+    metadata?: any;
+    title?: string | null;
+    trigger?: string | null;
+    updatedAt: Date | string;
+  }>;
+}
+
+const CronTopicGroup = memo<CronTopicGroupProps>(({ cronJob, cronJobId, topics }) => {
+  const { aid } = useParams<{ aid?: string }>();
+  const router = useRouter();
+  const handleOpenCronJob = useCallback(
+    (event: MouseEvent) => {
+      event.stopPropagation();
+      if (!aid) return;
+      router.push(`/agent/${aid}/cron/${cronJobId}`);
+    },
+    [aid, cronJobId, router],
+  );
+
+  const cronJobName = cronJob?.name || `Cron Job ${cronJobId.slice(-8)}`;
+  const isEnabled = cronJob?.enabled ?? false;
+
+  return (
+    <Flexbox gap={1}>
+      <Flexbox
+        align="center"
+        gap={6}
+        height={24}
+        horizontal
+        onClick={handleOpenCronJob}
+        paddingInline={8}
+        style={{ cursor: 'pointer', opacity: isEnabled ? 1 : 0.6, overflow: 'hidden' }}
+      >
+        <Icon icon={Clock} style={{ color: cssVar.colorTextDescription, opacity: 0.7 }} />
+        <Text ellipsis fontSize={12} style={{ flex: 1 }} type={'secondary'} weight={500}>
+          {cronJobName}
+        </Text>
+        {topics.length > 0 && (
+          <Text style={{ color: cssVar.colorTextDescription, fontSize: 11 }}>{topics.length}</Text>
+        )}
+      </Flexbox>
+      {topics.length > 0 && (
+        <Flexbox gap={1} paddingBlock={1}>
+          {topics.map((topic) => (
+            <CronTopicItem key={topic.id} topic={topic} />
+          ))}
+        </Flexbox>
+      )}
+    </Flexbox>
+  );
+});
+
+export default CronTopicGroup;