feat: Add pagination support and account status management across database adapters (CONFLICTED)

agent/src/index.ts

@@ -42,6 +42,7 @@ import {
     type ICacheManager,
     type IDatabaseAdapter,
     type IDatabaseCacheAdapter,
+    type TypeDatabaseAdapter,
     ModelProviderName,
     parseBooleanFromText,
     settings,
@@ -1389,24 +1390,14 @@ function initializeCache(
 
 async function startAgent(
     character: Character,
-    directClient: DirectClient
+    directClient: DirectClient,
+    db: TypeDatabaseAdapter
 ): Promise<AgentRuntime> {
-    let db: IDatabaseAdapter & IDatabaseCacheAdapter;
     try {
         character.id ??= stringToUuid(character.name);
         character.username ??= character.name;
 
         const token = getTokenForProvider(character.modelProvider, character);
-        const dataDir = path.join(__dirname, "../data");
-
-        if (!fs.existsSync(dataDir)) {
-            fs.mkdirSync(dataDir, { recursive: true });
-        }
-
-        db = initializeDatabase(dataDir) as IDatabaseAdapter &
-            IDatabaseCacheAdapter;
-
-        await db.init();
 
         const cache = initializeCache(
             process.env.CACHE_STORE ?? CacheStore.DATABASE,
@@ -1440,9 +1431,6 @@ async function startAgent(
             error
         );
         elizaLogger.error(error);
-        if (db) {
-            await db.close();
-        }
         throw error;
     }
 }
@@ -1476,6 +1464,16 @@ const startAgents = async () => {
     let serverPort = Number.parseInt(settings.SERVER_PORT || "3000");
     const args = parseArguments();
     const charactersArg = args.characters || args.character;
+    const dataDir = path.join(__dirname, "../data");
+
+    if (!fs.existsSync(dataDir)) {
+        fs.mkdirSync(dataDir, { recursive: true });
+    }
+
+    const db = initializeDatabase(dataDir) as TypeDatabaseAdapter;
+
+    await db.init();
+
     let characters = [defaultCharacter];
 
     if (process.env.IQ_WALLET_ADDRESS && process.env.IQSOlRPC) {
@@ -1493,7 +1491,7 @@ const startAgents = async () => {
 
     try {
         for (const character of characters) {
-            await startAgent(character, directClient);
+            await startAgent(character, directClient, db);
         }
     } catch (error) {
         elizaLogger.error("Error starting agents:", error);
@@ -1513,11 +1511,12 @@ const startAgents = async () => {
         character.plugins = await handlePluginImporting(character.plugins);
 
         // wrap it so we don't have to inject directClient later
-        return startAgent(character, directClient);
+        return startAgent(character, directClient, db);
     };
 
     directClient.loadCharacterTryPath = loadCharacterTryPath;
     directClient.jsonToCharacter = jsonToCharacter;
+    directClient.db = db;
 
     directClient.start(serverPort);
 

packages/adapter-mongodb/src/index.ts

@@ -11,6 +11,8 @@
     type Memory,
     type Relationship,
     type UUID, elizaLogger,
+    type PaginationParams,
+    type PaginationResult,
 } from "@elizaos/core";
 import { v4 } from "uuid";
 
@@ -322,6 +324,11 @@
         }
     }
 
+    async updateAccount(account: Account): Promise<void> {
+        await this.ensureConnection();
+        await this.database.collection('accounts').updateOne({ id: account.id }, { $set: account });
+    }
+
     async getActorDetails(params: { roomId: UUID }): Promise<Actor[]> {
         await this.ensureConnection();
         const actors = await this.database.collection('participants')
@@ -1440,6 +1447,61 @@
             return [];
         }
     }
+    async paginate(collectionName: string, params: PaginationParams): Promise<PaginationResult> {
+        await this.ensureConnection();
+
+        const {
+            page = 1,
+            pageSize = 10,
+            where = {},
+            order = { createdAt: -1 } // MongoDB uses 1 for ASC, -1 for DESC
+        } = params;
+
+        const skip = (page - 1) * pageSize;
+
+        // Convert where conditions for MongoDB
+        const whereQuery: any = {};
+        // biome-ignore lint/complexity/noForEach: <explanation>
+        Object.entries(where).forEach(([key, value]) => {
+            if (value === null || value === undefined) return;
+
+            if (typeof value === 'object') {
+                if (key === 'createdAt') {
+                    whereQuery[key] = {};
+                    if (value.gte) whereQuery[key].$gte = new Date(value.gte);
+                    if (value.lte) whereQuery[key].$lte = new Date(value.lte);
+                } else {
+                    whereQuery[key] = value;
+                }
+            } else {
+                whereQuery[key] = value;
+            }
+        });
 
+        try {
+            // Get total count
+            const total = await this.database.collection(collectionName)
+                .countDocuments(whereQuery);
+
+            // Get paginated data
+            const list = await this.database.collection(collectionName)
+                .find(whereQuery)
+                .sort(order)
+                .skip(skip)
+                .limit(pageSize)
+                .toArray();
+
+            return {
+                list,
+                total,
+                page,
+                pageSize,
+                totalPages: Math.ceil(total / pageSize),
+            };
+        } catch (error) {
+            elizaLogger.error(`Error in paginate for collection ${collectionName}:`, error);
+            throw error;
+        }
+    }
 }
 

packages/adapter-pglite/src/index.ts

@@ -15,6 +15,8 @@
     DatabaseAdapter,
     EmbeddingProvider,
     type RAGKnowledgeItem,
+    type PaginationParams,
+    type PaginationResult,
 } from "@elizaos/core";
 import fs from "fs";
 import { fileURLToPath } from "url";
@@ -241,15 +243,16 @@
             try {
                 const accountId = account.id ?? v4();
                 await this.query(
-                    `INSERT INTO accounts (id, name, username, email, "avatarUrl", details)
-                    VALUES ($1, $2, $3, $4, $5, $6)`,
+                    `INSERT INTO accounts (id, name, username, email, "avatarUrl", details, status)
+                    VALUES ($1, $2, $3, $4, $5, $6, $7)`,
                     [
                         accountId,
                         account.name,
                         account.username || "",
                         account.email || "",
                         account.avatarUrl || "",
                         JSON.stringify(account.details),
+                        account.status || "paused",
                     ]
                 );
                 elizaLogger.debug("Account created successfully:", {
@@ -268,6 +271,33 @@
         }, "createAccount");
     }
 
+    async updateAccount(account: Account): Promise<void> {
+        return this.withDatabase(async () => {
+            try {
+                await this.query(
+                    `UPDATE accounts SET name = $1, username = $2, email = $3, "avatarUrl" = $4, status = $5, details = $6 WHERE id = $7`,
+                    [
+                        account.name,
+                        account.username,
+                        account.email,
+                        account.avatarUrl,
+                        account.status,
+                        JSON.stringify(account.details),
+                        account.id,
+                    ]
+                );
+            } catch (error) {
+                elizaLogger.error("Failed to update accounts:", {
+                    account: account.id,
+                    error:
+                        error instanceof Error ? error.message : String(error),
+                    status: account.status,
+                });
+                throw error;
+            }
+        }, "updateAccount");
+    }
+
     async getActorById(params: { roomId: UUID }): Promise<Actor[]> {
         return this.withDatabase(async () => {
             const { rows } = await this.query<Actor>(
@@ -1558,6 +1588,95 @@
             }
         }, "clearKnowledge");
     }
+
+    async paginate(table: string, params: PaginationParams): Promise<PaginationResult> {
+        return this.withDatabase(async () => {
+            const {
+                page = 1,
+                pageSize = 10,
+                where = {},
+                order = { createdAt: 'DESC' }
+            } = params;
+
+            const offset = (page - 1) * pageSize;
+            const whereClause: string[] = [];
+            const values: any[] = [];
+            let paramCount = 0;
+
+            // Build where clause with proper parameter indexing
+            // biome-ignore lint/complexity/noForEach: <explanation>
+            Object.entries(where).forEach(([key, value]) => {
+                if (value === null || value === undefined) return;
+
+                if (typeof value === 'object') {
+                    if (key === 'createdAt') {
+                        if (value.gte) {
+                            paramCount++;
+                            whereClause.push(`"${key}" >= $${paramCount}`);
+                            values.push(value.gte);
+                        }
+                        if (value.lte) {
+                            paramCount++;
+                            whereClause.push(`"${key}" <= $${paramCount}`);
+                            values.push(value.lte);
+                        }
+                    }
+                } else {
+                    paramCount++;
+                    whereClause.push(`"${key}" = $${paramCount}`);
+                    values.push(value);
+                }
+            });
+
+            const whereStr = whereClause.length > 0
+                ? `WHERE ${whereClause.join(' AND ')}`
+                : '';
+
+            const orderClause = Object.entries(order)
+                .map(([key, direction]) => `"${key}" ${direction}`)
+                .join(', ');
+
+            // Count total records
+            const countQuery = `
+                SELECT COUNT(*) as total 
+                FROM "${table}" 
+                ${whereStr}
+            `;
+
+            const { rows: countRows } = await this.query<{ total: number }>(
+                countQuery,
+                values
+            );
+            const total = Number(countRows[0]?.total || 0);
+
+            // Get paginated data
+            paramCount++;
+            const limitParam = `$${paramCount}`;
+            paramCount++;
+            const offsetParam = `$${paramCount}`;
+
+            const dataQuery = `
+                SELECT * 
+                FROM "${table}" 
+                ${whereStr}
+                ORDER BY ${orderClause}
+                LIMIT ${limitParam} OFFSET ${offsetParam}
+            `;
+
+            const { rows: list } = await this.query(
+                dataQuery,
+                [...values, pageSize, offset]
+            );
+
+            return {
+                list,
+                total,
+                page,
+                pageSize,
+                totalPages: Math.ceil(total / pageSize),
+            };
+        }, "paginate");
+    }
 }
 
 export default PGLiteDatabaseAdapter;

packages/adapter-postgres/schema.sql

@@ -43,7 +43,8 @@ CREATE TABLE IF NOT EXISTS accounts (
     "username" TEXT,
     "email" TEXT NOT NULL,
     "avatarUrl" TEXT,
-    "details" JSONB DEFAULT '{}'::jsonb
+    "details" JSONB DEFAULT '{}'::jsonb,
+    "status" TEXT
 );
 
 CREATE TABLE IF NOT EXISTS rooms (