@elizaos/plugin-sql 1.0.0-alpha.7 → 1.0.0-beta.0

package/dist/index.js

@@ -1,15 +1,16 @@
 import {
   PGliteClientManager,
-  PostgresConnectionManager,
+  PostgresConnectionManager
+} from "./chunk-PSEXCDLP.js";
+import {
   __name
-} from "./chunk-LLEN3JTK.js";
+} from "./chunk-I3JSTNED.js";
 
 // src/index.ts
-import {
-  logger as logger4
-} from "@elizaos/core";
+import * as os from "node:os";
+import { logger as logger4 } from "@elizaos/core";
 
-// src/pg-lite/adapter.ts
+// src/pglite/adapter.ts
 import { logger as logger2 } from "@elizaos/core";
 import { drizzle } from "drizzle-orm/pglite";
 
@@ -28,20 +29,13 @@ import {
   inArray,
   lte,
   or,
-  sql as sql13
+  sql as sql12
 } from "drizzle-orm";
 import { v4 } from "uuid";
 
 // src/schema/embedding.ts
 import { sql as sql6 } from "drizzle-orm";
-import {
-  check as check2,
-  foreignKey as foreignKey2,
-  index as index2,
-  pgTable as pgTable6,
-  uuid as uuid6,
-  vector as vector2
-} from "drizzle-orm/pg-core";
+import { check as check2, foreignKey as foreignKey2, index as index2, pgTable as pgTable6, uuid as uuid6, vector as vector2 } from "drizzle-orm/pg-core";
 
 // src/schema/memory.ts
 import { relations, sql as sql5 } from "drizzle-orm";
@@ -58,14 +52,7 @@ import {
 
 // src/schema/agent.ts
 import { sql } from "drizzle-orm";
-import {
-  boolean,
-  jsonb,
-  pgTable,
-  text,
-  unique,
-  uuid
-} from "drizzle-orm/pg-core";
+import { boolean, jsonb, pgTable, text, unique, uuid } from "drizzle-orm/pg-core";
 
 // src/schema/types.ts
 import { customType } from "drizzle-orm/pg-core";
@@ -80,28 +67,26 @@ var stringJsonb = customType({
     return JSON.stringify(value);
   }
 });
