@lobehub/lobehub 2.0.0-next.251 → 2.0.0-next.253

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

@@ -0,0 +1,367 @@
+import { TRPCError } from '@trpc/server';
+import { z } from 'zod';
+
+import { AgentCronJobModel } from '@/database/models/agentCronJob';
+import {
+  type CreateAgentCronJobData,
+  type UpdateAgentCronJobData,
+  insertAgentCronJobSchema,
+  updateAgentCronJobSchema,
+} from '@/database/schemas/agentCronJob';
+import { authedProcedure, router } from '@/libs/trpc/lambda';
+import { serverDatabase } from '@/libs/trpc/lambda/middleware';
+
+const agentCronJobProcedure = authedProcedure.use(serverDatabase);
+
+const listQuerySchema = z.object({
+  agentId: z.string().optional(),
+  enabled: z.boolean().optional(),
+  limit: z.number().min(1).max(100).default(20),
+  offset: z.number().min(0).default(0),
+});
+
+const resetExecutionsSchema = z.object({
+  id: z.string(),
+  newMaxExecutions: z.number().min(1).max(10_000).optional(),
+});
+
+const batchUpdateStatusSchema = z.object({
+  enabled: z.boolean(),
+  ids: z.array(z.string()),
+});
+
+// Create input schema for tRPC that omits server-managed fields
+const createAgentCronJobInputSchema = insertAgentCronJobSchema.omit({
+  userId: true, // Provided by authentication context
+});
+
+/**
+ * Agent Cron Job tRPC Router
+ *
+ * Provides type-safe API for managing agent scheduled tasks
+ */
+export const agentCronJobRouter = router({
+  /**
+   * Batch update status (enable/disable) for multiple jobs
+   */
+  batchUpdateStatus: agentCronJobProcedure
+    .input(batchUpdateStatusSchema)
+    .mutation(async ({ input, ctx }) => {
+      const { userId, serverDB: db } = ctx;
+      const { ids, enabled } = input;
+
+      try {
+        const cronJobModel = new AgentCronJobModel(db, userId);
+        const updatedCount = await cronJobModel.batchUpdateStatus(ids, enabled);
+
+        return {
+          data: { updatedCount },
+          message: `${updatedCount} cron jobs ${enabled ? 'enabled' : 'disabled'} successfully`,
+          success: true,
+        };
+      } catch (error) {
+        console.error('[agentCronJob:batchUpdateStatus]', error);
+        throw new TRPCError({
+          cause: error,
+          code: 'INTERNAL_SERVER_ERROR',
+          message: 'Failed to update cron job statuses',
+        });
+      }
+    }),
+
+  /**
+   * Create a new cron job
+   */
+  create: agentCronJobProcedure
+    .input(createAgentCronJobInputSchema)
+    .mutation(async ({ input, ctx }) => {
+      const { userId, serverDB: db } = ctx;
+
+      try {
+        const cronJobModel = new AgentCronJobModel(db, userId);
+        // Add userId to the input data since it's provided by authentication context
+        const cronJobData = { ...input, userId };
+        const cronJob = await cronJobModel.create(cronJobData as CreateAgentCronJobData);
+
+        return {
+          data: cronJob,
+          message: 'Cron job created successfully',
+          success: true,
+        };
+      } catch (error) {
+        console.error('[agentCronJob:create]', error);
+        throw new TRPCError({
+          cause: error,
+          code: 'INTERNAL_SERVER_ERROR',
+          message: 'Failed to create cron job',
+        });
+      }
+    }),
+
+  /**
+   * Delete a cron job
+   */
+  delete: agentCronJobProcedure
+    .input(z.object({ id: z.string() }))
+    .mutation(async ({ input, ctx }) => {
+      const { userId, serverDB: db } = ctx;
+      const { id } = input;
+
+      try {
+        const cronJobModel = new AgentCronJobModel(db, userId);
+        const deleted = await cronJobModel.delete(id);
+
+        if (!deleted) {
+          throw new TRPCError({
+            code: 'NOT_FOUND',
+            message: 'Cron job not found or access denied',
+          });
+        }
+
+        return {
+          message: 'Cron job deleted successfully',
+          success: true,
+        };
+      } catch (error) {
+        if (error instanceof TRPCError) throw error;
+
+        console.error('[agentCronJob:delete]', error);
+        throw new TRPCError({
+          cause: error,
+          code: 'INTERNAL_SERVER_ERROR',
+          message: 'Failed to delete cron job',
+        });
+      }
+    }),
+
+  /**
+   * List cron jobs by agent ID
+   */
+  findByAgent: agentCronJobProcedure
+    .input(z.object({ agentId: z.string() }))
+    .query(async ({ input, ctx }) => {
+      const { userId, serverDB: db } = ctx;
+      const { agentId } = input;
+
+      try {
+        const cronJobModel = new AgentCronJobModel(db, userId);
+        const cronJobs = await cronJobModel.findByAgentId(agentId);
+
+        return {
+          data: cronJobs,
+          success: true,
+        };
+      } catch (error) {
+        console.error('[agentCronJob:findByAgent]', error);
+        throw new TRPCError({
+          cause: error,
+          code: 'INTERNAL_SERVER_ERROR',
+          message: 'Failed to fetch agent cron jobs',
+        });
+      }
+    }),
+
+  /**
+   * Get a single cron job by ID
+   */
+  findById: agentCronJobProcedure
+    .input(z.object({ id: z.string() }))
+    .query(async ({ input, ctx }) => {
+      const { userId, serverDB: db } = ctx;
+      const { id } = input;
+
+      try {
+        const cronJobModel = new AgentCronJobModel(db, userId);
+        const cronJob = await cronJobModel.findById(id);
+
+        if (!cronJob) {
+          throw new TRPCError({
+            code: 'NOT_FOUND',
+            message: 'Cron job not found',
+          });
+        }
+
+        return {
+          data: cronJob,
+          success: true,
+        };
+      } catch (error) {
+        if (error instanceof TRPCError) throw error;
+
+        console.error('[agentCronJob:findById]', error);
+        throw new TRPCError({
+          cause: error,
+          code: 'INTERNAL_SERVER_ERROR',
+          message: 'Failed to fetch cron job',
+        });
+      }
+    }),
+
+  /**
+   * Get jobs that are near depletion (for warnings)
+   */
+  getNearDepletion: agentCronJobProcedure
+    .input(z.object({ threshold: z.number().min(1).max(20).default(5) }))
+    .query(async ({ input, ctx }) => {
+      const { userId, serverDB: db } = ctx;
+      const { threshold } = input;
+
+      try {
+        const cronJobModel = new AgentCronJobModel(db, userId);
+        const jobs = await cronJobModel.getTasksNearDepletion(threshold);
+
+        return {
+          data: jobs,
+          success: true,
+        };
+      } catch (error) {
+        console.error('[agentCronJob:getNearDepletion]', error);
+        throw new TRPCError({
+          cause: error,
+          code: 'INTERNAL_SERVER_ERROR',
+          message: 'Failed to fetch near depletion jobs',
+        });
+      }
+    }),
+
+  /**
+   * Get execution statistics for user's cron jobs
+   */
+  getStats: agentCronJobProcedure.query(async ({ ctx }) => {
+    const { userId, serverDB: db } = ctx;
+
+    try {
+      const cronJobModel = new AgentCronJobModel(db, userId);
+      const stats = await cronJobModel.getExecutionStats();
+
+      return {
+        data: stats,
+        success: true,
+      };
+    } catch (error) {
+      console.error('[agentCronJob:getStats]', error);
+      throw new TRPCError({
+        cause: error,
+        code: 'INTERNAL_SERVER_ERROR',
+        message: 'Failed to fetch execution statistics',
+      });
+    }
+  }),
+
+  /**
+   * List cron jobs with filtering and pagination
+   */
+  list: agentCronJobProcedure.input(listQuerySchema).query(async ({ input, ctx }) => {
+    const { userId, serverDB: db } = ctx;
+    const { agentId, enabled, limit, offset } = input;
+
+    try {
+      const cronJobModel = new AgentCronJobModel(db, userId);
+      const result = await cronJobModel.findWithPagination({
+        agentId,
+        enabled,
+        limit,
+        offset,
+      });
+
+      return {
+        data: result.jobs,
+        pagination: {
+          hasMore: offset + limit < result.total,
+          limit,
+          offset,
+          total: result.total,
+        },
+        success: true,
+      };
+    } catch (error) {
+      console.error('[agentCronJob:list]', error);
+      throw new TRPCError({
+        cause: error,
+        code: 'INTERNAL_SERVER_ERROR',
+        message: 'Failed to fetch cron jobs',
+      });
+    }
+  }),
+
+  /**
+   * Reset execution counts for a cron job
+   */
+  resetExecutions: agentCronJobProcedure
+    .input(resetExecutionsSchema)
+    .mutation(async ({ input, ctx }) => {
+      const { userId, serverDB: db } = ctx;
+      const { id, newMaxExecutions } = input;
+
+      try {
+        const cronJobModel = new AgentCronJobModel(db, userId);
+        const cronJob = await cronJobModel.resetExecutions(id, newMaxExecutions);
+
+        if (!cronJob) {
+          throw new TRPCError({
+            code: 'NOT_FOUND',
+            message: 'Cron job not found or access denied',
+          });
+        }
+
+        return {
+          data: cronJob,
+          message: 'Execution counts reset successfully',
+          success: true,
+        };
+      } catch (error) {
+        if (error instanceof TRPCError) throw error;
+
+        console.error('[agentCronJob:resetExecutions]', error);
+        throw new TRPCError({
+          cause: error,
+          code: 'INTERNAL_SERVER_ERROR',
+          message: 'Failed to reset execution counts',
+        });
+      }
+    }),
+
+  /**
+   * Update a cron job
+   */
+  update: agentCronJobProcedure
+    .input(
+      z.object({
+        data: updateAgentCronJobSchema,
+        id: z.string(),
+      }),
+    )
+    .mutation(async ({ input, ctx }) => {
+      const { userId, serverDB: db } = ctx;
+      const { id, data } = input;
+
+      try {
+        const cronJobModel = new AgentCronJobModel(db, userId);
+        const cronJob = await cronJobModel.update(id, data as UpdateAgentCronJobData);
+
+        if (!cronJob) {
+          throw new TRPCError({
+            code: 'NOT_FOUND',
+            message: 'Cron job not found or access denied',
+          });
+        }
+
+        return {
+          data: cronJob,
+          message: 'Cron job updated successfully',
+          success: true,
+        };
+      } catch (error) {
+        if (error instanceof TRPCError) throw error;
+
+        console.error('[agentCronJob:update]', error);
+        throw new TRPCError({
+          cause: error,
+          code: 'INTERNAL_SERVER_ERROR',
+          message: 'Failed to update cron job',
+        });
+      }
+    }),
+
+  // Note: testExecution moved to cloud layer since it uses AgentCronWorkflow
+});

