@elizaos/plugin-sql 1.0.0-alpha.2 → 1.0.0-alpha.21

package/dist/index.js

@@ -1,6 +1,13 @@
+import {
+  PGliteClientManager,
+  PostgresConnectionManager,
+  __name
+} from "./chunk-2FOOMI3E.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
@@ -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,33 +95,7 @@ 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",
   {
@@ -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;
   }
+  /**
+   * Ensure 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);
     }
   }
+  /**
+   * Ensure 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 {
@@ -730,11 +757,12 @@ 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;
       }
     });
@@ -947,7 +975,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
   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,
@@ -1004,7 +1032,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       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
@@ -1030,30 +1058,12 @@ 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;
-      }
-    });
-  }
   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
       )})`;
@@ -1113,8 +1123,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,
@@ -1191,103 +1201,10 @@ 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));
-      });
-    });
-  }
   async getRoom(roomId) {
     return this.withDatabase(async () => {
       const result = await this.db.select({
@@ -1566,7 +1483,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;
@@ -1727,7 +1646,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;
@@ -1847,13 +1766,28 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
 
 // src/pg-lite/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 +1795,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 +1808,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 +1853,77 @@ 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();
-  }
-  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;
-    }
-  }
-  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}`
-      );
-    } 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;
+var postgresConnectionManager;
+function expandTildePath(filepath) {
+  if (filepath && typeof filepath === "string" && filepath.startsWith("~")) {
+    return filepath.replace(/^~/, os.homedir());
+  }
+  return filepath;
+}
+__name(expandTildePath, "expandTildePath");
 function createDatabaseAdapter(config, agentId) {
+  if (config.dataDir) {
+    config.dataDir = expandTildePath(config.dataDir);
+  }
   if (config.postgresUrl) {
-    const manager = new PostgresConnectionManager(config.postgresUrl);
-    return new PgDatabaseAdapter(agentId, manager);
+    if (!postgresConnectionManager) {
+      postgresConnectionManager = new PostgresConnectionManager(
+        config.postgresUrl
+      );
+    }
+    return new PgDatabaseAdapter(agentId, postgresConnectionManager);
   }
-  const dataDir = config.dataDir ?? "../../pgLite";
+  const dataDir = config.dataDir ?? "./elizadb";
   if (!pgLiteClientManager) {
     pgLiteClientManager = new PGliteClientManager({ dataDir });
   }
   return new PgliteDatabaseAdapter(agentId, 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"),
+      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 {