-var numberTimestamp = customType(
-  {
-    dataType() {
-      return "timestamptz";
-    },
-    toDriver(value) {
-      return new Date(value).toISOString();
-    },
-    fromDriver(value) {
-      return new Date(value).getTime();
-    }
+var numberTimestamp = customType({
+  dataType() {
+    return "timestamptz";
+  },
+  toDriver(value) {
+    return new Date(value).toISOString();
+  },
+  fromDriver(value) {
+    return new Date(value).getTime();
   }
-);
+});
 
 // src/schema/agent.ts
 var agentTable = pgTable(
   "agents",
   {
     id: uuid("id").primaryKey().defaultRandom(),
+    enabled: boolean("enabled").default(true).notNull(),
     createdAt: numberTimestamp("createdAt").default(sql`now()`).notNull(),
     updatedAt: numberTimestamp("updatedAt").default(sql`now()`).notNull(),
-    enabled: boolean("enabled").default(true).notNull(),
     // Character
     name: text("name"),
     username: text("username"),
@@ -324,27 +309,18 @@ var componentTable = pgTable8("components", {
   createdAt: numberTimestamp("createdAt").default(sql8`now()`).notNull()
 });
 
-// src/schema/goal.ts
+// src/schema/log.ts
 import { sql as sql9 } from "drizzle-orm";
 import { foreignKey as foreignKey3, jsonb as jsonb8, pgTable as pgTable9, text as text8, uuid as uuid9 } from "drizzle-orm/pg-core";
-var goalTable = pgTable9(
-  "goals",
+var logTable = pgTable9(
+  "logs",
   {
-    id: uuid9("id").notNull().primaryKey().default(sql9`gen_random_uuid()`),
+    id: uuid9("id").defaultRandom().notNull(),
     createdAt: numberTimestamp("createdAt").default(sql9`now()`).notNull(),
-    entityId: uuid9("entityId").references(() => entityTable.id, {
-      onDelete: "cascade"
-    }),
-    agentId: uuid9("agentId").references(() => agentTable.id, {
-      onDelete: "cascade"
-    }),
-    name: text8("name"),
-    status: text8("status"),
-    description: text8("description"),
-    roomId: uuid9("roomId").references(() => roomTable.id, {
-      onDelete: "cascade"
-    }),
-    objectives: jsonb8("objectives").default("[]").notNull()
+    entityId: uuid9("entityId").notNull().references(() => entityTable.id),
+    body: jsonb8("body").notNull(),
+    type: text8("type").notNull(),
+    roomId: uuid9("roomId").notNull().references(() => roomTable.id)
   },
   (table) => [
     foreignKey3({
@@ -360,68 +336,35 @@ var goalTable = pgTable9(
   ]
 );
 
-// src/schema/log.ts
-import { sql as sql10 } from "drizzle-orm";
-import { foreignKey as foreignKey4, jsonb as jsonb9, pgTable as pgTable10, text as text9, uuid as uuid10 } from "drizzle-orm/pg-core";
-var logTable = pgTable10(
-  "logs",
-  {
-    id: uuid10("id").defaultRandom().notNull(),
-    createdAt: numberTimestamp("createdAt").default(sql10`now()`).notNull(),
-    entityId: uuid10("entityId").notNull().references(() => entityTable.id),
-    body: jsonb9("body").notNull(),
-    type: text9("type").notNull(),
-    roomId: uuid10("roomId").notNull().references(() => roomTable.id)
-  },
-  (table) => [
-    foreignKey4({
-      name: "fk_room",
-      columns: [table.roomId],
-      foreignColumns: [roomTable.id]
-    }).onDelete("cascade"),
-    foreignKey4({
-      name: "fk_user",
-      columns: [table.entityId],
-      foreignColumns: [entityTable.id]
-    }).onDelete("cascade")
-  ]
-);
-
 // src/schema/participant.ts
-import { sql as sql11 } from "drizzle-orm";
-import {
-  foreignKey as foreignKey5,
-  index as index3,
-  pgTable as pgTable11,
-  text as text10,
-  uuid as uuid11
-} from "drizzle-orm/pg-core";
-var participantTable = pgTable11(
+import { sql as sql10 } from "drizzle-orm";
+import { foreignKey as foreignKey4, index as index3, pgTable as pgTable10, text as text9, uuid as uuid10 } from "drizzle-orm/pg-core";
+var participantTable = pgTable10(
   "participants",
   {
-    id: uuid11("id").notNull().primaryKey().default(sql11`gen_random_uuid()`),
-    createdAt: numberTimestamp("createdAt").default(sql11`now()`).notNull(),
-    entityId: uuid11("entityId").references(() => entityTable.id, {
+    id: uuid10("id").notNull().primaryKey().default(sql10`gen_random_uuid()`),
+    createdAt: numberTimestamp("createdAt").default(sql10`now()`).notNull(),
+    entityId: uuid10("entityId").references(() => entityTable.id, {
       onDelete: "cascade"
     }),
-    roomId: uuid11("roomId").references(() => roomTable.id, {
+    roomId: uuid10("roomId").references(() => roomTable.id, {
       onDelete: "cascade"
     }),
-    agentId: uuid11("agentId").references(() => agentTable.id, {
+    agentId: uuid10("agentId").references(() => agentTable.id, {
       onDelete: "cascade"
     }),
-    roomState: text10("roomState")
+    roomState: text9("roomState")
   },
   (table) => [
     // unique("participants_user_room_agent_unique").on(table.entityId, table.roomId, table.agentId),
     index3("idx_participants_user").on(table.entityId),
     index3("idx_participants_room").on(table.roomId),
-    foreignKey5({
+    foreignKey4({
       name: "fk_room",
       columns: [table.roomId],
       foreignColumns: [roomTable.id]
     }).onDelete("cascade"),
-    foreignKey5({
+    foreignKey4({
       name: "fk_user",
       columns: [table.entityId],
       foreignColumns: [entityTable.id]
@@ -430,43 +373,28 @@ var participantTable = pgTable11(
 );
 
 // src/schema/relationship.ts
-import { sql as sql12 } from "drizzle-orm";
-import {
-  foreignKey as foreignKey6,
-  index as index4,
-  jsonb as jsonb10,
-  pgTable as pgTable12,
-  text as text11,
-  unique as unique6,
-  uuid as uuid12
-} from "drizzle-orm/pg-core";
-var relationshipTable = pgTable12(
+import { sql as sql11 } from "drizzle-orm";
+import { foreignKey as foreignKey5, index as index4, jsonb as jsonb9, pgTable as pgTable11, text as text10, unique as unique6, uuid as uuid11 } from "drizzle-orm/pg-core";
+var relationshipTable = pgTable11(
   "relationships",
   {
-    id: uuid12("id").notNull().primaryKey().default(sql12`gen_random_uuid()`),
-    createdAt: numberTimestamp("createdAt").default(sql12`now()`).notNull(),
-    sourceEntityId: uuid12("sourceEntityId").notNull().references(() => entityTable.id, { onDelete: "cascade" }),
-    targetEntityId: uuid12("targetEntityId").notNull().references(() => entityTable.id, { onDelete: "cascade" }),
-    agentId: uuid12("agentId").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
-    tags: text11("tags").array(),
-    metadata: jsonb10("metadata")
+    id: uuid11("id").notNull().primaryKey().default(sql11`gen_random_uuid()`),
+    createdAt: numberTimestamp("createdAt").default(sql11`now()`).notNull(),
+    sourceEntityId: uuid11("sourceEntityId").notNull().references(() => entityTable.id, { onDelete: "cascade" }),
+    targetEntityId: uuid11("targetEntityId").notNull().references(() => entityTable.id, { onDelete: "cascade" }),
+    agentId: uuid11("agentId").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
+    tags: text10("tags").array(),
+    metadata: jsonb9("metadata")
   },
   (table) => [
-    index4("idx_relationships_users").on(
-      table.sourceEntityId,
-      table.targetEntityId
-    ),
-    unique6("unique_relationship").on(
-      table.sourceEntityId,
-      table.targetEntityId,
-      table.agentId
-    ),
-    foreignKey6({
+    index4("idx_relationships_users").on(table.sourceEntityId, table.targetEntityId),
+    unique6("unique_relationship").on(table.sourceEntityId, table.targetEntityId, table.agentId),
+    foreignKey5({
       name: "fk_user_a",
       columns: [table.sourceEntityId],
       foreignColumns: [entityTable.id]
     }).onDelete("cascade"),
-    foreignKey6({
+    foreignKey5({
       name: "fk_user_b",
       columns: [table.targetEntityId],
       foreignColumns: [entityTable.id]
@@ -475,16 +403,16 @@ var relationshipTable = pgTable12(
 );
 
 // src/schema/tasks.ts
-import { jsonb as jsonb11, pgTable as pgTable13, text as text12, timestamp, uuid as uuid13 } from "drizzle-orm/pg-core";
-var taskTable = pgTable13("tasks", {
-  id: uuid13("id").primaryKey().defaultRandom(),
-  name: text12("name").notNull(),
-  description: text12("description").notNull(),
-  roomId: uuid13("room_id"),
-  worldId: uuid13("world_id"),
-  agentId: uuid13("agent_id").notNull(),
-  tags: text12("tags").array(),
-  metadata: jsonb11("metadata"),
+import { jsonb as jsonb10, pgTable as pgTable12, text as text11, timestamp, uuid as uuid12 } from "drizzle-orm/pg-core";
+var taskTable = pgTable12("tasks", {
+  id: uuid12("id").primaryKey().defaultRandom(),
+  name: text11("name").notNull(),
+  description: text11("description").notNull(),
+  roomId: uuid12("room_id"),
+  worldId: uuid12("world_id"),
+  agentId: uuid12("agent_id").notNull(),
+  tags: text11("tags").array(),
+  metadata: jsonb10("metadata"),
   createdAt: timestamp("created_at").defaultNow(),
   updatedAt: timestamp("updated_at").defaultNow()
 });
@@ -523,20 +451,13 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       } catch (error) {
         lastError = error;
         if (attempt < this.maxRetries) {
-          const backoffDelay = Math.min(
-            this.baseDelay * 2 ** (attempt - 1),
-            this.maxDelay
-          );
+          const backoffDelay = Math.min(this.baseDelay * 2 ** (attempt - 1), this.maxDelay);
           const jitter = Math.random() * this.jitterMax;
           const delay = backoffDelay + jitter;
-          logger.warn(
-            `Database operation failed (attempt ${attempt}/${this.maxRetries}):`,
-            {
-              error: error instanceof Error ? error.message : String(error),
-              nextRetryIn: `${(delay / 1e3).toFixed(1)}s`
-            }
-          );
-          console.trace("****** Database operation failure source");
+          logger.warn(`Database operation failed (attempt ${attempt}/${this.maxRetries}):`, {
+            error: error instanceof Error ? error.message : String(error),
+            nextRetryIn: `${(delay / 1e3).toFixed(1)}s`
+          });
           await new Promise((resolve) => setTimeout(resolve, delay));
         } else {
           logger.error("Max retry attempts reached:", {
@@ -550,7 +471,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
     throw lastError;
   }
   /**
-   * Ensure that an agent exists by checking if an agent with the same name already exists in the system.
+   * Asynchronously ensures that an agent exists by checking if an agent with the same name already exists in the system.
    * If the agent does not exist, it will be created with the provided data.
    *
    * @param {Partial<Agent>} agent - The partial data of the agent to ensure its existence.
@@ -570,7 +491,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
     }
   }
   /**
-   * Ensure that the given embedding dimension is valid for the agent.
+   * Asynchronously ensures that the given embedding dimension is valid for the agent.
    *
    * @param {number} dimension - The dimension to ensure for the embedding.
    * @returns {Promise<void>} - Resolves once the embedding dimension is ensured.
@@ -583,9 +504,6 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       const usedDimension = Object.entries(DIMENSION_MAP).find(
         ([_, colName]) => existingMemory[0].embedding[colName] !== null
       );
-      if (usedDimension && usedDimension[1] !== DIMENSION_MAP[dimension]) {
-        throw new Error("Cannot change embedding dimension for agent");
-      }
     }
     this.embeddingDimension = DIMENSION_MAP[dimension];
   }
@@ -725,23 +643,29 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       }
     });
   }
+  /**
+   * Asynchronously retrieves an entity and its components by entity ID.
+   * @param {UUID} entityId - The unique identifier of the entity to retrieve.
+   * @returns {Promise<Entity | null>} A Promise that resolves to the entity with its components if found, null otherwise.
+   */
   async getEntityById(entityId) {
     return this.withDatabase(async () => {
       const result = await this.db.select({
         entity: entityTable,
         components: componentTable
-      }).from(entityTable).leftJoin(componentTable, eq(componentTable.entityId, entityTable.id)).where(
-        and(
-          eq(entityTable.id, entityId),
-          eq(entityTable.agentId, this.agentId)
-        )
-      );
+      }).from(entityTable).leftJoin(componentTable, eq(componentTable.entityId, entityTable.id)).where(and(eq(entityTable.id, entityId), eq(entityTable.agentId, this.agentId)));
       if (result.length === 0) return null;
       const entity = result[0].entity;
       entity.components = result.filter((row) => row.components).map((row) => row.components);
       return entity;
     });
   }
+  /**
+   * Asynchronously retrieves all entities for a given room, optionally including their components.
+   * @param {UUID} roomId - The unique identifier of the room to get entities for
+   * @param {boolean} [includeComponents] - Whether to include component data for each entity
+   * @returns {Promise<Entity[]>} A Promise that resolves to an array of entities in the room
+   */
   async getEntitiesForRoom(roomId, includeComponents) {
     return this.withDatabase(async () => {
       const query = this.db.select({
@@ -749,16 +673,10 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
         ...includeComponents && { components: componentTable }
       }).from(participantTable).leftJoin(
         entityTable,
-        and(
-          eq(participantTable.entityId, entityTable.id),
-          eq(entityTable.agentId, this.agentId)
-        )
+        and(eq(participantTable.entityId, entityTable.id), eq(entityTable.agentId, this.agentId))
       );
       if (includeComponents) {
-        query.leftJoin(
-          componentTable,
-          eq(componentTable.entityId, entityTable.id)
-        );
+        query.leftJoin(componentTable, eq(componentTable.entityId, entityTable.id));
       }
       const result = await query.where(eq(participantTable.roomId, roomId));
       const entitiesByIdMap = /* @__PURE__ */ new Map();
@@ -785,6 +703,11 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       return Array.from(entitiesByIdMap.values());
     });
   }
+  /**
+   * Asynchronously creates a new entity in the database.
+   * @param {Entity} entity - The entity object to be created.
+   * @returns {Promise<boolean>} A Promise that resolves to a boolean indicating the success of the operation.
+   */
   async createEntity(entity) {
     return this.withDatabase(async () => {
       try {
@@ -801,13 +724,13 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
           entityId: entity.id,
           name: entity.metadata?.name
         });
-        console.trace(error);
+        logger.trace(error);
         return false;
       }
     });
   }
   /**
-   * Ensures an entity exists, creating it if it doesn't
+   * Asynchronously ensures an entity exists, creating it if it doesn't
    * @param entity The entity to ensure exists
    * @returns Promise resolving to boolean indicating success
    */
@@ -830,22 +753,19 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       return false;
     }
   }
+  /**
+   * Asynchronously updates an entity in the database.
+   * @param {Entity} entity - The entity object to be updated.
+   * @returns {Promise<void>} A Promise that resolves when the entity is updated.
+   */
   async updateEntity(entity) {
     return this.withDatabase(async () => {
-      await this.db.update(entityTable).set(entity).where(
-        and(
-          eq(entityTable.id, entity.id),
-          eq(entityTable.agentId, entity.agentId)
-        )
-      );
+      await this.db.update(entityTable).set(entity).where(and(eq(entityTable.id, entity.id), eq(entityTable.agentId, entity.agentId)));
     });
   }
   async getComponent(entityId, type, worldId, sourceEntityId) {
     return this.withDatabase(async () => {
-      const conditions = [
-        eq(componentTable.entityId, entityId),
-        eq(componentTable.type, type)
-      ];
+      const conditions = [eq(componentTable.entityId, entityId), eq(componentTable.type, type)];
       if (worldId) {
         conditions.push(eq(componentTable.worldId, worldId));
       }
@@ -856,6 +776,13 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       return result.length > 0 ? result[0] : null;
     });
   }
+  /**
+   * Asynchronously retrieves all components for a given entity, optionally filtered by world and source entity.
+   * @param {UUID} entityId - The unique identifier of the entity to retrieve components for
+   * @param {UUID} [worldId] - Optional world ID to filter components by
+   * @param {UUID} [sourceEntityId] - Optional source entity ID to filter components by
+   * @returns {Promise<Component[]>} A Promise that resolves to an array of components
+   */
   async getComponents(entityId, worldId, sourceEntityId) {
     return this.withDatabase(async () => {
       const conditions = [eq(componentTable.entityId, entityId)];
@@ -877,40 +804,73 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       return result;
     });
   }
+  /**
+   * Asynchronously creates a new component in the database.
+   * @param {Component} component - The component object to be created.
+   * @returns {Promise<boolean>} A Promise that resolves to a boolean indicating the success of the operation.
+   */
   async createComponent(component) {
     return this.withDatabase(async () => {
       await this.db.insert(componentTable).values(component);
       return true;
     });
   }
+  /**
+   * Asynchronously updates an existing component in the database.
+   * @param {Component} component - The component object to be updated.
+   * @returns {Promise<void>} A Promise that resolves when the component is updated.
+   */
   async updateComponent(component) {
     return this.withDatabase(async () => {
       await this.db.update(componentTable).set(component).where(eq(componentTable.id, component.id));
     });
   }
+  /**
+   * Asynchronously deletes a component from the database.
+   * @param {UUID} componentId - The unique identifier of the component to delete.
+   * @returns {Promise<void>} A Promise that resolves when the component is deleted.
+   */
   async deleteComponent(componentId) {
     return this.withDatabase(async () => {
       await this.db.delete(componentTable).where(eq(componentTable.id, componentId));
     });
   }
+  /**
+   * Asynchronously retrieves memories from the database based on the provided parameters.
+   * @param {Object} params - The parameters for retrieving memories.
+   * @param {UUID} params.roomId - The ID of the room to retrieve memories for.
+   * @param {number} [params.count] - The maximum number of memories to retrieve.
+   * @param {boolean} [params.unique] - Whether to retrieve unique memories only.
+   * @param {string} [params.tableName] - The name of the table to retrieve memories from.
+   * @param {number} [params.start] - The start date to retrieve memories from.
+   * @param {number} [params.end] - The end date to retrieve memories from.
+   * @returns {Promise<Memory[]>} A Promise that resolves to an array of memories.
+   */
   async getMemories(params) {
-    if (!params.tableName) throw new Error("tableName is required");
-    if (!params.roomId) throw new Error("roomId is required");
+    const { entityId, agentId, roomId, tableName, count: count2, unique: unique7, start, end } = params;
+    if (!tableName) throw new Error("tableName is required");
+    if (!roomId && !entityId && !agentId)
+      throw new Error("roomId, entityId, or agentId is required");
     return this.withDatabase(async () => {
-      const conditions = [
-        eq(memoryTable.type, params.tableName),
-        eq(memoryTable.roomId, params.roomId)
-      ];
-      if (params.start) {
-        conditions.push(gte(memoryTable.createdAt, params.start));
+      const conditions = [eq(memoryTable.type, tableName)];
+      if (start) {
+        conditions.push(gte(memoryTable.createdAt, start));
       }
-      if (params.end) {
-        conditions.push(lte(memoryTable.createdAt, params.end));
+      if (entityId) {
+        conditions.push(eq(memoryTable.entityId, entityId));
       }
-      if (params.unique) {
+      if (roomId) {
+        conditions.push(eq(memoryTable.roomId, roomId));
+      }
+      if (end) {
+        conditions.push(lte(memoryTable.createdAt, end));
+      }
+      if (unique7) {
         conditions.push(eq(memoryTable.unique, true));
       }
-      conditions.push(eq(memoryTable.agentId, this.agentId));
+      if (agentId) {
+        conditions.push(eq(memoryTable.agentId, agentId));
+      }
       const query = this.db.select({
         memory: {
           id: memoryTable.id,
@@ -920,7 +880,8 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
           entityId: memoryTable.entityId,
           agentId: memoryTable.agentId,
           roomId: memoryTable.roomId,
-          unique: memoryTable.unique
+          unique: memoryTable.unique,
+          metadata: memoryTable.metadata
         },
         embedding: embeddingTable[this.embeddingDimension]
       }).from(memoryTable).leftJoin(embeddingTable, eq(embeddingTable.memoryId, memoryTable.id)).where(and(...conditions)).orderBy(desc(memoryTable.createdAt));
@@ -934,10 +895,19 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
         agentId: row.memory.agentId,
         roomId: row.memory.roomId,
         unique: row.memory.unique,
+        metadata: row.memory.metadata,
         embedding: row.embedding ? Array.from(row.embedding) : void 0
       }));
     });
   }
+  /**
+   * Asynchronously retrieves memories from the database based on the provided parameters.
+   * @param {Object} params - The parameters for retrieving memories.
+   * @param {UUID[]} params.roomIds - The IDs of the rooms to retrieve memories for.
+   * @param {string} params.tableName - The name of the table to retrieve memories from.
+   * @param {number} [params.limit] - The maximum number of memories to retrieve.
+   * @returns {Promise<Memory[]>} A Promise that resolves to an array of memories.
+   */
   async getMemoriesByRoomIds(params) {
     return this.withDatabase(async () => {
       if (params.roomIds.length === 0) return [];
@@ -954,7 +924,8 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
         entityId: memoryTable.entityId,
         agentId: memoryTable.agentId,
         roomId: memoryTable.roomId,
-        unique: memoryTable.unique
+        unique: memoryTable.unique,
+        metadata: memoryTable.metadata
       }).from(memoryTable).where(and(...conditions)).orderBy(desc(memoryTable.createdAt));
       const rows = params.limit ? await query.limit(params.limit) : await query;
       return rows.map((row) => ({
@@ -964,10 +935,16 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
         entityId: row.entityId,
         agentId: row.agentId,
         roomId: row.roomId,
-        unique: row.unique
+        unique: row.unique,
+        metadata: row.metadata
       }));
     });
   }
+  /**
+   * Asynchronously retrieves a memory by its unique identifier.
+   * @param {UUID} id - The unique identifier of the memory to retrieve.
+   * @returns {Promise<Memory | null>} A Promise that resolves to the memory if found, null otherwise.
+   */
   async getMemoryById(id) {
     return this.withDatabase(async () => {
       const result = await this.db.select({
@@ -988,6 +965,13 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       };
     });
   }
+  /**
+   * Asynchronously retrieves memories from the database based on the provided parameters.
+   * @param {Object} params - The parameters for retrieving memories.
+   * @param {UUID[]} params.memoryIds - The IDs of the memories to retrieve.
+   * @param {string} [params.tableName] - The name of the table to retrieve memories from.
+   * @returns {Promise<Memory[]>} A Promise that resolves to an array of memories.
+   */
   async getMemoriesByIds(memoryIds, tableName) {
     return this.withDatabase(async () => {
       if (memoryIds.length === 0) return [];
@@ -1007,14 +991,26 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
         agentId: row.memory.agentId,
         roomId: row.memory.roomId,
         unique: row.memory.unique,
+        metadata: row.memory.metadata,
         embedding: row.embedding ?? void 0
       }));
     });
   }
+  /**
+   * Asynchronously retrieves cached embeddings from the database based on the provided parameters.
+   * @param {Object} opts - The parameters for retrieving cached embeddings.
+   * @param {string} opts.query_table_name - The name of the table to retrieve embeddings from.
+   * @param {number} opts.query_threshold - The threshold for the levenshtein distance.
+   * @param {string} opts.query_input - The input string to search for.
+   * @param {string} opts.query_field_name - The name of the field to retrieve embeddings from.
+   * @param {string} opts.query_field_sub_name - The name of the sub-field to retrieve embeddings from.
+   * @param {number} opts.query_match_count - The maximum number of matches to retrieve.
+   * @returns {Promise<{ embedding: number[]; levenshtein_score: number }[]>} A Promise that resolves to an array of cached embeddings.
+   */
   async getCachedEmbeddings(opts) {
     return this.withDatabase(async () => {
       try {
-        const results = await this.db.execute(sql13`
+        const results = await this.db.execute(sql12`
                     WITH content_text AS (
                         SELECT
                             m.id,
@@ -1066,12 +1062,21 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       }
     });
   }
+  /**
+   * Asynchronously logs an event in the database.
+   * @param {Object} params - The parameters for logging an event.
+   * @param {Object} params.body - The body of the event to log.
+   * @param {UUID} params.entityId - The ID of the entity associated with the event.
+   * @param {UUID} params.roomId - The ID of the room associated with the event.
+   * @param {string} params.type - The type of the event to log.
+   * @returns {Promise<void>} A Promise that resolves when the event is logged.
+   */
   async log(params) {
     return this.withDatabase(async () => {
       try {
         await this.db.transaction(async (tx) => {
           await tx.insert(logTable).values({
-            body: sql13`${params.body}::jsonb`,
+            body: sql12`${params.body}::jsonb`,
             entityId: params.entityId,
             roomId: params.roomId,
             type: params.type
@@ -1088,6 +1093,50 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       }
     });
   }
+  /**
+   * Asynchronously retrieves logs from the database based on the provided parameters.
+   * @param {Object} params - The parameters for retrieving logs.
+   * @param {UUID} params.entityId - The ID of the entity associated with the logs.
+   * @param {UUID} [params.roomId] - The ID of the room associated with the logs.
+   * @param {string} [params.type] - The type of the logs to retrieve.
+   * @param {number} [params.count] - The maximum number of logs to retrieve.
+   * @param {number} [params.offset] - The offset to retrieve logs from.
+   * @returns {Promise<Log[]>} A Promise that resolves to an array of logs.
+   */
+  async getLogs(params) {
+    const { entityId, roomId, type, count: count2, offset } = params;
+    return this.withDatabase(async () => {
+      const result = await this.db.select().from(logTable).where(
+        and(
+          eq(logTable.entityId, entityId),
+          roomId ? eq(logTable.roomId, roomId) : void 0,
+          type ? eq(logTable.type, type) : void 0
+        )
+      ).orderBy(desc(logTable.createdAt)).limit(count2 ?? 10).offset(offset ?? 0);
+      return result;
+    });
+  }
+  /**
+   * Asynchronously deletes a log from the database based on the provided parameters.
+   * @param {UUID} logId - The ID of the log to delete.
+   * @returns {Promise<void>} A Promise that resolves when the log is deleted.
+   */
+  async deleteLog(logId) {
+    return this.withDatabase(async () => {
+      await this.db.delete(logTable).where(eq(logTable.id, logId));
+    });
+  }
+  /**
+   * Asynchronously searches for memories in the database based on the provided parameters.
+   * @param {Object} params - The parameters for searching for memories.
+   * @param {string} params.tableName - The name of the table to search for memories in.
+   * @param {UUID} params.roomId - The ID of the room to search for memories in.
+   * @param {number[]} params.embedding - The embedding to search for.
+   * @param {number} [params.match_threshold] - The threshold for the cosine distance.
+   * @param {number} [params.count] - The maximum number of memories to retrieve.
+   * @param {boolean} [params.unique] - Whether to retrieve unique memories only.
+   * @returns {Promise<Memory[]>} A Promise that resolves to an array of memories.
+   */
   async searchMemories(params) {
     return await this.searchMemoriesByEmbedding(params.embedding, {
       match_threshold: params.match_threshold,
@@ -1097,30 +1146,21 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       tableName: params.tableName
     });
   }
-  async updateGoalStatus(params) {
-    return this.withDatabase(async () => {
-      try {
-        await this.db.transaction(async (tx) => {
-          await tx.update(goalTable).set({
-            status: params.status
-          }).where(eq(goalTable.id, params.goalId));
-        });
-      } catch (error) {
-        logger.error("Failed to update goal status:", {
-          goalId: params.goalId,
-          status: params.status,
-          error: error instanceof Error ? error.message : String(error)
-        });
-        throw error;
-      }
-    });
-  }
+  /**
+   * Asynchronously searches for memories in the database based on the provided parameters.
+   * @param {number[]} embedding - The embedding to search for.
+   * @param {Object} params - The parameters for searching for memories.
+   * @param {number} [params.match_threshold] - The threshold for the cosine distance.
+   * @param {number} [params.count] - The maximum number of memories to retrieve.
+   * @param {UUID} [params.roomId] - The ID of the room to search for memories in.
+   * @param {boolean} [params.unique] - Whether to retrieve unique memories only.
+   * @param {string} [params.tableName] - The name of the table to search for memories in.
+   * @returns {Promise<Memory[]>} A Promise that resolves to an array of memories.
+   */
   async searchMemoriesByEmbedding(embedding, params) {
     return this.withDatabase(async () => {
-      const cleanVector = embedding.map(
-        (n) => Number.isFinite(n) ? Number(n.toFixed(6)) : 0
-      );
-      const similarity = sql13`1 - (${cosineDistance(
+      const cleanVector = embedding.map((n) => Number.isFinite(n) ? Number(n.toFixed(6)) : 0);
+      const similarity = sql12`1 - (${cosineDistance(
         embeddingTable[this.embeddingDimension],
         cleanVector
       )})`;
@@ -1149,11 +1189,18 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
         agentId: row.memory.agentId,
         roomId: row.memory.roomId,
         unique: row.memory.unique,
+        metadata: row.memory.metadata,
         embedding: row.embedding ?? void 0,
         similarity: row.similarity
       }));
     });
   }
+  /**
+   * Asynchronously creates a new memory in the database.
+   * @param {Memory & { metadata?: MemoryMetadata }} memory - The memory object to create.
+   * @param {string} tableName - The name of the table to create the memory in.
+   * @returns {Promise<UUID>} A Promise that resolves to the ID of the created memory.
+   */
   async createMemory(memory, tableName) {
     logger.debug("DrizzleAdapter createMemory:", {
       memoryId: memory.id,
@@ -1162,15 +1209,12 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
     });
     let isUnique = true;
     if (memory.embedding && Array.isArray(memory.embedding)) {
-      const similarMemories = await this.searchMemoriesByEmbedding(
-        memory.embedding,
-        {
-          tableName,
-          roomId: memory.roomId,
-          match_threshold: 0.95,
-          count: 1
-        }
-      );
+      const similarMemories = await this.searchMemoriesByEmbedding(memory.embedding, {
+        tableName,
+        roomId: memory.roomId,
+        match_threshold: 0.95,
+        count: 1
+      });
       isUnique = similarMemories.length === 0;
     }
     const contentToInsert = typeof memory.content === "string" ? JSON.parse(memory.content) : memory.content;
@@ -1180,8 +1224,8 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
         {
           id: memoryId,
           type: tableName,
-          content: sql13`${contentToInsert}::jsonb`,
-          metadata: sql13`${memory.metadata || {}}::jsonb`,
+          content: sql12`${contentToInsert}::jsonb`,
+          metadata: sql12`${memory.metadata || {}}::jsonb`,
           entityId: memory.entityId,
           roomId: memory.roomId,
           agentId: memory.agentId,
@@ -1204,29 +1248,124 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
     });
     return memoryId;
   }
-  async removeMemory(memoryId, tableName) {
+  /**
+   * Updates an existing memory in the database.
+   * @param memory The memory object with updated content and optional embedding
+   * @returns Promise resolving to boolean indicating success
+   */
+  async updateMemory(memory) {
+    return this.withDatabase(async () => {
+      try {
+        logger.debug("Updating memory:", {
+          memoryId: memory.id,
+          hasEmbedding: !!memory.embedding
+        });
+        await this.db.transaction(async (tx) => {
+          if (memory.content) {
+            const contentToUpdate = typeof memory.content === "string" ? JSON.parse(memory.content) : memory.content;
+            await tx.update(memoryTable).set({
+              content: sql12`${contentToUpdate}::jsonb`,
+              ...memory.metadata && { metadata: sql12`${memory.metadata}::jsonb` }
+            }).where(eq(memoryTable.id, memory.id));
+          } else if (memory.metadata) {
+            await tx.update(memoryTable).set({
+              metadata: sql12`${memory.metadata}::jsonb`
+            }).where(eq(memoryTable.id, memory.id));
+          }
+          if (memory.embedding && Array.isArray(memory.embedding)) {
+            const cleanVector = memory.embedding.map(
+              (n) => Number.isFinite(n) ? Number(n.toFixed(6)) : 0
+            );
+            const existingEmbedding = await tx.select({ id: embeddingTable.id }).from(embeddingTable).where(eq(embeddingTable.memoryId, memory.id)).limit(1);
+            if (existingEmbedding.length > 0) {
+              const updateValues = {};
+              updateValues[this.embeddingDimension] = cleanVector;
+              await tx.update(embeddingTable).set(updateValues).where(eq(embeddingTable.memoryId, memory.id));
+            } else {
+              const embeddingValues = {
+                id: v4(),
+                memoryId: memory.id,
+                createdAt: Date.now()
+              };
+              embeddingValues[this.embeddingDimension] = cleanVector;
+              await tx.insert(embeddingTable).values([embeddingValues]);
+            }
+          }
+        });
+        logger.debug("Memory updated successfully:", {
+          memoryId: memory.id
+        });
+        return true;
+      } catch (error) {
+        logger.error("Error updating memory:", {
+          error: error instanceof Error ? error.message : String(error),
+          memoryId: memory.id
+        });
+        return false;
+      }
+    });
+  }
+  /**
+   * Asynchronously deletes a memory from the database based on the provided parameters.
+   * @param {UUID} memoryId - The ID of the memory to delete.
+   * @returns {Promise<void>} A Promise that resolves when the memory is deleted.
+   */
+  async deleteMemory(memoryId) {
     return this.withDatabase(async () => {
       await this.db.transaction(async (tx) => {
+        await this.deleteMemoryFragments(tx, memoryId);
         await tx.delete(embeddingTable).where(eq(embeddingTable.memoryId, memoryId));
-        await tx.delete(memoryTable).where(
-          and(eq(memoryTable.id, memoryId), eq(memoryTable.type, tableName))
-        );
+        await tx.delete(memoryTable).where(eq(memoryTable.id, memoryId));
       });
-      logger.debug("Memory removed successfully:", {
-        memoryId,
-        tableName
+      logger.debug("Memory and related fragments removed successfully:", {
+        memoryId
       });
     });
   }
-  async removeAllMemories(roomId, tableName) {
+  /**
+   * Deletes all memory fragments that reference a specific document memory
+   * @param tx The database transaction
+   * @param documentId The UUID of the document memory whose fragments should be deleted
+   * @private
+   */
+  async deleteMemoryFragments(tx, documentId) {
+    const fragmentsToDelete = await this.getMemoryFragments(tx, documentId);
+    if (fragmentsToDelete.length > 0) {
+      const fragmentIds = fragmentsToDelete.map((f) => f.id);
+      await tx.delete(embeddingTable).where(inArray(embeddingTable.memoryId, fragmentIds));
+      await tx.delete(memoryTable).where(inArray(memoryTable.id, fragmentIds));
+      logger.debug("Deleted related fragments:", {
+        documentId,
+        fragmentCount: fragmentsToDelete.length
+      });
+    }
+  }
+  /**
+   * Retrieves all memory fragments that reference a specific document memory
+   * @param tx The database transaction
+   * @param documentId The UUID of the document memory whose fragments should be retrieved
+   * @returns An array of memory fragments
+   * @private
+   */
+  async getMemoryFragments(tx, documentId) {
+    const fragments = await tx.select({ id: memoryTable.id }).from(memoryTable).where(
+      and(
+        eq(memoryTable.agentId, this.agentId),
+        sql12`${memoryTable.metadata}->>'documentId' = ${documentId}`
+      )
+    );
+    return fragments;
+  }
+  /**
+   * Asynchronously deletes all memories from the database based on the provided parameters.
+   * @param {UUID} roomId - The ID of the room to delete memories from.
+   * @param {string} tableName - The name of the table to delete memories from.
+   * @returns {Promise<void>} A Promise that resolves when the memories are deleted.
+   */
+  async deleteAllMemories(roomId, tableName) {
     return this.withDatabase(async () => {
       await this.db.transaction(async (tx) => {
-        const memoryIds = await tx.select({ id: memoryTable.id }).from(memoryTable).where(
-          and(
-            eq(memoryTable.roomId, roomId),
-            eq(memoryTable.type, tableName)
-          )
-        );
+        const memoryIds = await tx.select({ id: memoryTable.id }).from(memoryTable).where(and(eq(memoryTable.roomId, roomId), eq(memoryTable.type, tableName)));
         if (memoryIds.length > 0) {
           await tx.delete(embeddingTable).where(
             inArray(
@@ -1234,12 +1373,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
               memoryIds.map((m) => m.id)
             )
           );
-          await tx.delete(memoryTable).where(
-            and(
-              eq(memoryTable.roomId, roomId),
-              eq(memoryTable.type, tableName)
-            )
-          );
+          await tx.delete(memoryTable).where(and(eq(memoryTable.roomId, roomId), eq(memoryTable.type, tableName)));
         }
       });
       logger.debug("All memories removed successfully:", {
@@ -1248,113 +1382,29 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       });
     });
   }
+  /**
+   * Asynchronously counts the number of memories in the database based on the provided parameters.
+   * @param {UUID} roomId - The ID of the room to count memories in.
+   * @param {boolean} [unique] - Whether to count unique memories only.
+   * @param {string} [tableName] - The name of the table to count memories in.
+   * @returns {Promise<number>} A Promise that resolves to the number of memories.
+   */
   async countMemories(roomId, unique7 = true, tableName = "") {
     if (!tableName) throw new Error("tableName is required");
     return this.withDatabase(async () => {
-      const conditions = [
-        eq(memoryTable.roomId, roomId),
-        eq(memoryTable.type, tableName)
-      ];
+      const conditions = [eq(memoryTable.roomId, roomId), eq(memoryTable.type, tableName)];
       if (unique7) {
         conditions.push(eq(memoryTable.unique, true));
       }
-      const result = await this.db.select({ count: sql13`count(*)` }).from(memoryTable).where(and(...conditions));
+      const result = await this.db.select({ count: sql12`count(*)` }).from(memoryTable).where(and(...conditions));
       return Number(result[0]?.count ?? 0);
     });
   }
-  async getGoals(params) {
-    return this.withDatabase(async () => {
-      const conditions = [eq(goalTable.roomId, params.roomId)];
-      if (params.entityId) {
-        conditions.push(eq(goalTable.entityId, params.entityId));
-      }
-      if (params.onlyInProgress) {
-        conditions.push(eq(goalTable.status, "IN_PROGRESS"));
-      }
-      const query = this.db.select().from(goalTable).where(and(...conditions)).orderBy(desc(goalTable.createdAt));
-      const result = await (params.count ? query.limit(params.count) : query);
-      return result.map((row) => ({
-        id: row.id,
-        roomId: row.roomId,
-        entityId: row.entityId,
-        name: row.name ?? "",
-        status: row.status ?? "NOT_STARTED",
-        description: row.description ?? "",
-        objectives: row.objectives,
-        createdAt: row.createdAt
-      }));
-    });
-  }
-  async updateGoal(goal) {
-    return this.withDatabase(async () => {
-      try {
-        await this.db.transaction(async (tx) => {
-          await tx.update(goalTable).set({
-            name: goal.name,
-            status: goal.status,
-            objectives: goal.objectives
-          }).where(eq(goalTable.id, goal.id));
-        });
-      } catch (error) {
-        logger.error("Failed to update goal:", {
-          error: error instanceof Error ? error.message : String(error),
-          goalId: goal.id,
-          status: goal.status
-        });
-        throw error;
-      }
-    });
-  }
-  async createGoal(goal) {
-    return this.withDatabase(async () => {
-      try {
-        await this.db.transaction(async (tx) => {
-          await tx.insert(goalTable).values({
-            id: goal.id ?? v4(),
-            roomId: goal.roomId,
-            entityId: goal.entityId,
-            name: goal.name,
-            status: goal.status,
-            objectives: sql13`${goal.objectives}::jsonb`
-          });
-        });
-      } catch (error) {
-        logger.error("Failed to update goal:", {
-          goalId: goal.id,
-          error: error instanceof Error ? error.message : String(error),
-          status: goal.status
-        });
-        throw error;
-      }
-    });
-  }
-  async removeGoal(goalId) {
-    if (!goalId) throw new Error("Goal ID is required");
-    return this.withDatabase(async () => {
-      try {
-        await this.db.transaction(async (tx) => {
-          await tx.delete(goalTable).where(eq(goalTable.id, goalId));
-        });
-        logger.debug("Goal removal attempt:", {
-          goalId,
-          removed: true
-        });
-      } catch (error) {
-        logger.error("Failed to remove goal:", {
-          error: error instanceof Error ? error.message : String(error),
-          goalId
-        });
-        throw error;
-      }
-    });
-  }
-  async removeAllGoals(roomId) {
-    return this.withDatabase(async () => {
-      await this.db.transaction(async (tx) => {
-        await tx.delete(goalTable).where(eq(goalTable.roomId, roomId));
-      });
-    });
-  }
+  /**
+   * Asynchronously retrieves a room from the database based on the provided parameters.
+   * @param {UUID} roomId - The ID of the room to retrieve.
+   * @returns {Promise<Room | null>} A Promise that resolves to the room if found, null otherwise.
+   */
   async getRoom(roomId) {
     return this.withDatabase(async () => {
       const result = await this.db.select({
@@ -1365,33 +1415,38 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
         worldId: roomTable.worldId,
         type: roomTable.type,
         source: roomTable.source
-      }).from(roomTable).where(
-        and(eq(roomTable.id, roomId), eq(roomTable.agentId, this.agentId))
-      ).limit(1);
+      }).from(roomTable).where(and(eq(roomTable.id, roomId), eq(roomTable.agentId, this.agentId))).limit(1);
       if (result.length === 0) return null;
       return result[0];
     });
   }
+  /**
+   * Asynchronously retrieves all rooms from the database based on the provided parameters.
+   * @param {UUID} worldId - The ID of the world to retrieve rooms from.
+   * @returns {Promise<Room[]>} A Promise that resolves to an array of rooms.
+   */
   async getRooms(worldId) {
     return this.withDatabase(async () => {
       const result = await this.db.select().from(roomTable).where(eq(roomTable.worldId, worldId));
       return result;
     });
   }
+  /**
+   * Asynchronously updates a room in the database based on the provided parameters.
+   * @param {Room} room - The room object to update.
+   * @returns {Promise<void>} A Promise that resolves when the room is updated.
+   */
   async updateRoom(room) {
     return this.withDatabase(async () => {
       await this.db.update(roomTable).set({ ...room, agentId: this.agentId }).where(eq(roomTable.id, room.id));
     });
   }
-  async createRoom({
-    id,
-    name,
-    source,
-    type,
-    channelId,
-    serverId,
-    worldId
-  }) {
+  /**
+   * Asynchronously creates a new room in the database based on the provided parameters.
+   * @param {Room} room - The room object to create.
+   * @returns {Promise<UUID>} A Promise that resolves to the ID of the created room.
+   */
+  async createRoom({ id, name, source, type, channelId, serverId, worldId }) {
     return this.withDatabase(async () => {
       const newRoomId = id || v4();
       await this.db.insert(roomTable).values({
@@ -1407,6 +1462,11 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       return newRoomId;
     });
   }
+  /**
+   * Asynchronously deletes a room from the database based on the provided parameters.
+   * @param {UUID} roomId - The ID of the room to delete.
+   * @returns {Promise<void>} A Promise that resolves when the room is deleted.
+   */
   async deleteRoom(roomId) {
     if (!roomId) throw new Error("Room ID is required");
     return this.withDatabase(async () => {
@@ -1415,28 +1475,36 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       });
     });
   }
+  /**
+   * Asynchronously retrieves all rooms for a participant from the database based on the provided parameters.
+   * @param {UUID} entityId - The ID of the entity to retrieve rooms for.
+   * @returns {Promise<UUID[]>} A Promise that resolves to an array of room IDs.
+   */
   async getRoomsForParticipant(entityId) {
     return this.withDatabase(async () => {
-      const result = await this.db.select({ roomId: participantTable.roomId }).from(participantTable).innerJoin(roomTable, eq(participantTable.roomId, roomTable.id)).where(
-        and(
-          eq(participantTable.entityId, entityId),
-          eq(roomTable.agentId, this.agentId)
-        )
-      );
+      const result = await this.db.select({ roomId: participantTable.roomId }).from(participantTable).innerJoin(roomTable, eq(participantTable.roomId, roomTable.id)).where(and(eq(participantTable.entityId, entityId), eq(roomTable.agentId, this.agentId)));
       return result.map((row) => row.roomId);
     });
   }
+  /**
+   * Asynchronously retrieves all rooms for a list of participants from the database based on the provided parameters.
+   * @param {UUID[]} entityIds - The IDs of the entities to retrieve rooms for.
+   * @returns {Promise<UUID[]>} A Promise that resolves to an array of room IDs.
+   */
   async getRoomsForParticipants(entityIds) {
     return this.withDatabase(async () => {
       const result = await this.db.selectDistinct({ roomId: participantTable.roomId }).from(participantTable).innerJoin(roomTable, eq(participantTable.roomId, roomTable.id)).where(
-        and(
-          inArray(participantTable.entityId, entityIds),
-          eq(roomTable.agentId, this.agentId)
-        )
+        and(inArray(participantTable.entityId, entityIds), eq(roomTable.agentId, this.agentId))
       );
       return result.map((row) => row.roomId);
     });
   }
+  /**
+   * Asynchronously adds a participant to a room in the database based on the provided parameters.
+   * @param {UUID} entityId - The ID of the entity to add to the room.
+   * @param {UUID} roomId - The ID of the room to add the entity to.
+   * @returns {Promise<boolean>} A Promise that resolves to a boolean indicating whether the participant was added successfully.
+   */
   async addParticipant(entityId, roomId) {
     return this.withDatabase(async () => {
       try {
@@ -1457,15 +1525,18 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       }
     });
   }
+  /**
+   * Asynchronously removes a participant from a room in the database based on the provided parameters.
+   * @param {UUID} entityId - The ID of the entity to remove from the room.
+   * @param {UUID} roomId - The ID of the room to remove the entity from.
+   * @returns {Promise<boolean>} A Promise that resolves to a boolean indicating whether the participant was removed successfully.
+   */
   async removeParticipant(entityId, roomId) {
     return this.withDatabase(async () => {
       try {
         const result = await this.db.transaction(async (tx) => {
           return await tx.delete(participantTable).where(
-            and(
-              eq(participantTable.entityId, entityId),
-              eq(participantTable.roomId, roomId)
-            )
+            and(eq(participantTable.entityId, entityId), eq(participantTable.roomId, roomId))
           ).returning();
         });
         const removed = result.length > 0;
@@ -1485,6 +1556,11 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       }
     });
   }
+  /**
+   * Asynchronously retrieves all participants for an entity from the database based on the provided parameters.
+   * @param {UUID} entityId - The ID of the entity to retrieve participants for.
+   * @returns {Promise<Participant[]>} A Promise that resolves to an array of participants.
+   */
   async getParticipantsForEntity(entityId) {
     return this.withDatabase(async () => {
       const result = await this.db.select({
@@ -1502,17 +1578,25 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       }));
     });
   }
+  /**
+   * Asynchronously retrieves all participants for a room from the database based on the provided parameters.
+   * @param {UUID} roomId - The ID of the room to retrieve participants for.
+   * @returns {Promise<UUID[]>} A Promise that resolves to an array of entity IDs.
+   */
   async getParticipantsForRoom(roomId) {
     return this.withDatabase(async () => {
       const result = await this.db.select({ entityId: participantTable.entityId }).from(participantTable).where(
-        and(
-          eq(participantTable.roomId, roomId),
-          eq(participantTable.agentId, this.agentId)
-        )
+        and(eq(participantTable.roomId, roomId), eq(participantTable.agentId, this.agentId))
       );
       return result.map((row) => row.entityId);
     });
   }
+  /**
+   * Asynchronously retrieves the user state for a participant in a room from the database based on the provided parameters.
+   * @param {UUID} roomId - The ID of the room to retrieve the participant's user state for.
+   * @param {UUID} entityId - The ID of the entity to retrieve the user state for.
+   * @returns {Promise<"FOLLOWED" | "MUTED" | null>} A Promise that resolves to the participant's user state.
+   */
   async getParticipantUserState(roomId, entityId) {
     return this.withDatabase(async () => {
       const result = await this.db.select({ roomState: participantTable.roomState }).from(participantTable).where(
@@ -1525,6 +1609,13 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       return result[0]?.roomState ?? null;
     });
   }
+  /**
+   * Asynchronously sets the user state for a participant in a room in the database based on the provided parameters.
+   * @param {UUID} roomId - The ID of the room to set the participant's user state for.
+   * @param {UUID} entityId - The ID of the entity to set the user state for.
+   * @param {string} state - The state to set the participant's user state to.
+   * @returns {Promise<void>} A Promise that resolves when the participant's user state is set.
+   */
   async setParticipantUserState(roomId, entityId, state) {
     return this.withDatabase(async () => {
       try {
@@ -1548,6 +1639,15 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       }
     });
   }
+  /**
+   * Asynchronously creates a new relationship in the database based on the provided parameters.
+   * @param {Object} params - The parameters for creating a new relationship.
+   * @param {UUID} params.sourceEntityId - The ID of the source entity.
+   * @param {UUID} params.targetEntityId - The ID of the target entity.
+   * @param {string[]} [params.tags] - The tags for the relationship.
+   * @param {Object} [params.metadata] - The metadata for the relationship.
+   * @returns {Promise<boolean>} A Promise that resolves to a boolean indicating whether the relationship was created successfully.
+   */
   async createRelationship(params) {
     return this.withDatabase(async () => {
       const id = v4();
@@ -1571,6 +1671,11 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       }
     });
   }
+  /**
+   * Asynchronously updates an existing relationship in the database based on the provided parameters.
+   * @param {Relationship} relationship - The relationship object to update.
+   * @returns {Promise<void>} A Promise that resolves when the relationship is updated.
+   */
   async updateRelationship(relationship) {
     return this.withDatabase(async () => {
       try {
@@ -1587,6 +1692,13 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       }
     });
   }
+  /**
+   * Asynchronously retrieves a relationship from the database based on the provided parameters.
+   * @param {Object} params - The parameters for retrieving a relationship.
+   * @param {UUID} params.sourceEntityId - The ID of the source entity.
+   * @param {UUID} params.targetEntityId - The ID of the target entity.
+   * @returns {Promise<Relationship | null>} A Promise that resolves to the relationship if found, null otherwise.
+   */
   async getRelationship(params) {
     return this.withDatabase(async () => {
       try {
@@ -1618,6 +1730,13 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       }
     });
   }
+  /**
+   * Asynchronously retrieves all relationships from the database based on the provided parameters.
+   * @param {Object} params - The parameters for retrieving relationships.
+   * @param {UUID} params.entityId - The ID of the entity to retrieve relationships for.
+   * @param {string[]} [params.tags] - The tags to filter relationships by.
+   * @returns {Promise<Relationship[]>} A Promise that resolves to an array of relationships.
+   */
   async getRelationships(params) {
     return this.withDatabase(async () => {
       try {
@@ -1633,9 +1752,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
         if (params.tags && params.tags.length > 0) {
           const tagParams = params.tags.map((tag) => `'${tag.replace(/'/g, "''")}'`).join(", ");
           query = query.where(
-            sql13`${relationshipTable.tags} @> ARRAY[${sql13.raw(
-              tagParams
-            )}]::text[]`
+            sql12`${relationshipTable.tags} @> ARRAY[${sql12.raw(tagParams)}]::text[]`
           );
         }
         const results = await query;
@@ -1657,12 +1774,15 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       }
     });
   }
+  /**
+   * Asynchronously retrieves a cache value from the database based on the provided key.
+   * @param {string} key - The key to retrieve the cache value for.
+   * @returns {Promise<T | undefined>} A Promise that resolves to the cache value if found, undefined otherwise.
+   */
   async getCache(key) {
     return this.withDatabase(async () => {
       try {
-        const result = await this.db.select().from(cacheTable).where(
-          and(eq(cacheTable.agentId, this.agentId), eq(cacheTable.key, key))
-        );
+        const result = await this.db.select().from(cacheTable).where(and(eq(cacheTable.agentId, this.agentId), eq(cacheTable.key, key)));
         return result[0]?.value;
       } catch (error) {
         logger.error("Error fetching cache", {
@@ -1674,6 +1794,12 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       }
     });
   }
+  /**
+   * Asynchronously sets a cache value in the database based on the provided key and value.
+   * @param {string} key - The key to set the cache value for.
+   * @param {T} value - The value to set in the cache.
+   * @returns {Promise<boolean>} A Promise that resolves to a boolean indicating whether the cache value was set successfully.
+   */
   async setCache(key, value) {
     return this.withDatabase(async () => {
       try {
@@ -1700,16 +1826,16 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       }
     });
   }
+  /**
+   * Asynchronously deletes a cache value from the database based on the provided key.
+   * @param {string} key - The key to delete the cache value for.
+   * @returns {Promise<boolean>} A Promise that resolves to a boolean indicating whether the cache value was deleted successfully.
+   */
   async deleteCache(key) {
     return this.withDatabase(async () => {
       try {
         await this.db.transaction(async (tx) => {
-          await tx.delete(cacheTable).where(
-            and(
-              eq(cacheTable.agentId, this.agentId),
-              eq(cacheTable.key, key)
-            )
-          );
+          await tx.delete(cacheTable).where(and(eq(cacheTable.agentId, this.agentId), eq(cacheTable.key, key)));
         });
         return true;
       } catch (error) {
@@ -1722,6 +1848,11 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       }
     });
   }
+  /**
+   * Asynchronously creates a new world in the database based on the provided parameters.
+   * @param {World} world - The world object to create.
+   * @returns {Promise<UUID>} A Promise that resolves to the ID of the created world.
+   */
   async createWorld(world) {
     return this.withDatabase(async () => {
       const newWorldId = world.id || v4();
@@ -1732,32 +1863,51 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       return newWorldId;
     });
   }
+  /**
+   * Asynchronously retrieves a world from the database based on the provided parameters.
+   * @param {UUID} id - The ID of the world to retrieve.
+   * @returns {Promise<World | null>} A Promise that resolves to the world if found, null otherwise.
+   */
   async getWorld(id) {
     return this.withDatabase(async () => {
       const result = await this.db.select().from(worldTable).where(eq(worldTable.id, id));
       return result[0];
     });
   }
+  /**
+   * Asynchronously retrieves all worlds from the database based on the provided parameters.
+   * @returns {Promise<World[]>} A Promise that resolves to an array of worlds.
+   */
   async getAllWorlds() {
     return this.withDatabase(async () => {
       const result = await this.db.select().from(worldTable).where(eq(worldTable.agentId, this.agentId));
       return result;
     });
   }
+  /**
+   * Asynchronously updates an existing world in the database based on the provided parameters.
+   * @param {World} world - The world object to update.
+   * @returns {Promise<void>} A Promise that resolves when the world is updated.
+   */
   async updateWorld(world) {
     return this.withDatabase(async () => {
       await this.db.update(worldTable).set(world).where(eq(worldTable.id, world.id));
     });
   }
+  /**
+   * Asynchronously removes a world from the database based on the provided parameters.
+   * @param {UUID} id - The ID of the world to remove.
+   * @returns {Promise<void>} A Promise that resolves when the world is removed.
+   */
   async removeWorld(id) {
     return this.withDatabase(async () => {
       await this.db.delete(worldTable).where(eq(worldTable.id, id));
     });
   }
   /**
-   * Creates a new task in the database.
-   * @param task The task object to create
-   * @returns Promise resolving to the UUID of the created task
+   * Asynchronously creates a new task in the database based on the provided parameters.
+   * @param {Task} task - The task object to create.
+   * @returns {Promise<UUID>} A Promise that resolves to the ID of the created task.
    */
   async createTask(task) {
     return this.withRetry(async () => {
@@ -1782,7 +1932,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
     });
   }
   /**
-   * Retrieves tasks based on specified parameters.
+   * Asynchronously retrieves tasks based on specified parameters.
    * @param params Object containing optional roomId and tags to filter tasks
    * @returns Promise resolving to an array of Task objects
    */
@@ -1795,9 +1945,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
         }
         if (params.tags && params.tags.length > 0) {
           const tagParams = params.tags.map((tag) => `'${tag.replace(/'/g, "''")}'`).join(", ");
-          query = query.where(
-            sql13`${taskTable.tags} @> ARRAY[${sql13.raw(tagParams)}]::text[]`
-          );
+          query = query.where(sql12`${taskTable.tags} @> ARRAY[${sql12.raw(tagParams)}]::text[]`);
         }
         const result = await query;
         return result.map((row) => ({
@@ -1813,16 +1961,14 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
     });
   }
   /**
-   * Retrieves a specific task by its name.
+   * Asynchronously retrieves a specific task by its name.
    * @param name The name of the task to retrieve
    * @returns Promise resolving to the Task object if found, null otherwise
    */
   async getTasksByName(name) {
     return this.withRetry(async () => {
       return this.withDatabase(async () => {
-        const result = await this.db.select().from(taskTable).where(
-          and(eq(taskTable.name, name), eq(taskTable.agentId, this.agentId))
-        );
+        const result = await this.db.select().from(taskTable).where(and(eq(taskTable.name, name), eq(taskTable.agentId, this.agentId)));
         return result.map((row) => ({
           id: row.id,
           name: row.name,
@@ -1836,7 +1982,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
     });
   }
   /**
-   * Retrieves a specific task by its ID.
+   * Asynchronously retrieves a specific task by its ID.
    * @param id The UUID of the task to retrieve
    * @returns Promise resolving to the Task object if found, null otherwise
    */
@@ -1861,7 +2007,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
     });
   }
   /**
-   * Updates an existing task in the database.
+   * Asynchronously updates an existing task in the database.
    * @param id The UUID of the task to update
    * @param task Partial Task object containing the fields to update
    * @returns Promise resolving when the update is complete
@@ -1871,8 +2017,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       await this.withDatabase(async () => {
         const updateValues = {};
         if (task.name !== void 0) updateValues.name = task.name;
-        if (task.description !== void 0)
-          updateValues.description = task.description;
+        if (task.description !== void 0) updateValues.description = task.description;
         if (task.roomId !== void 0) updateValues.roomId = task.roomId;
         if (task.worldId !== void 0) updateValues.worldId = task.worldId;
         if (task.tags !== void 0) updateValues.tags = task.tags;
@@ -1892,29 +2037,25 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
             };
           }
         }
-        await this.db.update(taskTable).set(updateValues).where(
-          and(eq(taskTable.id, id), eq(taskTable.agentId, this.agentId))
-        );
+        await this.db.update(taskTable).set(updateValues).where(and(eq(taskTable.id, id), eq(taskTable.agentId, this.agentId)));
       });
     });
   }
   /**
-   * Deletes a task from the database.
+   * Asynchronously deletes a task from the database.
    * @param id The UUID of the task to delete
    * @returns Promise resolving when the deletion is complete
    */
   async deleteTask(id) {
     await this.withRetry(async () => {
       await this.withDatabase(async () => {
-        await this.db.delete(taskTable).where(
-          and(eq(taskTable.id, id), eq(taskTable.agentId, this.agentId))
-        );
+        await this.db.delete(taskTable).where(and(eq(taskTable.id, id), eq(taskTable.agentId, this.agentId)));
       });
     });
   }
 };
 
-// src/pg-lite/adapter.ts
+// src/pglite/adapter.ts
 var PgliteDatabaseAdapter = class extends BaseDrizzleAdapter {
   static {
     __name(this, "PgliteDatabaseAdapter");
@@ -2012,7 +2153,7 @@ var PgDatabaseAdapter = class extends BaseDrizzleAdapter {
   async init() {
     try {
       await this.manager.runMigrations();
-      logger3.info("PgDatabaseAdapter initialized successfully");
+      logger3.debug("PgDatabaseAdapter initialized successfully");
     } catch (error) {
       logger3.error("Failed to initialize PgDatabaseAdapter:", error);
       throw error;
@@ -2029,30 +2170,45 @@ var PgDatabaseAdapter = class extends BaseDrizzleAdapter {
 };
 
 // src/index.ts
-var pgLiteClientManager;
-var postgresConnectionManager;
+import { Pool } from "pg";
+var GLOBAL_SINGLETONS = Symbol.for("@elizaos/plugin-sql/global-singletons");
+var globalSymbols = global;
+if (!globalSymbols[GLOBAL_SINGLETONS]) {
+  globalSymbols[GLOBAL_SINGLETONS] = {};
+}
+var globalSingletons = globalSymbols[GLOBAL_SINGLETONS];
+function expandTildePath(filepath) {
+  if (filepath && typeof filepath === "string" && filepath.startsWith("~")) {
+    return filepath.replace(/^~/, os.homedir());
+  }
+  return filepath;
+}
+__name(expandTildePath, "expandTildePath");
 function createDatabaseAdapter(config, agentId) {
-  console.log("*** postgresUrl", config.postgresUrl);
+  if (config.dataDir) {
+    config.dataDir = expandTildePath(config.dataDir);
+  }
   if (config.postgresUrl) {
-    if (!postgresConnectionManager) {
-      postgresConnectionManager = new PostgresConnectionManager(
+    const pool = new Pool({ connectionString: config.postgresUrl });
+    if (!globalSingletons.postgresConnectionManager) {
+      globalSingletons.postgresConnectionManager = new PostgresConnectionManager(
+        pool,
         config.postgresUrl
       );
     }
-    return new PgDatabaseAdapter(agentId, postgresConnectionManager);
+    return new PgDatabaseAdapter(agentId, globalSingletons.postgresConnectionManager);
   }
   const dataDir = config.dataDir ?? "./elizadb";
-  if (!pgLiteClientManager) {
-    pgLiteClientManager = new PGliteClientManager({ dataDir });
+  if (!globalSingletons.pgLiteClientManager) {
+    globalSingletons.pgLiteClientManager = new PGliteClientManager({ dataDir });
   }
-  return new PgliteDatabaseAdapter(agentId, pgLiteClientManager);
+  return new PgliteDatabaseAdapter(agentId, globalSingletons.pgLiteClientManager);
 }
 __name(createDatabaseAdapter, "createDatabaseAdapter");
-var drizzlePlugin = {
-  name: "drizzle",
-  description: "Database adapter plugin using Drizzle ORM",
+var sqlPlugin = {
+  name: "sql",
+  description: "SQL database adapter plugin using Drizzle ORM",
   init: /* @__PURE__ */ __name(async (_, runtime) => {
-    console.log("*** drizzlePlugin init");
     const config = {
       dataDir: runtime.getSetting("PGLITE_DATA_DIR") ?? "./pglite",
       postgresUrl: runtime.getSetting("POSTGRES_URL")
@@ -2067,7 +2223,7 @@ var drizzlePlugin = {
     }
   }, "init")
 };
-var index_default = drizzlePlugin;
+var index_default = sqlPlugin;
 export {
   createDatabaseAdapter,
   index_default as default