@ainetwork/adk-provider-memory-mongodb 0.2.2 → 0.2.4

package/dist/models/intent.model.d.cts

@@ -1,9 +1,8 @@
+import { Intent } from '@ainetwork/adk/types/memory';
 import mongoose, { Document } from 'mongoose';
 
-interface IntentDocument extends Document {
-    name: string;
-    description: string;
-    prompt?: string;
+interface IntentDocument extends Omit<Document, 'id'>, Omit<Intent, 'id'> {
+    id: string;
 }
 declare const IntentModel: mongoose.Model<IntentDocument, {}, {}, {}, mongoose.Document<unknown, {}, IntentDocument, {}> & IntentDocument & Required<{
     _id: unknown;

package/dist/models/intent.model.d.ts

@@ -1,9 +1,8 @@
+import { Intent } from '@ainetwork/adk/types/memory';
 import mongoose, { Document } from 'mongoose';
 
-interface IntentDocument extends Document {
-    name: string;
-    description: string;
-    prompt?: string;
+interface IntentDocument extends Omit<Document, 'id'>, Omit<Intent, 'id'> {
+    id: string;
 }
 declare const IntentModel: mongoose.Model<IntentDocument, {}, {}, {}, mongoose.Document<unknown, {}, IntentDocument, {}> & IntentDocument & Required<{
     _id: unknown;

package/dist/models/intent.model.js

@@ -1,6 +1,6 @@
 import {
   IntentModel
-} from "../chunk-722XAZKL.js";
+} from "../chunk-YFW7JXII.js";
 export {
   IntentModel
 };

package/implements/base.memory.ts

@@ -2,51 +2,229 @@ import { IMemory } from "node_modules/@ainetwork/adk/dist/esm/modules/memory/bas
 import mongoose from "mongoose";
 import { loggers } from "@ainetwork/adk/utils/logger";
 
+export interface MongoDBMemoryConfig {
+  uri: string;
+  maxReconnectAttempts?: number;
+  reconnectInterval?: number;
+  maxPoolSize?: number;
+  serverSelectionTimeoutMS?: number;
+  socketTimeoutMS?: number;
+  connectTimeoutMS?: number;
+  operationTimeoutMS?: number; // Timeout for database operations
+}
+
 export class MongoDBMemory implements IMemory {
-  private _isConnected: boolean = false;
-  private _uri: string;
+  private static instance: MongoDBMemory;
+  private uri: string;
+  private connected: boolean = false;
+  private reconnectAttempts: number = 0;
+  private maxReconnectAttempts: number;
+  private reconnectInterval: number;
+  private reconnecting: boolean = false;
+  private connectionConfig: mongoose.ConnectOptions;
+  private eventListenersSetup: boolean = false;
+  private operationTimeoutMS: number;
+
+  constructor(config: string | MongoDBMemoryConfig) {
+    const cfg = typeof config === 'string' ? { uri: config } : config;
+
+    this.uri = cfg.uri;
+    this.maxReconnectAttempts = cfg.maxReconnectAttempts ?? 5;
+    this.reconnectInterval = cfg.reconnectInterval ?? 5000;
+    this.operationTimeoutMS = cfg.operationTimeoutMS ?? 10000; // Default 10 seconds
+    this.connectionConfig = {
+      maxPoolSize: cfg.maxPoolSize ?? 1,
+      serverSelectionTimeoutMS: cfg.serverSelectionTimeoutMS ?? 30000,
+      socketTimeoutMS: cfg.socketTimeoutMS ?? 45000,
+      connectTimeoutMS: cfg.connectTimeoutMS ?? 30000,
+      bufferCommands: false,
+    };
+
+    if (!MongoDBMemory.instance) {
+      MongoDBMemory.instance = this;
+      this.setupMongooseEventListeners();
+    } else {
+      // Use existing instance's connection state
+      this.connected = MongoDBMemory.instance.connected;
+      this.operationTimeoutMS = MongoDBMemory.instance.operationTimeoutMS;
+    }
+  }
+
+  private setupMongooseEventListeners(): void {
+    if (this.eventListenersSetup) return;
+
+    this.eventListenersSetup = true;
+
+    mongoose.connection.on("connected", () => {
+      this.connected = true;
+      this.reconnectAttempts = 0;
+      this.reconnecting = false;
+      loggers.agent.info("MongoDB connected successfully");
+    });
+
+    mongoose.connection.on("disconnected", () => {
+      this.connected = false;
+      loggers.agent.warn("MongoDB disconnected");
+      this.handleDisconnection();
+    });
+
+    mongoose.connection.on("error", (error) => {
+      this.connected = false;
+      loggers.agent.error("MongoDB connection error:", error);
+      this.handleDisconnection();
+    });
+
+    mongoose.connection.on("reconnected", () => {
+      this.connected = true;
+      this.reconnectAttempts = 0;
+      this.reconnecting = false;
+      loggers.agent.info("MongoDB reconnected successfully");
+    });
+  }
+
+  private async handleDisconnection(): Promise<void> {
+    if (this.reconnecting) {
+      return;
+    }
+
+    this.reconnecting = true;
+
+    while (this.reconnectAttempts < this.maxReconnectAttempts && !this.isConnected) {
+      this.reconnectAttempts++;
+      loggers.agent.info(
+        `Attempting to reconnect to MongoDB (${this.reconnectAttempts}/${this.maxReconnectAttempts})...`
+      );
+
+      try {
+        await mongoose.connect(this.uri, this.connectionConfig);
+        this.connected = true;
+        this.reconnectAttempts = 0;
+        this.reconnecting = false;
+        loggers.agent.info("MongoDB reconnection successful");
+        return;
+      } catch (error) {
+        loggers.agent.error(
+          `Reconnection attempt ${this.reconnectAttempts} failed:`,
+          error
+        );
 
-  constructor(uri: string) {
-    this._uri = uri;
+        if (this.reconnectAttempts < this.maxReconnectAttempts) {
+          await new Promise((resolve) =>
+            setTimeout(resolve, this.reconnectInterval)
+          );
+        }
+      }
+    }
+
+    this.reconnecting = false;
+
+    if (!this.isConnected) {
+      loggers.agent.error(
+        `Failed to reconnect to MongoDB after ${this.maxReconnectAttempts} attempts`
+      );
+    }
   }
 
   public async connect(): Promise<void> {
-		if (this._isConnected) {
-			return;
-		}
-
-		try {
-      await mongoose.connect(this._uri, {
-        maxPoolSize: 1,
-        serverSelectionTimeoutMS: 30000,
-        socketTimeoutMS: 45000,
-        connectTimeoutMS: 30000,
-        bufferCommands: false,
-      });
-			this._isConnected = true;
-			loggers.agent.info("MongoDB connected successfully");
-		} catch (error) {
-			loggers.agent.error("Failed to connect to MongoDB:", error);
-			throw error;
-		}
+    if (this.connected) {
+      return;
+    }
+
+    try {
+      await mongoose.connect(this.uri, this.connectionConfig);
+      this.connected = true;
+      this.reconnectAttempts = 0;
+    } catch (error) {
+      loggers.agent.error("Failed to connect to MongoDB:", error);
+      throw error;
+    }
   }
 
   public async disconnect(): Promise<void> {
-		if (!this.isConnected) {
-			return;
-		}
+    if (!this.isConnected) {
+      return;
+    }
 
-		try {
-			await mongoose.disconnect();
-			this._isConnected = false;
-			loggers.agent.info("MongoDB disconnected successfully");
-		} catch (error) {
-			loggers.agent.error("Failed to disconnect from MongoDB:", error);
-			throw error;
-		}
+    try {
+      await mongoose.disconnect();
+      this.connected = false;
+    } catch (error) {
+      loggers.agent.error("Failed to disconnect from MongoDB:", error);
+      throw error;
+    }
   }
 
   public isConnected(): boolean {
-    return this._isConnected;
+    return this.connected;
+  }
+
+  private async ensureConnection(): Promise<void> {
+    if (!this.isConnected && !this.reconnecting) {
+      await this.connect();
+    }
+
+    // Wait for reconnection if in progress
+    const maxWaitTime = 30000; // 30 seconds
+    const startTime = Date.now();
+    while (this.reconnecting && Date.now() - startTime < maxWaitTime) {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+
+    if (!this.isConnected) {
+      throw new Error("MongoDB is not connected and reconnection failed");
+    }
+  }
+
+  /**
+   * Get the operation timeout in milliseconds
+   */
+  protected getOperationTimeout(): number {
+    return this.operationTimeoutMS;
+  }
+
+  /**
+   * Execute a database operation with automatic retry on connection errors
+   * Note: Use mongoose's maxTimeMS option in queries for timeout control
+   */
+  protected async executeWithRetry<T>(
+    operation: () => Promise<T>,
+    operationName: string = "Database operation"
+  ): Promise<T> {
+    await this.ensureConnection();
+
+    try {
+      return await operation();
+    } catch (error: any) {
+      // Check if it's a timeout error from MongoDB
+      if (error.code === 50 || error.message?.includes("operation exceeded time limit")) {
+        loggers.agent.error(`${operationName} exceeded time limit`);
+        throw error;
+      }
+
+      // Check if it's a connection-related error
+      if (
+        error.name === "MongoNetworkError" ||
+        error.name === "MongoServerError" ||
+        error.message?.includes("connection") ||
+        error.message?.includes("disconnect")
+      ) {
+        loggers.agent.warn(
+          `${operationName} failed due to connection issue, attempting reconnection...`
+        );
+
+        await this.ensureConnection();
+
+        // Retry the operation once after reconnection
+        try {
+          return await operation();
+        } catch (retryError: any) {
+          loggers.agent.error(`${operationName} failed after retry:`, retryError);
+          throw retryError;
+        }
+      }
+
+      // If it's not a connection error, just throw it
+      throw error;
+    }
   }
-}
+}

package/implements/intent.memory.ts

@@ -2,62 +2,57 @@ import type { Intent } from "@ainetwork/adk/types/memory";
 import { IIntentMemory } from "@ainetwork/adk/modules";
 import { MongoDBMemory } from "./base.memory";
 import { IntentModel } from "../models/intent.model";
-import { Types } from "mongoose";
 
 export class MongoDBIntent extends MongoDBMemory implements IIntentMemory {
   public async getIntent(intentId: string): Promise<Intent | undefined> {
-    const intent = await IntentModel.findById(new Types.ObjectId(intentId));
-    if (intent) {
-      return {
-        name: intent.name,
-        description: intent.description,
-        prompt: intent.prompt,
-      } as Intent;
-    }
-    return undefined;
+    return this.executeWithRetry(async () => {
+      const timeout = this.getOperationTimeout();
+      const intent = await IntentModel.findOne({ id: intentId })
+        .maxTimeMS(timeout)
+        .lean<Intent>();
+      return intent || undefined;
+    }, `getIntent(${intentId})`);
   };
 
-	public async getIntentByName(intentName: string): Promise<Intent | undefined> {
-		const intent = await IntentModel.findOne({ name: intentName });
-		if (intent) {
-			return {
-				name: intent.name,
-				description: intent.description,
-				prompt: intent.prompt,
-			} as Intent;
-		}
-		return undefined;
-	}
+  public async getIntentByName(intentName: string): Promise<Intent | undefined> {
+    return this.executeWithRetry(async () => {
+      const timeout = this.getOperationTimeout();
+      const intent = await IntentModel.findOne({ name: intentName })
+        .maxTimeMS(timeout)
+        .lean<Intent>();
+      return intent || undefined;
+    }, `getIntentByName(${intentName})`);
+  }
 
-	public async saveIntent(intent: Intent): Promise<void> {
-    // ObjectId automatically generated (MongoDB automatically generates)
-    await IntentModel.create({
-      name: intent.name,
-      description: intent.description,
-      prompt: intent.prompt,
-    });
+  public async saveIntent(intent: Intent): Promise<void> {
+    return this.executeWithRetry(async () => {
+      await IntentModel.create(intent);
+    }, `saveIntent(${intent.id})`);
   };
 
-	public async updateIntent(intentId: string, intent: Intent): Promise<void> {
-    await IntentModel.updateOne({
-      _id: new Types.ObjectId(intentId),
-    },{
-      name: intent.name,
-      description: intent.description,
-      prompt: intent.prompt,
-    });
+  public async updateIntent(intentId: string, intent: Intent): Promise<void> {
+    return this.executeWithRetry(async () => {
+      const timeout = this.getOperationTimeout();
+      await IntentModel.updateOne({
+        id: intentId,
+      }, intent).maxTimeMS(timeout);
+    }, `updateIntent(${intentId})`);
   };
 
-	public async deleteIntent(intentId: string): Promise<void> {
-    await IntentModel.deleteOne({ _id: new Types.ObjectId(intentId) });
+  public async deleteIntent(intentId: string): Promise<void> {
+    return this.executeWithRetry(async () => {
+      const timeout = this.getOperationTimeout();
+      await IntentModel.deleteOne({ id: intentId }).maxTimeMS(timeout);
+    }, `deleteIntent(${intentId})`);
   };
 
-	public async listIntents(): Promise<Intent[]> {
-    const intents = await IntentModel.find();
-    return intents.map(intent => ({
-      name: intent.name,
-      description: intent.description,
-      prompt: intent.prompt,
-    } as Intent));
+  public async listIntents(): Promise<Intent[]> {
+    return this.executeWithRetry(async () => {
+      const timeout = this.getOperationTimeout();
+      const intents = await IntentModel.find()
+        .maxTimeMS(timeout)
+        .lean<Intent[]>();
+      return intents;
+    }, `listIntents()`);
   };
-}
+}

package/implements/thread.memory.ts

@@ -15,101 +15,114 @@ export class MongoDBThread extends MongoDBMemory implements IThreadMemory {
     userId: string,
     threadId: string
   ): Promise<ThreadObject | undefined> {
-    const thread = await ThreadModel.findOne({ threadId, userId });
-		const messages = await MessageModel.find({ threadId, userId }).sort({
-			timestamp: 1,
-		});
+    return this.executeWithRetry(async () => {
+      const timeout = this.getOperationTimeout();
+      const thread = await ThreadModel.findOne({ threadId, userId }).maxTimeMS(timeout);
+      const messages = await MessageModel.find({ threadId, userId })
+        .sort({ timestamp: 1 })
+        .maxTimeMS(timeout);
 
-    if (!thread) return undefined;
+      if (!thread) return undefined;
 
-		loggers.agent.debug(`Found ${messages.length} messages for thread ${threadId}`);
+      loggers.agent.debug(`Found ${messages.length} messages for thread ${threadId}`);
 
-		const threadObject: ThreadObject = { 
-      threadId: thread.threadId, 
-      userId: thread.userId,
-      type: thread.type as ThreadType,
-      title: thread.title || "New thread",
-      messages: []
-    };
-		messages.forEach((message: MessageDocument) => {
-			threadObject.messages.push({
-        messageId: message.messageId,
-				role: message.role as MessageRole,
-				content: message.content,
-				timestamp: message.timestamp,
-				metadata: message.metadata,
-			});
-		});
+      const threadObject: ThreadObject = {
+        threadId: thread.threadId,
+        userId: thread.userId,
+        type: thread.type as ThreadType,
+        title: thread.title || "New thread",
+        messages: []
+      };
+      messages.forEach((message: MessageDocument) => {
+        threadObject.messages.push({
+          messageId: message.messageId,
+          role: message.role as MessageRole,
+          content: message.content,
+          timestamp: message.timestamp,
+          metadata: message.metadata,
+        });
+      });
 
-		return threadObject;
+      return threadObject;
+    }, `getThread(${userId}, ${threadId})`);
   };
 
-	public async createThread(
-		type: ThreadType,
-		userId: string,
-		threadId: string,
-		title: string,
+  public async createThread(
+    type: ThreadType,
+    userId: string,
+    threadId: string,
+    title: string,
   ): Promise<ThreadObject> {
-    const now = Date.now();
-    await ThreadModel.create({
-      type,
-      userId,
-      threadId,
-      title,
-      updated_at: now,
-      created_at: now,
-    });
+    return this.executeWithRetry(async () => {
+      const now = Date.now();
+      await ThreadModel.create({
+        type,
+        userId,
+        threadId,
+        title,
+        updated_at: now,
+        created_at: now,
+      });
 
-    return { type, userId, threadId, title, messages: []};
+      return { type, userId, threadId, title, messages: []};
+    }, `createThread(${userId}, ${threadId})`);
   };
 
-	public async addMessagesToThread(
+  public async addMessagesToThread(
     userId: string,
     threadId: string,
     messages: MessageObject[]
   ): Promise<void> {
-    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,
+    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,
+        });
+      }
+    }, `addMessagesToThread(${userId}, ${threadId})`);
   };
 
-	public async deleteThread(userId: string, threadId: string): Promise<void> {
-		const messages = await MessageModel.find({ userId, threadId }).sort({
-			timestamp: 1,
-		});
+  public async deleteThread(userId: string, threadId: string): Promise<void> {
+    return this.executeWithRetry(async () => {
+      const timeout = this.getOperationTimeout();
+      const messages = await MessageModel.find({ userId, threadId })
+        .sort({ timestamp: 1 })
+        .maxTimeMS(timeout);
+
+      messages?.forEach((message: MessageDocument) => {
+        message.deleteOne();
+      });
 
-		messages?.forEach((message: MessageDocument) => {
-      message.deleteOne();
-		});
-    
-    const thread = await ThreadModel.findOne({ userId, threadId });
-    thread?.deleteOne();
+      const thread = await ThreadModel.findOne({ userId, threadId }).maxTimeMS(timeout);
+      thread?.deleteOne();
+    }, `deleteThread(${userId}, ${threadId})`);
   };
 
-	public async listThreads(userId: string): Promise<ThreadMetadata[]> {
-    const threads = await ThreadModel.find({ userId }).sort({
-      updated_at: -1,
-    });
-    const data: ThreadMetadata[] = threads.map((thread: ThreadDocument) => {
-      return {
-        type: thread.type,
-        userId,
-        threadId: thread.threadId,
-        title: thread.title,
-        updatedAt: thread.updated_at
-      } as ThreadMetadata;
-    })
-    return data;
+  public async listThreads(userId: string): Promise<ThreadMetadata[]> {
+    return this.executeWithRetry(async () => {
+      const timeout = this.getOperationTimeout();
+      const threads = await ThreadModel.find({ userId })
+        .sort({ updated_at: -1 })
+        .maxTimeMS(timeout);
+      const data: ThreadMetadata[] = threads.map((thread: ThreadDocument) => {
+        return {
+          type: thread.type,
+          userId,
+          threadId: thread.threadId,
+          title: thread.title,
+          updatedAt: thread.updated_at
+        } as ThreadMetadata;
+      })
+      return data;
+    }, `listThreads(${userId})`);
   };
-}
+}

package/index.ts

@@ -1,2 +1,4 @@
 export { MongoDBThread } from "./implements/thread.memory";
-export { MongoDBIntent } from "./implements/intent.memory";
+export { MongoDBIntent } from "./implements/intent.memory";
+export { MongoDBMemory } from "./implements/base.memory";
+export type { MongoDBMemoryConfig } from "./implements/base.memory";

package/models/intent.model.ts

@@ -1,7 +1,14 @@
+import { Intent } from "@ainetwork/adk/types/memory";
 import mongoose, { type Document, Schema } from "mongoose";
 
 const IntentObjectSchema = new Schema(
 	{
+		id: { 
+			type: String,
+			required: true,
+			index: true,
+			unique: true,
+		},
 		name: {
 			type: String,
 			required: true,
@@ -15,13 +22,23 @@ const IntentObjectSchema = new Schema(
 			type: String,
 			required: false,
 		},
-	}
+		status: {
+			type: String,
+			required: true,
+		},
+		triggeringSentences: {
+			type: [String],
+			required: false,
+		},
+		tags: {
+			type: [String],
+			required: false,
+		},
+	},
 );
 
-export interface IntentDocument extends Document {
-	name: string;
-	description: string;
-	prompt?: string;
+export interface IntentDocument extends Omit<Document, 'id'>, Omit<Intent, 'id'> {
+	id: string;
 }
 
 export const IntentModel = mongoose.model<IntentDocument>("Intent", IntentObjectSchema);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ainetwork/adk-provider-memory-mongodb",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "author": "AI Network (https://ainetwork.ai)",
   "type": "module",
   "engines": {
@@ -28,7 +28,7 @@
     "clean": "rm -rf dist"
   },
   "dependencies": {
-    "@ainetwork/adk": "^0.2.7",
+    "@ainetwork/adk": "0.2.9",
     "mongoose": "^8.16.5"
   },
   "devDependencies": {
@@ -38,5 +38,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "e0021453227b0c9c0cd1d21efa0395e8e1f6740e"
+  "gitHead": "f1315510a23dd44492dc20737c4be71188d01e26"
 }