@elizaos/plugin-sql 1.0.0-alpha.6 → 1.0.0-alpha.60

package/dist/index.js

@@ -1,9 +1,16 @@
+import {
+  PGliteClientManager,
+  PostgresConnectionManager,
+  __name
+} from "./chunk-JA2K6HCO.js";
+
 // src/index.ts
+import * as os from "node:os";
 import {
-  logger as logger6
+  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";
 
@@ -22,20 +29,44 @@ 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,
-  index as index2,
-  foreignKey as foreignKey2,
-  check as check2
+  vector as vector2
+} from "drizzle-orm/pg-core";
+
+// src/schema/memory.ts
+import { relations, sql as sql5 } from "drizzle-orm";
+import {
+  boolean as boolean2,
+  check,
+  foreignKey,
+  index,
+  jsonb as jsonb5,
+  pgTable as pgTable5,
+  text as text5,
+  uuid as uuid5
+} from "drizzle-orm/pg-core";
+
+// src/schema/agent.ts
+import { sql } from "drizzle-orm";
+import {
+  boolean,
+  jsonb,
+  pgTable,
+  text,
+  unique,
+  uuid
 } from "drizzle-orm/pg-core";
-import { sql as sql6 } from "drizzle-orm";
 
 // src/schema/types.ts
 import { customType } from "drizzle-orm/pg-core";
@@ -64,40 +95,14 @@ var numberTimestamp = customType(
   }
 );
 
-// src/schema/memory.ts
-import {
-  pgTable as pgTable5,
-  uuid as uuid5,
-  text as text5,
-  jsonb as jsonb5,
-  index,
-  boolean as boolean2,
-  foreignKey,
-  check
-} from "drizzle-orm/pg-core";
-import { relations, sql as sql5 } from "drizzle-orm";
-
-// src/schema/entity.ts
-import { sql as sql2 } from "drizzle-orm";
-import { jsonb as jsonb2, pgTable as pgTable2, text as text2, unique as unique2, uuid as uuid2 } from "drizzle-orm/pg-core";
-
 // src/schema/agent.ts
-import {
-  boolean,
-  jsonb,
-  pgTable,
-  text,
-  uuid,
-  unique
-} from "drizzle-orm/pg-core";
-import { sql } from "drizzle-orm";
 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"),
@@ -120,6 +125,8 @@ var agentTable = pgTable(
 );
 
 // src/schema/entity.ts