package/src/server/routers/lambda/image/index.test.ts

@@ -2,6 +2,8 @@ import { beforeEach, describe, expect, it, vi } from 'vitest';
 
 import { AsyncTaskStatus, AsyncTaskType } from '@/types/asyncTask';
 
+import { imageRouter } from './index';
+
 // Use vi.hoisted for variables used in vi.mock factory
 const {
   mockServerDB,
@@ -79,8 +81,6 @@ vi.mock('@/utils/number', () => ({
   generateUniqueSeeds: vi.fn((count: number) => Array.from({ length: count }, (_, i) => 1000 + i)),
 }));
 
-import { imageRouter } from './index';
-
 describe('imageRouter', () => {
   const mockUserId = 'test-user-id';
   const mockAsyncCallerCreateImage = vi.fn();

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

@@ -8,6 +8,7 @@ import { topUpRouter } from '@/business/server/lambda-routers/topUp';
 import { publicProcedure, router } from '@/libs/trpc/lambda';
 
 import { agentRouter } from './agent';
+import { agentCronJobRouter } from './agentCronJob';
 import { agentGroupRouter } from './agentGroup';
 import { aiAgentRouter } from './aiAgent';
 import { aiChatRouter } from './aiChat';
@@ -46,6 +47,7 @@ import { userMemoryRouter } from './userMemory';
 
 export const lambdaRouter = router({
   agent: agentRouter,
+  agentCronJob: agentCronJobRouter,
   aiAgent: aiAgentRouter,
   aiChat: aiChatRouter,
   aiModel: aiModelRouter,

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

@@ -142,11 +142,18 @@ export const topicRouter = router({
     return ctx.topicModel.queryAll();
   }),
 
+  getCronTopicsGroupedByCronJob: topicProcedure
+    .input(z.object({ agentId: z.string() }))
+    .query(async ({ input, ctx }) => {
+      return ctx.topicModel.getCronTopicsGroupedByCronJob(input.agentId);
+    }),
+
   getTopics: topicProcedure
     .input(
       z.object({
         agentId: z.string().nullable().optional(),
         current: z.number().optional(),
+        excludeTriggers: z.array(z.string()).optional(),
         groupId: z.string().nullable().optional(),
         isInbox: z.boolean().optional(),
         pageSize: z.number().optional(),
@@ -154,11 +161,11 @@ export const topicRouter = router({
       }),
     )
     .query(async ({ input, ctx }) => {
-      const { sessionId, isInbox, groupId, ...rest } = input;
+      const { sessionId, isInbox, groupId, excludeTriggers, ...rest } = input;
 
       // If groupId is provided, query by groupId directly
       if (groupId) {
-        const result = await ctx.topicModel.query({ groupId, ...rest });
+        const result = await ctx.topicModel.query({ excludeTriggers, groupId, ...rest });
         return { items: result.items, total: result.total };
       }
 
@@ -168,7 +175,12 @@ export const topicRouter = router({
         effectiveAgentId = await resolveAgentIdFromSession(sessionId, ctx.serverDB, ctx.userId);
       }
 
-      const result = await ctx.topicModel.query({ ...rest, agentId: effectiveAgentId, isInbox });
+      const result = await ctx.topicModel.query({
+        ...rest,
+        agentId: effectiveAgentId,
+        excludeTriggers,
+        isInbox,
+      });
 
       // Runtime migration: backfill agentId for ALL legacy topics and messages under this agent
       const runMigration = async () => {

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

@@ -33,8 +33,12 @@ const log = debug('lobe-server:ai-agent-service');
  * This extends the public ExecAgentParams with server-side only options
  */
 interface InternalExecAgentParams extends ExecAgentParams {
+  /** Cron job ID that triggered this execution (if trigger is 'cron') */
+  cronJobId?: string;
   /** Step lifecycle callbacks for operation tracking (server-side only) */
   stepCallbacks?: StepLifecycleCallbacks;
+  /** Topic creation trigger source ('cron' | 'chat' | 'api') */
+  trigger?: string;
 }
 
 /**
@@ -88,6 +92,8 @@ export class AiAgentService {
       autoStart = true,
       existingMessageIds = [],
       stepCallbacks,
+      trigger,
+      cronJobId,
     } = params;
 
     // Validate that either agentId or slug is provided
@@ -114,12 +120,22 @@ export class AiAgentService {
     // 2. Handle topic creation: if no topicId provided, create a new topic; otherwise reuse existing
     let topicId = appContext?.topicId;
     if (!topicId) {
+      // Prepare metadata with cronJobId if provided
+      const metadata = cronJobId ? { cronJobId } : undefined;
+
       const newTopic = await this.topicModel.create({
         agentId: resolvedAgentId,
+        metadata,
         title: prompt.slice(0, 50) + (prompt.length > 50 ? '...' : ''),
+        trigger,
       });
       topicId = newTopic.id;
-      log('execAgent: created new topic %s', topicId);
+      log(
+        'execAgent: created new topic %s with trigger %s, cronJobId %s',
+        topicId,
+        trigger || 'default',
+        cronJobId || 'none',
+      );
     } else {
       log('execAgent: reusing existing topic %s', topicId);
     }
@@ -397,6 +413,7 @@ export class AiAgentService {
         groupId,
         messages: newTopic?.topicMessageIds,
         title: topicTitle,
+        // Note: execGroupAgent doesn't have trigger param yet, defaults to null
       });
       topicId = topicItem.id;
       isCreateNewTopic = true;

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