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

package/src/server/services/memory/userMemory/extract.ts

@@ -4,21 +4,20 @@ import {
 } from '@lobechat/const';
 import { messages, topics } from '@lobechat/database/schemas';
 import {
+  BenchmarkLocomoContextProvider,
   LobeChatTopicContextProvider,
   LobeChatTopicResultRecorder,
   MemoryExtractionService,
   RetrievalUserMemoryContextProvider,
   RetrievalUserMemoryIdentitiesProvider,
-  BenchmarkLocomoContextProvider,
 } from '@lobechat/memory-user-memory';
 import type {
+  BenchmarkLocomoPart,
   MemoryExtractionAgent,
   MemoryExtractionJob,
   MemoryExtractionResult,
-  BenchmarkLocomoPart,
   PersistedMemoryResult,
 } from '@lobechat/memory-user-memory';
-import { UserMemorySourceBenchmarkLoCoMoModel } from '@/database/models/userMemory/sources/benchmarkLoCoMo';
 import { ModelRuntime } from '@lobechat/model-runtime';
 import type {
   Embeddings,
@@ -45,6 +44,7 @@ import type {
   MemoryExtractionTracePayload,
 } from '@lobechat/types';
 import { Client } from '@upstash/workflow';
+import debug from 'debug';
 import { and, asc, eq, inArray } from 'drizzle-orm';
 import { join } from 'pathe';
 import { z } from 'zod';
@@ -54,6 +54,7 @@ import { TopicModel } from '@/database/models/topic';
 import type { ListUsersForMemoryExtractorCursor } from '@/database/models/user';
 import { UserModel } from '@/database/models/user';
 import { UserMemoryModel } from '@/database/models/userMemory';
+import { UserMemorySourceBenchmarkLoCoMoModel } from '@/database/models/userMemory/sources/benchmarkLoCoMo';
 import { getServerDB } from '@/database/server';
 import { getServerGlobalConfig } from '@/server/globalConfig';
 import {
@@ -64,9 +65,13 @@ import { KeyVaultsGateKeeper } from '@/server/modules/KeyVaultsEncrypt';
 import { S3 } from '@/server/modules/S3';
 import type { GlobalMemoryLayer } from '@/types/serverConfig';
 import type { UserKeyVaults } from '@/types/user/settings';
-import { LayersEnum, type MergeStrategyEnum, TypesEnum, MemorySourceType } from '@/types/userMemory';
+import {
+  LayersEnum,
+  MemorySourceType,
+  type MergeStrategyEnum,
+  TypesEnum,
+} from '@/types/userMemory';
 import { encodeAsync } from '@/utils/tokenizer';
-import debug from 'debug';
 
 const SOURCE_ALIAS_MAP: Record<string, MemorySourceType> = {
   benchmark_locomo: MemorySourceType.BenchmarkLocomo,
@@ -913,7 +918,10 @@ export class MemoryExtractionExecutor {
     };
   }
 
-  async listUserMemoryIdentities(job: MemoryExtractionJob, userId: string): Promise<IdentityMemoryDetail[]> {
+  async listUserMemoryIdentities(
+    job: MemoryExtractionJob,
+    userId: string,
+  ): Promise<IdentityMemoryDetail[]> {
     const db = await this.db;
     const userMemoryModel = new UserMemoryModel(db, userId);
 

package/src/services/agentCronJob.ts

@@ -0,0 +1,95 @@
+import type {
+  CreateAgentCronJobData,
+  UpdateAgentCronJobData,
+} from '@/database/schemas/agentCronJob';
+import { lambdaClient } from '@/libs/trpc/client/lambda';
+
+/**
+ * Client-side service for Agent Cron Job operations
+ *
+ * This service provides a clean interface for frontend components
+ * to interact with agent cron job data using tRPC client.
+ */
+class AgentCronJobService {
+  /**
+   * Create a new cron job
+   */
+  async create(data: Omit<CreateAgentCronJobData, 'userId'>) {
+    return await lambdaClient.agentCronJob.create.mutate(data);
+  }
+
+  /**
+   * Get cron jobs for a specific agent
+   */
+  async getByAgentId(agentId: string) {
+    return await lambdaClient.agentCronJob.findByAgent.query({ agentId });
+  }
+
+  /**
+   * Get a single cron job by ID
+   */
+  async getById(id: string) {
+    return await lambdaClient.agentCronJob.findById.query({ id });
+  }
+
+  /**
+   * List cron jobs with pagination and filtering
+   */
+  async list(
+    options: {
+      agentId?: string;
+      enabled?: boolean;
+      limit?: number;
+      offset?: number;
+    } = {},
+  ) {
+    return await lambdaClient.agentCronJob.list.query(options);
+  }
+
+  /**
+   * Update a cron job
+   */
+  async update(id: string, data: UpdateAgentCronJobData) {
+    return await lambdaClient.agentCronJob.update.mutate({ data, id });
+  }
+
+  /**
+   * Delete a cron job
+   */
+  async delete(id: string) {
+    return await lambdaClient.agentCronJob.delete.mutate({ id });
+  }
+
+  /**
+   * Reset execution counts
+   */
+  async resetExecutions(id: string, newMaxExecutions?: number) {
+    return await lambdaClient.agentCronJob.resetExecutions.mutate({
+      id,
+      newMaxExecutions,
+    });
+  }
+
+  /**
+   * Get execution statistics
+   */
+  async getStats() {
+    return await lambdaClient.agentCronJob.getStats.query();
+  }
+
+  /**
+   * Get jobs near depletion
+   */
+  async getNearDepletion(threshold: number = 5) {
+    return await lambdaClient.agentCronJob.getNearDepletion.query({ threshold });
+  }
+
+  /**
+   * Batch update status (enable/disable) for multiple jobs
+   */
+  async batchUpdateStatus(ids: string[], enabled: boolean) {
+    return await lambdaClient.agentCronJob.batchUpdateStatus.mutate({ enabled, ids });
+  }
+}
+
+export const agentCronJobService = new AgentCronJobService();

package/src/services/discover.ts

@@ -1,5 +1,10 @@
 import { type CategoryItem, type CategoryListQuery, type PluginManifest } from '@lobehub/market-sdk';
-import { type CallReportRequest, type InstallReportRequest } from '@lobehub/market-types';
+import {
+  AgentEventRequest,
+  type CallReportRequest,
+  type InstallReportRequest,
+  type PluginEventRequest,
+} from '@lobehub/market-types';
 
 import { lambdaClient } from '@/libs/trpc/client';
 import { globalHelpers } from '@/store/global/helpers';
@@ -195,6 +200,22 @@ class DiscoverService {
     });
   };
 
+  reportMcpEvent = async (eventData: PluginEventRequest) => {
+    const allow = userGeneralSettingsSelectors.telemetry(useUserStore.getState());
+    if (!allow) return;
+
+    await this.injectMPToken();
+
+    const payload = cleanObject({
+      ...eventData,
+      source: eventData.source ?? 'community/mcp',
+    });
+
+    lambdaClient.market.reportMcpEvent.mutate(payload).catch((error) => {
+      console.warn('Failed to report MCP event:', error);
+    });
+  };
+
   /**
    * Report agent installation to increase install count
    */
@@ -211,6 +232,22 @@ class DiscoverService {
     });
   };
 
