@ainetwork/adk-provider-memory-mongodb 0.4.0 → 0.5.0

package/dist/models/workflow-template.model.d.cts

@@ -0,0 +1,60 @@
+import mongoose, { Schema, Document } from 'mongoose';
+
+declare const WorkflowTemplateObjectSchema: Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: true;
+}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    description: string;
+    title: string;
+    content: string;
+    active: boolean;
+    templateId: string;
+    variables?: any;
+}, Document<unknown, {}, mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    description: string;
+    title: string;
+    content: string;
+    active: boolean;
+    templateId: string;
+    variables?: any;
+}>, {}> & mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    description: string;
+    title: string;
+    content: string;
+    active: boolean;
+    templateId: string;
+    variables?: any;
+}> & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>;
+interface WorkflowTemplateDocument extends Document {
+    templateId: string;
+    title: string;
+    description: string;
+    active: boolean;
+    content: string;
+    variables?: Record<string, {
+        id: string;
+        label: string;
+        type: "select" | "date_range" | "date_parts" | "text" | "number";
+        options?: Array<string>;
+        resolveAt?: "creation" | "execution";
+    }>;
+}
+declare const WorkflowTemplateModel: mongoose.Model<WorkflowTemplateDocument, {}, {}, {}, Document<unknown, {}, WorkflowTemplateDocument, {}> & WorkflowTemplateDocument & Required<{
+    _id: unknown;
+}> & {
+    __v: number;
+}, any>;
+
+export { type WorkflowTemplateDocument, WorkflowTemplateModel, WorkflowTemplateObjectSchema };

package/dist/models/workflow-template.model.d.ts

@@ -0,0 +1,60 @@
+import mongoose, { Schema, Document } from 'mongoose';
+
+declare const WorkflowTemplateObjectSchema: Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: true;
+}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    description: string;
+    title: string;
+    content: string;
+    active: boolean;
+    templateId: string;
+    variables?: any;
+}, Document<unknown, {}, mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    description: string;
+    title: string;
+    content: string;
+    active: boolean;
+    templateId: string;
+    variables?: any;
+}>, {}> & mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    description: string;
+    title: string;
+    content: string;
+    active: boolean;
+    templateId: string;
+    variables?: any;
+}> & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>;
+interface WorkflowTemplateDocument extends Document {
+    templateId: string;
+    title: string;
+    description: string;
+    active: boolean;
+    content: string;
+    variables?: Record<string, {
+        id: string;
+        label: string;
+        type: "select" | "date_range" | "date_parts" | "text" | "number";
+        options?: Array<string>;
+        resolveAt?: "creation" | "execution";
+    }>;
+}
+declare const WorkflowTemplateModel: mongoose.Model<WorkflowTemplateDocument, {}, {}, {}, Document<unknown, {}, WorkflowTemplateDocument, {}> & WorkflowTemplateDocument & Required<{
+    _id: unknown;
+}> & {
+    __v: number;
+}, any>;
+
+export { type WorkflowTemplateDocument, WorkflowTemplateModel, WorkflowTemplateObjectSchema };

package/dist/models/workflow-template.model.js

@@ -0,0 +1,9 @@
+import {
+  WorkflowTemplateModel,
+  WorkflowTemplateObjectSchema
+} from "../chunk-SJ2FHHN6.js";
+export {
+  WorkflowTemplateModel,
+  WorkflowTemplateObjectSchema
+};
+//# sourceMappingURL=workflow-template.model.js.map

package/dist/models/workflow-template.model.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/implements/base.memory.ts

@@ -1,10 +1,12 @@
-import { IAgentMemory, IIntentMemory, IMemory, IThreadMemory, IWorkflowMemory } from "@ainetwork/adk/modules";
+import { IAgentMemory, IIntentMemory, IMemory, IUserWorkflowMemory, IThreadMemory, IWorkflowTemplateMemory } from "@ainetwork/adk/modules";
 import mongoose from "mongoose";
 import { loggers } from "@ainetwork/adk/utils/logger";
 import { MongoDBAgent } from "./agent.memory";
 import { MongoDBIntent } from "./intent.memory";
 import { MongoDBThread } from "./thread.memory";