+import { sql as sql2 } from "drizzle-orm";
+import { jsonb as jsonb2, pgTable as pgTable2, text as text2, unique as unique2, uuid as uuid2 } from "drizzle-orm/pg-core";
 var entityTable = pgTable2(
   "entities",
   {
@@ -143,8 +150,8 @@ import { sql as sql4 } from "drizzle-orm";
 import { jsonb as jsonb4, pgTable as pgTable4, text as text4, uuid as uuid4 } from "drizzle-orm/pg-core";
 
 // src/schema/worldTable.ts
-import { jsonb as jsonb3, pgTable as pgTable3, text as text3, uuid as uuid3 } from "drizzle-orm/pg-core";
 import { sql as sql3 } from "drizzle-orm";
+import { jsonb as jsonb3, pgTable as pgTable3, text as text3, uuid as uuid3 } from "drizzle-orm/pg-core";
 var worldTable = pgTable3("worlds", {
   id: uuid3("id").notNull().primaryKey().default(sql3`gen_random_uuid()`),
   agentId: uuid3("agentId").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
@@ -300,8 +307,8 @@ var cacheTable = pgTable7(
 );
 
 // src/schema/component.ts
-import { pgTable as pgTable8, uuid as uuid8, jsonb as jsonb7, text as text7 } from "drizzle-orm/pg-core";
 import { sql as sql8 } from "drizzle-orm";
+import { jsonb as jsonb7, pgTable as pgTable8, text as text7, uuid as uuid8 } from "drizzle-orm/pg-core";
 var componentTable = pgTable8("components", {
   id: uuid8("id").primaryKey().defaultRandom(),
   entityId: uuid8("entityId").notNull().references(() => entityTable.id, { onDelete: "cascade" }),
@@ -318,27 +325,18 @@ var componentTable = pgTable8("components", {
   createdAt: numberTimestamp("createdAt").default(sql8`now()`).notNull()
 });
 
-// src/schema/goal.ts
-import { pgTable as pgTable9, uuid as uuid9, text as text8, jsonb as jsonb8, foreignKey as foreignKey3 } from "drizzle-orm/pg-core";
+// src/schema/log.ts
 import { sql as sql9 } from "drizzle-orm";
-var goalTable = pgTable9(
-  "goals",
+import { foreignKey as foreignKey3, jsonb as jsonb8, pgTable as pgTable9, text as text8, uuid as uuid9 } from "drizzle-orm/pg-core";
+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({
@@ -354,68 +352,41 @@ var goalTable = pgTable9(
   ]
 );
 
-// src/schema/log.ts
-import { pgTable as pgTable10, uuid as uuid10, text as text9, jsonb as jsonb9, foreignKey as foreignKey4 } from "drizzle-orm/pg-core";
-import { sql as sql10 } from "drizzle-orm";
-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 sql10 } from "drizzle-orm";
 import {
-  pgTable as pgTable11,
-  uuid as uuid11,
-  text as text10,
+  foreignKey as foreignKey4,
   index as index3,
-  foreignKey as foreignKey5
+  pgTable as pgTable10,
+  text as text9,
+  uuid as uuid10
 } from "drizzle-orm/pg-core";
-import { sql as sql11 } from "drizzle-orm";
-var participantTable = pgTable11(
+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]
@@ -424,26 +395,26 @@ var participantTable = pgTable11(
 );
 
 // src/schema/relationship.ts
-import { sql as sql12 } from "drizzle-orm";
+import { sql as sql11 } from "drizzle-orm";
 import {
-  foreignKey as foreignKey6,
+  foreignKey as foreignKey5,
   index as index4,
-  jsonb as jsonb10,
-  pgTable as pgTable12,
-  text as text11,
+  jsonb as jsonb9,
+  pgTable as pgTable11,
+  text as text10,
   unique as unique6,
-  uuid as uuid12
+  uuid as uuid11
 } from "drizzle-orm/pg-core";
-var relationshipTable = pgTable12(
+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(
@@ -455,12 +426,12 @@ var relationshipTable = pgTable12(
       table.targetEntityId,
       table.agentId
     ),
-    foreignKey6({
+    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]
@@ -469,32 +440,46 @@ 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()
 });
 
 // src/base.ts
 var BaseDrizzleAdapter = class extends DatabaseAdapter {
+  static {
+    __name(this, "BaseDrizzleAdapter");
+  }
   maxRetries = 3;
   baseDelay = 1e3;
   maxDelay = 1e4;
   jitterMax = 1e3;
   embeddingDimension = DIMENSION_MAP[384];
   agentId;
+  /**
+   * Constructor for creating a new instance of Agent with the specified agentId.
+   *
+   * @param {UUID} agentId - The unique identifier for the agent.
+   */
   constructor(agentId) {
     super();
     this.agentId = agentId;
   }
+  /**
+   * Executes the given operation with retry logic.
+   * @template T
+   * @param {() => Promise<T>} operation - The operation to be executed.
+   * @returns {Promise<T>} A promise that resolves with the result of the operation.
+   */
   async withRetry(operation) {
     let lastError = new Error("Unknown error");
     for (let attempt = 1; attempt <= this.maxRetries; attempt++) {
@@ -516,7 +501,6 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
               nextRetryIn: `${(delay / 1e3).toFixed(1)}s`
             }
           );
-          console.trace("****** Database operation failure source");
           await new Promise((resolve) => setTimeout(resolve, delay));
         } else {
           logger.error("Max retry attempts reached:", {
@@ -529,6 +513,14 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
     }
     throw lastError;
   }
+  /**
+   * 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.
+   * @returns {Promise<void>} - A promise that resolves when the agent is successfully ensured.
+   * @throws {Error} - If the agent name is not provided or if there is an issue creating the agent.
+   */
   async ensureAgentExists(agent) {
     if (!agent.name) {
       throw new Error("Agent name is required");
@@ -541,6 +533,12 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       await this.createAgent(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.
+   */
   async ensureEmbeddingDimension(dimension) {
     const existingMemory = await this.db.select({
       embedding: embeddingTable
@@ -549,12 +547,14 @@ 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];
   }
+  /**
+   * Asynchronously retrieves an agent by their ID from the database.
+   * @param {UUID} agentId - The ID of the agent to retrieve.
+   * @returns {Promise<Agent | null>} A promise that resolves to the retrieved agent or null if not found.
+   */
   async getAgent(agentId) {
     return this.withDatabase(async () => {
       const result = await this.db.select().from(agentTable).where(eq(agentTable.id, agentId)).limit(1);
@@ -562,12 +562,23 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       return result[0];
     });
   }
+  /**
+   * Asynchronously retrieves a list of agents from the database.
+   *
+   * @returns {Promise<Agent[]>} A Promise that resolves to an array of Agent objects.
+   */
   async getAgents() {
     return this.withDatabase(async () => {
       const result = await this.db.select().from(agentTable);
       return result;
     });
   }
+  /**
+   * Asynchronously creates a new agent record in the database.
+   *
+   * @param {Partial<Agent>} agent The agent object to be created.
+   * @returns {Promise<boolean>} A promise that resolves to a boolean indicating the success of the operation.
+   */
   async createAgent(agent) {
     return this.withDatabase(async () => {
       try {
@@ -590,6 +601,12 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       }
     });
   }
+  /**
+   * Updates an agent in the database with the provided agent ID and data.
+   * @param {UUID} agentId - The unique identifier of the agent to update.
+   * @param {Partial<Agent>} agent - The partial agent object containing the fields to update.
+   * @returns {Promise<boolean>} - A boolean indicating if the agent was successfully updated.
+   */
   async updateAgent(agentId, agent) {
     return this.withDatabase(async () => {
       try {
@@ -616,6 +633,12 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       }
     });
   }
+  /**
+   * Asynchronously deletes an agent with the specified UUID and all related entries.
+   *
+   * @param {UUID} agentId - The UUID of the agent to be deleted.
+   * @returns {Promise<boolean>} - A boolean indicating if the deletion was successful.
+   */
   async deleteAgent(agentId) {
     return this.withDatabase(async () => {
       await this.db.transaction(async (tx) => {
@@ -628,6 +651,10 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
    * Count all agents in the database
    * Used primarily for maintenance and cleanup operations
    */
+  /**
+   * Asynchronously counts the number of agents in the database.
+   * @returns {Promise<number>} A Promise that resolves to the number of agents in the database.
+   */
   async countAgents() {
     return this.withDatabase(async () => {
       try {
@@ -659,6 +686,11 @@ 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({
@@ -676,6 +708,12 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       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({
@@ -719,6 +757,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 {
@@ -730,17 +773,18 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
           return true;
         });
       } catch (error) {
-        logger.error("Error creating account:", {
+        logger.error("Error creating entity:", {
           error: error instanceof Error ? error.message : String(error),
           entityId: entity.id,
           name: entity.metadata?.name
         });
+        console.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
    */
@@ -763,6 +807,11 @@ 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(
@@ -789,6 +838,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)];
@@ -810,22 +866,48 @@ 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");
@@ -871,6 +953,14 @@ 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.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 [];
@@ -901,6 +991,11 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       }));
     });
   }
+  /**
+   * 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({
@@ -921,6 +1016,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 [];
@@ -944,10 +1046,21 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       }));
     });
   }
+  /**
+   * 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,
@@ -999,12 +1112,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
@@ -1021,6 +1143,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,
@@ -1030,30 +1196,23 @@ 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 similarity = sql12`1 - (${cosineDistance(
         embeddingTable[this.embeddingDimension],
         cleanVector
       )})`;
@@ -1087,7 +1246,14 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       }));
     });
   }
+  /**
+   * 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) {
+    console.log("memory.id is", memory.id);
     logger.debug("DrizzleAdapter createMemory:", {
       memoryId: memory.id,
       embeddingLength: memory.embedding?.length,
@@ -1113,8 +1279,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,
@@ -1137,21 +1303,31 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
     });
     return memoryId;
   }
-  async removeMemory(memoryId, tableName) {
+  /**
+   * 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 tx.delete(embeddingTable).where(eq(embeddingTable.memoryId, memoryId));
         await tx.delete(memoryTable).where(
-          and(eq(memoryTable.id, memoryId), eq(memoryTable.type, tableName))
+          and(eq(memoryTable.id, memoryId))
         );
       });
       logger.debug("Memory removed successfully:", {
-        memoryId,
-        tableName
+        memoryId
       });
     });
   }
-  async removeAllMemories(roomId, tableName) {
+  /**
+   * 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(
@@ -1181,6 +1357,13 @@ 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 () => {
@@ -1191,103 +1374,15 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       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({
@@ -1305,17 +1400,32 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       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));
     });
   }
+  /**
+   * 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,
@@ -1340,6 +1450,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 () => {
@@ -1348,6 +1463,11 @@ 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(
@@ -1359,6 +1479,11 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       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(
@@ -1370,6 +1495,12 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       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 {
@@ -1390,6 +1521,12 @@ 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 {
@@ -1418,6 +1555,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({
@@ -1435,6 +1577,11 @@ 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(
@@ -1446,6 +1593,12 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       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(
@@ -1458,6 +1611,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 {
@@ -1481,6 +1641,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();
@@ -1504,6 +1673,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 {
@@ -1520,6 +1694,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 {
@@ -1551,6 +1732,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 {
@@ -1566,7 +1754,9 @@ 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;
@@ -1588,6 +1778,11 @@ 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 {
@@ -1605,6 +1800,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 {
@@ -1631,6 +1832,11 @@ 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 {
@@ -1653,7 +1859,13 @@ 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) {
+    console.trace("*** creating world", world, "with id", world.id);
     return this.withDatabase(async () => {
       const newWorldId = world.id || v4();
       await this.db.insert(worldTable).values({
@@ -1663,32 +1875,52 @@ 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) {
+    console.trace("*** updating world", world, "with id", world.id);
     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 () => {
@@ -1713,7 +1945,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
    */
@@ -1727,7 +1959,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[]`
+            sql12`${taskTable.tags} @> ARRAY[${sql12.raw(tagParams)}]::text[]`
           );
         }
         const result = await query;
@@ -1744,7 +1976,7 @@ 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
    */
@@ -1767,7 +1999,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
    */
@@ -1792,7 +2024,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
@@ -1830,7 +2062,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
     });
   }
   /**
-   * 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
    */
@@ -1845,15 +2077,30 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
   }
 };
 
-// src/pg-lite/adapter.ts
+// src/pglite/adapter.ts
 var PgliteDatabaseAdapter = class extends BaseDrizzleAdapter {
+  static {
+    __name(this, "PgliteDatabaseAdapter");
+  }
   manager;
   embeddingDimension = DIMENSION_MAP[384];
+  /**
+   * Constructor for creating an instance of a class.
+   * @param {UUID} agentId - The unique identifier for the agent.
+   * @param {PGliteClientManager} manager - The manager for the PGlite client.
+   */
   constructor(agentId, manager) {
     super(agentId);
     this.manager = manager;
     this.db = drizzle(this.manager.getConnection());
   }
+  /**
+   * Asynchronously runs the provided database operation while checking if the database manager is currently shutting down.
+   * If the database manager is shutting down, a warning is logged and null is returned.
+   *
+   * @param {Function} operation - The database operation to be performed.
+   * @returns {Promise<T>} A promise that resolves with the result of the database operation.
+   */
   async withDatabase(operation) {
     if (this.manager.isShuttingDown()) {
       logger2.warn("Database is shutting down");
@@ -1861,6 +2108,11 @@ var PgliteDatabaseAdapter = class extends BaseDrizzleAdapter {
     }
     return operation();
   }
+  /**
+   * Asynchronously initializes the database by running migrations using the manager.
+   *
+   * @returns {Promise<void>} A Promise that resolves when the database initialization is complete.
+   */
   async init() {
     try {
       await this.manager.runMigrations();
@@ -1869,123 +2121,44 @@ var PgliteDatabaseAdapter = class extends BaseDrizzleAdapter {
       throw error;
     }
   }
+  /**
+   * Asynchronously closes the manager.
+   */
   async close() {
     await this.manager.close();
   }
 };
 
-// src/pg-lite/manager.ts
-import { PGlite } from "@electric-sql/pglite";
-import { vector as vector3 } from "@electric-sql/pglite/vector";
-import { fuzzystrmatch } from "@electric-sql/pglite/contrib/fuzzystrmatch";
-import { logger as logger3 } from "@elizaos/core";
-import { migrate } from "drizzle-orm/pglite/migrator";
-import { fileURLToPath } from "node:url";
-import path from "node:path";
-import { drizzle as drizzle2 } from "drizzle-orm/pglite";
-var __filename = fileURLToPath(import.meta.url);
-var __dirname = path.dirname(__filename);
-var PGliteClientManager = class {
-  client;
-  shuttingDown = false;
-  shutdownTimeout = 800;
-  constructor(options) {
-    this.client = new PGlite({
-      ...options,
-      extensions: {
-        vector: vector3,
-        fuzzystrmatch
-      }
-    });
-    this.setupShutdownHandlers();
-  }
-  getConnection() {
-    if (this.shuttingDown) {
-      throw new Error("Client manager is shutting down");
-    }
-    return this.client;
-  }
-  async gracefulShutdown() {
-    if (this.shuttingDown) {
-      return;
-    }
-    this.shuttingDown = true;
-    logger3.info("Starting graceful shutdown of PGlite client...");
-    const timeout = setTimeout(() => {
-      logger3.warn(
-        "Shutdown timeout reached, forcing database connection closure..."
-      );
-      this.client.close().finally(() => {
-        process.exit(1);
-      });
-    }, this.shutdownTimeout);
-    try {
-      await new Promise((resolve) => setTimeout(resolve, this.shutdownTimeout));
-      await this.client.close();
-      clearTimeout(timeout);
-      logger3.info("PGlite client shutdown completed successfully");
-      process.exit(0);
-    } catch (error) {
-      logger3.error("Error during graceful shutdown:", error);
-      process.exit(1);
-    }
-  }
-  setupShutdownHandlers() {
-    process.on("SIGINT", async () => {
-      await this.gracefulShutdown();
-    });
-    process.on("SIGTERM", async () => {
-      await this.gracefulShutdown();
-    });
-    process.on("beforeExit", async () => {
-      await this.gracefulShutdown();
-    });
-  }
-  async initialize() {
-    try {
-      await this.client.waitReady;
-      logger3.info("PGlite client initialized successfully");
-    } catch (error) {
-      logger3.error("Failed to initialize PGlite client:", error);
-      throw error;
-    }
-  }
-  async close() {
-    if (!this.shuttingDown) {
-      await this.gracefulShutdown();
-    }
-  }
-  isShuttingDown() {
-    return this.shuttingDown;
-  }
-  async runMigrations() {
-    try {
-      const db = drizzle2(this.client);
-      await migrate(db, {
-        migrationsFolder: path.resolve(__dirname, "../drizzle/migrations")
-      });
-      logger3.info("Migrations completed successfully!");
-    } catch (error) {
-      logger3.error("Failed to run database migrations:", error);
-    }
-  }
-};
-
 // src/pg/adapter.ts
-import { logger as logger4 } from "@elizaos/core";
-import { drizzle as drizzle3 } from "drizzle-orm/node-postgres";
+import { logger as logger3 } from "@elizaos/core";
+import { drizzle as drizzle2 } from "drizzle-orm/node-postgres";
 var PgDatabaseAdapter = class extends BaseDrizzleAdapter {
+  /**
+   * Constructor for creating a new instance of a class.
+   * @param {UUID} agentId - The unique identifier for the agent.
+   * @param {PostgresConnectionManager} manager - The Postgres connection manager for the instance.
+   */
   constructor(agentId, manager) {
     super(agentId);
     this.manager = manager;
     this.manager = manager;
   }
+  static {
+    __name(this, "PgDatabaseAdapter");
+  }
   embeddingDimension = DIMENSION_MAP[384];
+  /**
+   * Executes the provided operation with a database connection.
+   *
+   * @template T
+   * @param {() => Promise<T>} operation - The operation to be executed with the database connection.
+   * @returns {Promise<T>} A promise that resolves with the result of the operation.
+   */
   async withDatabase(operation) {
     return await this.withRetry(async () => {
       const client = await this.manager.getClient();
       try {
-        const db = drizzle3(client);
+        const db = drizzle2(client);
         this.db = db;
         return await operation();
       } finally {
@@ -1993,181 +2166,81 @@ var PgDatabaseAdapter = class extends BaseDrizzleAdapter {
       }
     });
   }
+  /**
+   * Asynchronously initializes the PgDatabaseAdapter by running migrations using the manager.
+   * Logs a success message if initialization is successful, otherwise logs an error message.
+   *
+   * @returns {Promise<void>} A promise that resolves when initialization is complete.
+   */
   async init() {
     try {
       await this.manager.runMigrations();
-      logger4.info("PgDatabaseAdapter initialized successfully");
+      logger3.info("PgDatabaseAdapter initialized successfully");
     } catch (error) {
-      logger4.error("Failed to initialize PgDatabaseAdapter:", error);
+      logger3.error("Failed to initialize PgDatabaseAdapter:", error);
       throw error;
     }
   }
+  /**
+   * Asynchronously closes the manager associated with this instance.
+   *
+   * @returns A Promise that resolves once the manager is closed.
+   */
   async close() {
     await this.manager.close();
   }
 };
 
-// src/pg/manager.ts
-import pkg from "pg";
-import { logger as logger5 } from "@elizaos/core";
-import { migrate as migrate2 } from "drizzle-orm/node-postgres/migrator";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
-import path2 from "node:path";
-import { drizzle as drizzle4 } from "drizzle-orm/node-postgres";
-var { Pool } = pkg;
-var __filename2 = fileURLToPath2(import.meta.url);
-var __dirname2 = path2.dirname(__filename2);
-var PostgresConnectionManager = class {
-  pool;
-  isShuttingDown = false;
-  connectionTimeout = 5e3;
-  constructor(connectionString) {
-    const defaultConfig = {
-      max: 20,
-      idleTimeoutMillis: 3e4,
-      connectionTimeoutMillis: this.connectionTimeout
-    };
-    this.pool = new Pool({
-      ...defaultConfig,
-      connectionString
-    });
-    this.pool.on("error", (err) => {
-      logger5.error("Unexpected pool error", err);
-      this.handlePoolError(err);
-    });
-    this.setupPoolErrorHandling();
-    this.testConnection();
+// src/index.ts
+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());
   }
-  async handlePoolError(error) {
-    logger5.error("Pool error occurred, attempting to reconnect", {
-      error: error.message
-    });
-    try {
-      await this.pool.end();
-      this.pool = new Pool({
-        ...this.pool.options,
-        connectionTimeoutMillis: this.connectionTimeout
-      });
-      await this.testConnection();
-      logger5.success("Pool reconnection successful");
-    } catch (reconnectError) {
-      logger5.error("Failed to reconnect pool", {
-        error: reconnectError instanceof Error ? reconnectError.message : String(reconnectError)
-      });
-      throw reconnectError;
-    }
+  return filepath;
+}
+__name(expandTildePath, "expandTildePath");
+function createDatabaseAdapter(config, agentId) {
+  if (config.dataDir) {
+    config.dataDir = expandTildePath(config.dataDir);
   }
-  async testConnection() {
-    let client;
-    try {
-      client = await this.pool.connect();
-      const result = await client.query("SELECT NOW()");
-      logger5.success("Database connection test successful:", result.rows[0]);
-      return true;
-    } catch (error) {
-      logger5.error("Database connection test failed:", error);
-      throw new Error(
-        `Failed to connect to database: ${error.message}`
+  if (config.postgresUrl) {
+    if (!globalSingletons.postgresConnectionManager) {
+      globalSingletons.postgresConnectionManager = new PostgresConnectionManager(
+        config.postgresUrl
       );
-    } finally {
-      if (client) client.release();
     }
-  }
-  setupPoolErrorHandling() {
-    process.on("SIGINT", async () => {
-      await this.cleanup();
-      process.exit(0);
-    });
-    process.on("SIGTERM", async () => {
-      await this.cleanup();
-      process.exit(0);
-    });
-    process.on("beforeExit", async () => {
-      await this.cleanup();
-    });
-  }
-  getConnection() {
-    if (this.isShuttingDown) {
-      throw new Error("Connection manager is shutting down");
-    }
-    try {
-      return this.pool;
-    } catch (error) {
-      logger5.error("Failed to get connection from pool:", error);
-      throw error;
-    }
-  }
-  async getClient() {
-    try {
-      return await this.pool.connect();
-    } catch (error) {
-      logger5.error("Failed to acquire a database client:", error);
-      throw error;
-    }
-  }
-  async initialize() {
-    try {
-      await this.testConnection();
-      logger5.info("PostgreSQL connection manager initialized successfully");
-    } catch (error) {
-      logger5.error("Failed to initialize connection manager:", error);
-      throw error;
-    }
-  }
-  async close() {
-    await this.cleanup();
-  }
-  async cleanup() {
-    try {
-      await this.pool.end();
-      logger5.info("Database pool closed");
-    } catch (error) {
-      logger5.error("Error closing database pool:", error);
-    }
-  }
-  async runMigrations() {
-    try {
-      const db = drizzle4(this.pool);
-      await migrate2(db, {
-        migrationsFolder: path2.resolve(__dirname2, "../drizzle/migrations")
-      });
-      logger5.info("Migrations completed successfully!");
-    } catch (error) {
-      logger5.error("Failed to run database migrations:", error);
-    }
-  }
-};
-
-// src/index.ts
-var pgLiteClientManager;
-function createDatabaseAdapter(config, agentId) {
-  if (config.postgresUrl) {
-    const manager = new PostgresConnectionManager(config.postgresUrl);
-    return new PgDatabaseAdapter(agentId, manager);
+    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",
-  init: async (_, runtime) => {
+  init: /* @__PURE__ */ __name(async (_, runtime) => {
     const config = {
       dataDir: runtime.getSetting("PGLITE_DATA_DIR") ?? "./pglite",
       postgresUrl: runtime.getSetting("POSTGRES_URL")
     };
     try {
       const db = createDatabaseAdapter(config, runtime.agentId);
-      logger6.success("Database connection established successfully");
+      logger4.success("Database connection established successfully");
       runtime.registerDatabaseAdapter(db);
     } catch (error) {
-      logger6.error("Failed to initialize database:", error);
+      logger4.error("Failed to initialize database:", error);
       throw error;
     }
-  }
+  }, "init")
 };
 var index_default = drizzlePlugin;
 export {