+  reportAgentEvent = async (eventData: AgentEventRequest) => {
+    const allow = userGeneralSettingsSelectors.telemetry(useUserStore.getState());
+    if (!allow) return;
+
+    await this.injectMPToken();
+
+    const payload = cleanObject({
+      ...eventData,
+      source: eventData.source ?? 'community/agent',
+    });
+
+    lambdaClient.market.reportAgentEvent.mutate(payload).catch((error) => {
+      console.warn('Failed to report Agent event:', error);
+    });
+  };
+
   // ============================== Models ==============================
 
   getModelCategories = async (params: CategoryListQuery = {}): Promise<CategoryItem[]> => {

package/src/services/topic/index.ts

@@ -37,6 +37,7 @@ export class TopicService {
     return lambdaClient.topic.getTopics.query({
       agentId: params.agentId,
       current: params.current,
+      excludeTriggers: params.excludeTriggers,
       groupId: params.groupId,
       isInbox: params.isInbox,
       pageSize: params.pageSize,

package/src/store/chat/slices/topic/action.ts

@@ -38,6 +38,11 @@ const n = setNamespace('t');
 
 const SWR_USE_FETCH_TOPIC = 'SWR_USE_FETCH_TOPIC';
 const SWR_USE_SEARCH_TOPIC = 'SWR_USE_SEARCH_TOPIC';
+type CronTopicsGroupWithJobInfo = {
+  cronJob: unknown;
+  cronJobId: string;
+  topics: ChatTopic[];
+};
 
 /**
  * Options for switchTopic action
@@ -91,6 +96,7 @@ export interface ChatTopicAction {
     enable: boolean,
     params: {
       agentId?: string;
+      excludeTriggers?: string[];
       groupId?: string;
       isInbox?: boolean;
       pageSize?: number;
@@ -282,7 +288,34 @@ export const chatTopic: StateCreator<
     });
   },
   favoriteTopic: async (id, favorite) => {
+    const { activeAgentId } = get();
     await get().internal_updateTopic(id, { favorite });
+
+    if (!activeAgentId) return;
+
+    await mutate(
+      ['cronTopicsWithJobInfo', activeAgentId],
+      (groups?: CronTopicsGroupWithJobInfo[]) => {
+        if (!groups) return groups;
+
+        let updated = false;
+        const next = groups.map((group) => {
+          let groupUpdated = false;
+          const topics = group.topics.map((topic) => {
+            if (topic.id !== id) return topic;
+            if (topic.favorite === favorite) return topic;
+            groupUpdated = true;
+            updated = true;
+            return { ...topic, favorite };
+          });
+
+          return groupUpdated ? { ...group, topics } : group;
+        });
+
+        return updated ? next : groups;
+      },
+      { revalidate: false },
+    );
   },
 
   updateTopicMetadata: async (id, metadata) => {
@@ -314,15 +347,28 @@ export const chatTopic: StateCreator<
   },
 
   // query
-  useFetchTopics: (enable, { agentId, groupId, pageSize: customPageSize, isInbox }) => {
+  useFetchTopics: (
+    enable,
+    { agentId, excludeTriggers, groupId, pageSize: customPageSize, isInbox },
+  ) => {
     const pageSize = customPageSize || 20;
+    const effectiveExcludeTriggers =
+      excludeTriggers && excludeTriggers.length > 0 ? excludeTriggers : undefined;
     // Use topicMapKey to generate the container key for topic data map
     const containerKey = topicMapKey({ agentId, groupId });
     const hasValidContainer = !!(groupId || agentId);
 
     return useClientDataSWRWithSync<{ items: ChatTopic[]; total: number }>(
       enable && hasValidContainer
-        ? [SWR_USE_FETCH_TOPIC, containerKey, { isInbox, pageSize }]
+        ? [
+            SWR_USE_FETCH_TOPIC,
+            containerKey,
+            {
+              isInbox,
+              pageSize,
+              ...(effectiveExcludeTriggers ? { excludeTriggers: effectiveExcludeTriggers } : {}),
+            },
+          ]
         : null,
       async () => {
         // agentId, groupId, isInbox, pageSize come from the outer scope closure
@@ -343,6 +389,7 @@ export const chatTopic: StateCreator<
         const result = await topicService.getTopics({
           agentId,
           current: 0,
+          excludeTriggers: effectiveExcludeTriggers,
           groupId,
           isInbox,
           pageSize,
@@ -374,6 +421,7 @@ export const chatTopic: StateCreator<
                 ...get().topicDataMap,
                 [containerKey]: {
                   currentPage: 0,
+                  excludeTriggers: effectiveExcludeTriggers,
                   hasMore,
                   isExpandingPageSize: false,
                   items: topics,
@@ -413,9 +461,11 @@ export const chatTopic: StateCreator<
 
     try {
       const pageSize = useGlobalStore.getState().status.topicPageSize || 20;
+      const excludeTriggers = currentData?.excludeTriggers;
       const result = await topicService.getTopics({
         agentId: activeAgentId,
         current: nextPage,
+        excludeTriggers,
         groupId: activeGroupId,
         pageSize,
       });
@@ -429,6 +479,7 @@ export const chatTopic: StateCreator<
             ...get().topicDataMap,
             [key]: {
               currentPage: nextPage,
+              excludeTriggers,
               hasMore,
               isLoadingMore: false,
               items: [...currentTopics, ...result.items],

package/src/store/chat/slices/topic/initialState.ts

@@ -5,6 +5,7 @@ import { type ChatTopic } from '@/types/topic';
  */
 export interface TopicData {
   currentPage: number;
+  excludeTriggers?: string[];
   hasMore: boolean;
   isExpandingPageSize?: boolean;
   isLoadingMore?: boolean;

package/src/store/chat/slices/topic/selectors.ts

@@ -18,27 +18,34 @@ const currentTopicData = (s: ChatStoreState): TopicData | undefined => {
 
 const currentTopics = (s: ChatStoreState): ChatTopic[] | undefined => currentTopicData(s)?.items;
 
+// Get topics without cron-triggered ones
+const currentTopicsWithoutCron = (s: ChatStoreState): ChatTopic[] | undefined => {
+  const topics = currentTopics(s);
+  if (!topics) return undefined;
+  return topics.filter((topic) => topic.trigger !== 'cron');
+};
+
 const currentActiveTopic = (s: ChatStoreState): ChatTopic | undefined => {
   return currentTopics(s)?.find((topic) => topic.id === s.activeTopicId);
 };
 const searchTopics = (s: ChatStoreState): ChatTopic[] => s.searchTopics;
 
-const displayTopics = (s: ChatStoreState): ChatTopic[] | undefined => currentTopics(s);
+const displayTopics = (s: ChatStoreState): ChatTopic[] | undefined => currentTopicsWithoutCron(s);
 
 const currentFavTopics = (s: ChatStoreState): ChatTopic[] =>
-  currentTopics(s)?.filter((s) => s.favorite) || [];
+  currentTopicsWithoutCron(s)?.filter((s) => s.favorite) || [];
 
 const currentUnFavTopics = (s: ChatStoreState): ChatTopic[] =>
-  currentTopics(s)?.filter((s) => !s.favorite) || [];
+  currentTopicsWithoutCron(s)?.filter((s) => !s.favorite) || [];
 
-const currentTopicLength = (s: ChatStoreState): number => currentTopicData(s)?.items?.length || 0;
+const currentTopicLength = (s: ChatStoreState): number => currentTopicsWithoutCron(s)?.length || 0;
 
 const currentTopicCount = (s: ChatStoreState): number => currentTopicData(s)?.total || 0;
 
 const getTopicById =
   (id: string) =>
   (s: ChatStoreState): ChatTopic | undefined =>
-    currentTopics(s)?.find((topic) => topic.id === id);
+    currentTopics(s)?.find((topic) => topic.id === id); // Don't filter here, need to access all topics by ID
 
 /**
  * Get topics by specific agentId (for AgentBuilder scenarios where agentId differs from activeAgentId)
@@ -79,7 +86,7 @@ const isSearchingTopic = (s: ChatStoreState) => s.isSearchingTopic;
 const displayTopicsForSidebar =
   (pageSize: number) =>
   (s: ChatStoreState): ChatTopic[] | undefined => {
-    const topics = currentTopics(s);
+    const topics = currentTopicsWithoutCron(s);
     if (!topics) return undefined;
 
     // Return only the first page worth of topics for sidebar
@@ -143,6 +150,7 @@ export const topicSelectors = {
   currentTopicLength,
   currentTopicWorkingDirectory,
   currentTopics,
+  currentTopicsWithoutCron,
   currentUnFavTopics,
   displayTopics,
   displayTopicsForSidebar,

package/src/store/tool/slices/mcpStore/action.test.ts

@@ -12,6 +12,37 @@ import { CheckMcpInstallResult, MCPInstallStep } from '@/types/plugins';
 
 import { useToolStore } from '../../store';
 
+vi.mock('@/libs/trpc/client', () => ({
+  asyncClient: {},
+  lambdaClient: {
+    market: {
+      getMcpCategories: { query: vi.fn() },
+      getMcpDetail: { query: vi.fn() },
+      getMcpList: { query: vi.fn() },
+      getMcpManifest: { query: vi.fn() },
+      registerClientInMarketplace: {
+        mutate: vi.fn().mockResolvedValue({
+          clientId: 'test-client-id',
+          clientSecret: 'test-client-secret',
+        }),
+      },
+      registerM2MToken: { query: vi.fn().mockResolvedValue({ success: true }) },
+      reportCall: { mutate: vi.fn().mockResolvedValue(undefined) },
+      reportMcpEvent: { mutate: vi.fn().mockResolvedValue(undefined) },
+      reportMcpInstallResult: { mutate: vi.fn().mockResolvedValue(undefined) },
+    },
+  },
+  toolsClient: {
+    market: {
+      callCloudMcpEndpoint: { mutate: vi.fn() },
+    },
+    mcp: {
+      callTool: { mutate: vi.fn() },
+      getStreamableMcpServerManifest: { query: vi.fn() },
+    },
+  },
+}));
+
 // Keep zustand mock as it's needed globally
 vi.mock('zustand/traditional');
 
@@ -61,6 +92,13 @@ const bootstrapToolStoreWithDesktop = async (isDesktopEnv: boolean) => {
 beforeEach(() => {
   vi.clearAllMocks();
 
+  vi.spyOn(discoverService, 'injectMPToken').mockResolvedValue(undefined);
+  vi.spyOn(discoverService, 'registerClient').mockResolvedValue({
+    clientId: 'test-client-id',
+    clientSecret: 'test-client-secret',
+  });
+  vi.spyOn(discoverService, 'reportMcpEvent').mockResolvedValue(undefined as any);
+
   // Reset store state
   act(() => {
     useToolStore.setState(

package/src/store/tool/slices/mcpStore/action.ts

@@ -588,6 +588,12 @@ export const createMCPPluginStoreSlice: StateCreator<
       // Calculate installation duration
       const installDurationMs = Date.now() - installStartTime;
 
+      discoverService.reportMcpEvent({
+        event: 'install',
+        identifier: plugin.identifier,
+        source: 'self',
+      })
+
       discoverService.reportMcpInstallResult({
         identifier: plugin.identifier,
         installDurationMs,
@@ -790,6 +796,12 @@ export const createMCPPluginStoreSlice: StateCreator<
         n('testMcpConnection/success'),
       );
 
+      discoverService.reportMcpEvent({
+        event: 'activate',
+        identifier: identifier,
+        source: 'self',
+      })
+
       return { manifest, success: true };
     } catch (error) {
       // Silently handle errors caused by cancellation
@@ -817,6 +829,12 @@ export const createMCPPluginStoreSlice: StateCreator<
   uninstallMCPPlugin: async (identifier) => {
     await pluginService.uninstallPlugin(identifier);
     await get().refreshPlugins();
+
+    discoverService.reportMcpEvent({
+      event: 'uninstall',
+      identifier: identifier,
+      source: 'self',
+    })
   },
 
   updateMCPInstallProgress: (identifier, progress) => {

package/src/tools/placeholders.ts

@@ -4,10 +4,7 @@ import {
   LocalSystemListFilesPlaceholder,
   LocalSystemSearchFilesPlaceholder,
 } from '@lobechat/builtin-tool-local-system/client';
-import {
-  NotebookIdentifier,
-  NotebookPlaceholders,
-} from '@lobechat/builtin-tool-notebook/client';
+import { NotebookIdentifier, NotebookPlaceholders } from '@lobechat/builtin-tool-notebook/client';
 import {
   WebBrowsingManifest,
   WebBrowsingPlaceholders,