-import { MongoDBWorkflow } from "./workflow.memory";
+import { MongoDBUserWorkflow } from "./user-workflow.memory";
+import { MongoDBWorkflowTemplate } from "./workflow-template.memory";
+import { MessageModel } from "../models/messages.model";
 
 export interface MongoDBMemoryConfig {
   uri: string;
@@ -15,6 +17,7 @@ export interface MongoDBMemoryConfig {
   socketTimeoutMS?: number;
   connectTimeoutMS?: number;
   operationTimeoutMS?: number; // Timeout for database operations
+  threadTTLSeconds?: number; // TTL for thread documents (in seconds). Orphaned messages are periodically cleaned up.
 }
 
 export class MongoDBMemory implements IMemory {
@@ -28,11 +31,14 @@ export class MongoDBMemory implements IMemory {
   private connectionConfig: mongoose.ConnectOptions;
   private eventListenersSetup: boolean = false;
   private operationTimeoutMS: number;
+  private threadTTLSeconds?: number;
+  private orphanCleanupTimer?: ReturnType<typeof setInterval>;
 
   private agentMemory: MongoDBAgent;
   private intentMemory: MongoDBIntent;
   private threadMemory: MongoDBThread;
-  private workflowMemory: MongoDBWorkflow;
+  private workflowTemplateMemory: MongoDBWorkflowTemplate;
+  private userWorkflowMemory: MongoDBUserWorkflow;
 
   constructor(config: string | MongoDBMemoryConfig) {
     const cfg = typeof config === 'string' ? { uri: config } : config;
@@ -41,8 +47,13 @@ export class MongoDBMemory implements IMemory {
     this.maxReconnectAttempts = cfg.maxReconnectAttempts ?? 5;
     this.reconnectInterval = cfg.reconnectInterval ?? 5000;
     this.operationTimeoutMS = cfg.operationTimeoutMS ?? 10000; // Default 10 seconds
+    if (cfg.threadTTLSeconds !== undefined && cfg.threadTTLSeconds > 0) {
+      this.threadTTLSeconds = cfg.threadTTLSeconds;
+    }
     this.connectionConfig = {
-      maxPoolSize: cfg.maxPoolSize ?? 1,
+      maxPoolSize: cfg.maxPoolSize ?? 10,
+      minPoolSize: 0,
+      maxIdleTimeMS: 30000,
       serverSelectionTimeoutMS: cfg.serverSelectionTimeoutMS ?? 30000,
       socketTimeoutMS: cfg.socketTimeoutMS ?? 45000,
       connectTimeoutMS: cfg.connectTimeoutMS ?? 30000,
@@ -73,7 +84,12 @@ export class MongoDBMemory implements IMemory {
 			this.getOperationTimeout.bind(this)
 		);
 
-		this.workflowMemory = new MongoDBWorkflow(
+		this.workflowTemplateMemory = new MongoDBWorkflowTemplate(
+			this.executeWithRetry.bind(this),
+			this.getOperationTimeout.bind(this)
+		);
+
+		this.userWorkflowMemory = new MongoDBUserWorkflow(
 			this.executeWithRetry.bind(this),
 			this.getOperationTimeout.bind(this)
 		);
@@ -91,8 +107,12 @@ export class MongoDBMemory implements IMemory {
     return this.intentMemory;
   }
 
-  public getWorkflowMemory(): IWorkflowMemory {
-    return this.workflowMemory;
+  public getWorkflowTemplateMemory(): IWorkflowTemplateMemory {
+    return this.workflowTemplateMemory;
+  }
+
+  public getUserWorkflowMemory(): IUserWorkflowMemory {
+    return this.userWorkflowMemory;
   }
 
   private setupMongooseEventListeners(): void {
@@ -134,7 +154,7 @@ export class MongoDBMemory implements IMemory {
 
     this.reconnecting = true;
 
-    while (this.reconnectAttempts < this.maxReconnectAttempts && !this.isConnected) {
+    while (this.reconnectAttempts < this.maxReconnectAttempts && !this.connected) {
       this.reconnectAttempts++;
       loggers.agent.info(
         `Attempting to reconnect to MongoDB (${this.reconnectAttempts}/${this.maxReconnectAttempts})...`
@@ -163,7 +183,7 @@ export class MongoDBMemory implements IMemory {
 
     this.reconnecting = false;
 
-    if (!this.isConnected) {
+    if (!this.connected) {
       loggers.agent.error(
         `Failed to reconnect to MongoDB after ${this.maxReconnectAttempts} attempts`
       );
@@ -179,6 +199,8 @@ export class MongoDBMemory implements IMemory {
       await mongoose.connect(this.uri, this.connectionConfig);
       this.connected = true;
       this.reconnectAttempts = 0;
+      await this.setupTTLIndex();
+      this.startOrphanCleanup();
     } catch (error) {
       loggers.agent.error("Failed to connect to MongoDB:", error);
       throw error;
@@ -186,11 +208,15 @@ export class MongoDBMemory implements IMemory {
   }
 
   public async disconnect(): Promise<void> {
-    if (!this.isConnected) {
+    if (!this.connected) {
       return;
     }
 
     try {
+      if (this.orphanCleanupTimer) {
+        clearInterval(this.orphanCleanupTimer);
+        this.orphanCleanupTimer = undefined;
+      }
       await mongoose.disconnect();
       this.connected = false;
     } catch (error) {
@@ -204,7 +230,7 @@ export class MongoDBMemory implements IMemory {
   }
 
   private async ensureConnection(): Promise<void> {
-    if (!this.isConnected && !this.reconnecting) {
+    if (!this.connected && !this.reconnecting) {
       await this.connect();
     }
 
@@ -215,11 +241,79 @@ export class MongoDBMemory implements IMemory {
       await new Promise((resolve) => setTimeout(resolve, 100));
     }
 
-    if (!this.isConnected) {
+    if (!this.connected) {
       throw new Error("MongoDB is not connected and reconnection failed");
     }
   }
 
+  private async setupTTLIndex(): Promise<void> {
+    if (this.threadTTLSeconds === undefined) return;
+
+    try {
+      const db = mongoose.connection.db;
+      if (!db) return;
+
+      const collection = db.collection('threads');
+      const indexes = await collection.indexes();
+      const existingTTL = indexes.find(
+        (idx) => idx.key?.updatedAt !== undefined && idx.expireAfterSeconds !== undefined
+      );
+
+      if (existingTTL) {
+        if (existingTTL.expireAfterSeconds !== this.threadTTLSeconds) {
+          await db.command({
+            collMod: 'threads',
+            index: { keyPattern: { updatedAt: 1 }, expireAfterSeconds: this.threadTTLSeconds },
+          });
+          loggers.agent.info(`Thread TTL index updated to ${this.threadTTLSeconds} seconds`);
+        }
+      } else {
+        await collection.createIndex(
+          { updatedAt: 1 },
+          { expireAfterSeconds: this.threadTTLSeconds },
+        );
+        loggers.agent.info(`Thread TTL index created with ${this.threadTTLSeconds} seconds`);
+      }
+    } catch (error) {
+      loggers.agent.error('Failed to setup TTL index:', error);
+    }
+  }
+
+  private startOrphanCleanup(): void {
+    if (this.threadTTLSeconds === undefined) return;
+    if (this.orphanCleanupTimer) return;
+
+    // Run cleanup at half the TTL interval, with a minimum of 60s and maximum of 1 hour
+    const intervalMs = Math.max(60_000, Math.min(this.threadTTLSeconds * 500, 3_600_000));
+    this.orphanCleanupTimer = setInterval(() => {
+      this.cleanupOrphanedMessages().catch((error) => {
+        loggers.agent.error('Orphaned message cleanup failed:', error);
+      });
+    }, intervalMs);
+
+    loggers.agent.info(`Orphaned message cleanup scheduled every ${Math.round(intervalMs / 1000)}s`);
+  }
+
+  private async cleanupOrphanedMessages(): Promise<void> {
+    if (!this.connected) return;
+
+    try {
+      const db = mongoose.connection.db;
+      if (!db) return;
+
+      const existingThreadIds = await db.collection('threads').distinct('threadId');
+      const result = await MessageModel.deleteMany({
+        threadId: { $nin: existingThreadIds },
+      });
+
+      if (result.deletedCount > 0) {
+        loggers.agent.info(`Cleaned up ${result.deletedCount} orphaned messages`);
+      }
+    } catch (error) {
+      loggers.agent.error('Failed to cleanup orphaned messages:', error);
+    }
+  }
+
   /**
    * Get the operation timeout in milliseconds
    */
@@ -246,6 +340,30 @@ export class MongoDBMemory implements IMemory {
         throw error;
       }
 
+      // Check if it's a TooManyLogicalSessions error
+      if (error.code === 261 || error.codeName === "TooManyLogicalSessions") {
+        loggers.agent.warn(
+          `${operationName} failed due to too many sessions, disconnecting to release sessions...`
+        );
+
+        try {
+          await mongoose.disconnect();
+          this.connected = false;
+        } catch (disconnectError) {
+          loggers.agent.error("Failed to disconnect during session cleanup:", disconnectError);
+        }
+
+        await new Promise((resolve) => setTimeout(resolve, 5000));
+        await this.ensureConnection();
+
+        try {
+          return await operation();
+        } catch (retryError: any) {
+          loggers.agent.error(`${operationName} failed after session cleanup retry:`, retryError);
+          throw retryError;
+        }
+      }
+
       // Check if it's a connection-related error
       if (
         error.name === "MongoNetworkError" ||

package/implements/thread.memory.ts

@@ -1,4 +1,4 @@
-import type { MessageObject, ThreadMetadata, ThreadObject, ThreadType } from "@ainetwork/adk/types/memory";
+import type { MessageObject, ThreadMetadata, ThreadObject, ThreadType, ThreadFilter } from "@ainetwork/adk/types/memory";
 import { MessageRole } from "@ainetwork/adk/types/memory";
 import { IThreadMemory } from "@ainetwork/adk/modules";
 import { ThreadDocument, ThreadModel } from "../models/threads.model";
@@ -44,6 +44,8 @@ export class MongoDBThread implements IThreadMemory {
         userId: thread.userId,
         type: thread.type as ThreadType,
         title: thread.title || "New thread",
+        isPinned: thread.isPinned ?? false,
+        workflowId: thread.workflowId,
         messages: []
       };
       messages.forEach((message: MessageDocument) => {
@@ -65,19 +67,18 @@ export class MongoDBThread implements IThreadMemory {
     userId: string,
     threadId: string,
     title: string,
+    workflowId?: string,
   ): Promise<ThreadObject> {
     return this.executeWithRetry(async () => {
-      const now = Date.now();
       await ThreadModel.create({
         type,
         userId,
         threadId,
         title,
-        updated_at: now,
-        created_at: now,
+        workflowId,
       });
 
-      return { type, userId, threadId, title, messages: []};
+      return { type, userId, threadId, title, workflowId, messages: []};
     }, `createThread(${userId}, ${threadId})`);
   };
 
@@ -87,20 +88,25 @@ export class MongoDBThread implements IThreadMemory {
     messages: MessageObject[]
   ): Promise<void> {
     return this.executeWithRetry(async () => {
-      await ThreadModel.updateOne({ threadId, userId }, {
-        updated_at: Date.now(),
-      });
-      for (const message of messages) {
-        await MessageModel.create({
-          threadId,
-          messageId: message.messageId,
-          userId,
-          role: message.role,
-          content: message.content,
-          timestamp: message.timestamp,
-          metadata: message.metadata,
-        });
+      if (messages.length > 0) {
+        const messageIds = messages.map((m) => m.messageId);
+        await MessageModel.deleteMany({ threadId, userId, messageId: { $in: messageIds } });
+        await MessageModel.insertMany(
+          messages.map((message) => ({
+            threadId,
+            messageId: message.messageId,
+            userId,
+            role: message.role,
+            content: message.content,
+            timestamp: message.timestamp,
+            metadata: message.metadata,
+          }))
+        );
       }
+      await ThreadModel.updateOne(
+        { threadId, userId },
+        { $set: { updatedAt: new Date() } }
+      );
     }, `addMessagesToThread(${userId}, ${threadId})`);
   };
 
@@ -116,11 +122,14 @@ export class MongoDBThread implements IThreadMemory {
     }, `deleteThread(${userId}, ${threadId})`);
   };
 
-  public async listThreads(userId: string): Promise<ThreadMetadata[]> {
+  public async listThreads(userId: string, filter?: ThreadFilter): Promise<ThreadMetadata[]> {
     return this.executeWithRetry(async () => {
       const timeout = this.getOperationTimeout();
-      const threads = await ThreadModel.find({ userId })
-        .sort({ updated_at: -1 })
+      const query: Record<string, any> = { userId };
+      if (filter?.workflowId) query.workflowId = filter.workflowId;
+      if (filter?.type) query.type = filter.type;
+      const threads = await ThreadModel.find(query)
+        .sort({ updatedAt: -1 })
         .maxTimeMS(timeout);
       const data: ThreadMetadata[] = threads.map((thread: ThreadDocument) => {
         return {
@@ -128,10 +137,27 @@ export class MongoDBThread implements IThreadMemory {
           userId,
           threadId: thread.threadId,
           title: thread.title,
-          updatedAt: thread.updated_at
+          isPinned: thread.isPinned ?? false,
+          workflowId: thread.workflowId,
+          createdAt: thread.createdAt?.toISOString(),
+          updatedAt: thread.updatedAt?.toISOString(),
         } as ThreadMetadata;
       })
       return data;
     }, `listThreads(${userId})`);
   };
+
+  public async updateThreadPin(
+    userId: string,
+    threadId: string,
+    isPinned: boolean
+  ): Promise<void> {
+    return this.executeWithRetry(async () => {
+      const timeout = this.getOperationTimeout();
+      await ThreadModel.updateOne(
+        { threadId, userId },
+        { $set: { isPinned } }
+      ).maxTimeMS(timeout);
+    }, `updateThreadPin(${userId}, ${threadId})`);
+  };
 }

package/implements/user-workflow.memory.ts

@@ -0,0 +1,87 @@
+import type { IUserWorkflowMemory } from "@ainetwork/adk/modules";
+import type { UserWorkflow } from "@ainetwork/adk/types/memory";
+import { UserWorkflowModel } from "../models/user-workflow.model";
+
+export type ExecuteWithRetryFn = <T>(
+  operation: () => Promise<T>,
+  operationName?: string
+) => Promise<T>;
+
+export type GetOperationTimeoutFn = () => number;
+
+export class MongoDBUserWorkflow implements IUserWorkflowMemory {
+  private executeWithRetry: ExecuteWithRetryFn;
+  private getOperationTimeout: GetOperationTimeoutFn;
+
+  constructor(
+    executeWithRetry: ExecuteWithRetryFn,
+    getOperationTimeout: GetOperationTimeoutFn
+  ) {
+    this.executeWithRetry = executeWithRetry;
+    this.getOperationTimeout = getOperationTimeout;
+  }
+
+  public async createUserWorkflow(workflow: UserWorkflow): Promise<UserWorkflow> {
+    return this.executeWithRetry(async () => {
+      const created = await UserWorkflowModel.create(workflow);
+      return created.toObject() as UserWorkflow;
+    }, "createUserWorkflow()");
+  }
+
+  public async getUserWorkflow(workflowId: string): Promise<UserWorkflow | undefined> {
+    return this.executeWithRetry(async () => {
+      const timeout = this.getOperationTimeout();
+      const workflow = await UserWorkflowModel.findOne({ workflowId })
+        .maxTimeMS(timeout)
+        .lean<UserWorkflow>();
+      return workflow || undefined;
+    }, "getUserWorkflow()");
+  }
+
+  public async updateUserWorkflow(workflowId: string, updates: Partial<UserWorkflow>): Promise<void> {
+    if (!updates.userId) {
+      throw new Error("userId is required for updateUserWorkflow");
+    }
+
+    const { userId, workflowId: _workflowId, ...mutableUpdates } = updates;
+
+    return this.executeWithRetry(async () => {
+      const timeout = this.getOperationTimeout();
+      await UserWorkflowModel.updateOne(
+        { workflowId, userId },
+        { $set: mutableUpdates }
+      ).maxTimeMS(timeout);
+    }, "updateUserWorkflow()");
+  }
+
+  public async deleteUserWorkflow(workflowId: string, userId: string): Promise<void> {
+    return this.executeWithRetry(async () => {
+      const timeout = this.getOperationTimeout();
+      await UserWorkflowModel.deleteOne({ workflowId, userId }).maxTimeMS(timeout);
+    }, "deleteUserWorkflow()");
+  }
+
+  public async listUserWorkflows(userId?: string): Promise<UserWorkflow[]> {
+    return this.executeWithRetry(async () => {
+      const timeout = this.getOperationTimeout();
+      const query = userId ? { userId } : {};
+      const workflows = await UserWorkflowModel.find(query)
+        .maxTimeMS(timeout)
+        .lean<UserWorkflow[]>();
+      return workflows;
+    }, "listUserWorkflows()");
+  }
+
+  public async listActiveScheduledWorkflows(): Promise<UserWorkflow[]> {
+    return this.executeWithRetry(async () => {
+      const timeout = this.getOperationTimeout();
+      const workflows = await UserWorkflowModel.find({
+        active: true,
+        schedule: { $exists: true, $ne: null },
+      })
+        .maxTimeMS(timeout)
+        .lean<UserWorkflow[]>();
+      return workflows;
+    }, "listActiveScheduledWorkflows()");
+  }
+}

package/implements/workflow-template.memory.ts

@@ -0,0 +1,69 @@
+import type { IWorkflowTemplateMemory } from "@ainetwork/adk/modules";
+import type { WorkflowTemplate } from "@ainetwork/adk/types/memory";
+import { WorkflowTemplateModel } from "../models/workflow-template.model";
+
+export type ExecuteWithRetryFn = <T>(
+  operation: () => Promise<T>,
+  operationName?: string
+) => Promise<T>;
+
+export type GetOperationTimeoutFn = () => number;
+
+export class MongoDBWorkflowTemplate implements IWorkflowTemplateMemory {
+  private executeWithRetry: ExecuteWithRetryFn;
+  private getOperationTimeout: GetOperationTimeoutFn;
+
+  constructor(
+    executeWithRetry: ExecuteWithRetryFn,
+    getOperationTimeout: GetOperationTimeoutFn
+  ) {
+    this.executeWithRetry = executeWithRetry;
+    this.getOperationTimeout = getOperationTimeout;
+  }
+
+  public async createTemplate(template: WorkflowTemplate): Promise<WorkflowTemplate> {
+    return this.executeWithRetry(async () => {
+      const created = await WorkflowTemplateModel.create(template);
+      return created.toObject() as WorkflowTemplate;
+    }, "createTemplate()");
+  }
+
+  public async getTemplate(templateId: string): Promise<WorkflowTemplate | undefined> {
+    return this.executeWithRetry(async () => {
+      const timeout = this.getOperationTimeout();
+      const template = await WorkflowTemplateModel.findOne({ templateId })
+        .maxTimeMS(timeout)
+        .lean<WorkflowTemplate>();
+      return template || undefined;
+    }, "getTemplate()");
+  }
+
+  public async updateTemplate(templateId: string, updates: Partial<WorkflowTemplate>): Promise<void> {
+    const { templateId: _templateId, ...mutableUpdates } = updates;
+
+    return this.executeWithRetry(async () => {
+      const timeout = this.getOperationTimeout();
+      await WorkflowTemplateModel.updateOne(
+        { templateId },
+        { $set: mutableUpdates }
+      ).maxTimeMS(timeout);
+    }, "updateTemplate()");
+  }
+
+  public async deleteTemplate(templateId: string): Promise<void> {
+    return this.executeWithRetry(async () => {
+      const timeout = this.getOperationTimeout();
+      await WorkflowTemplateModel.deleteOne({ templateId }).maxTimeMS(timeout);
+    }, "deleteTemplate()");
+  }
+
+  public async listTemplates(): Promise<WorkflowTemplate[]> {
+    return this.executeWithRetry(async () => {
+      const timeout = this.getOperationTimeout();
+      const templates = await WorkflowTemplateModel.find()
+        .maxTimeMS(timeout)
+        .lean<WorkflowTemplate[]>();
+      return templates;
+    }, "listTemplates()");
+  }
+}

package/models/messages.model.ts

@@ -47,8 +47,13 @@ export const MessageObjectSchema = new Schema(
 			default: {},
 		},
 	},
+	{
+		timestamps: true,
+	},
 );
 
+MessageObjectSchema.index({ threadId: 1, messageId: 1 }, { unique: true });
+
 // Message Document interface
 export interface MessageDocument extends Document {
 	messageId: string;
@@ -60,6 +65,8 @@ export interface MessageDocument extends Document {
 		parts: any[];
 	};
 	timestamp: number;
+	createdAt: Date;
+	updatedAt: Date;
 	metadata?: { [key: string]: unknown };
 }