@elizaos/plugin-sql 1.0.0-beta.49 → 1.0.0-beta.50

package/dist/index.d.ts

@@ -0,0 +1,30 @@
+import { Plugin, UUID, IDatabaseAdapter } from '@elizaos/core';
+
+/**
+ * Creates a database adapter based on the provided configuration.
+ * If a postgresUrl is provided in the config, a PgDatabaseAdapter is initialized using the PostgresConnectionManager.
+ * If no postgresUrl is provided, a PgliteDatabaseAdapter is initialized using PGliteClientManager with the dataDir from the config.
+ *
+ * @param {object} config - The configuration object.
+ * @param {string} [config.dataDir] - The directory where data is stored. Defaults to "./elizadb".
+ * @param {string} [config.postgresUrl] - The URL for the PostgreSQL database.
+ * @param {UUID} agentId - The unique identifier for the agent.
+ * @returns {IDatabaseAdapter} The created database adapter.
+ */
+declare function createDatabaseAdapter(config: {
+    dataDir?: string;
+    postgresUrl?: string;
+}, agentId: UUID): IDatabaseAdapter;
+/**
+ * SQL plugin for database adapter using Drizzle ORM
+ *
+ * @typedef {Object} Plugin
+ * @property {string} name - The name of the plugin
+ * @property {string} description - The description of the plugin
+ * @property {Function} init - The initialization function for the plugin
+ * @param {any} _ - Input parameter
+ * @param {IAgentRuntime} runtime - The runtime environment for the agent
+ */
+declare const sqlPlugin: Plugin;
+
+export { createDatabaseAdapter, sqlPlugin as default };

package/dist/index.js

@@ -18,25 +18,25 @@ import {
   logger,
   stringToUuid
 } from "@elizaos/core";
-import { and, cosineDistance, count, desc, eq, gte, inArray, lte, or, sql as sql12, not } from "drizzle-orm";
+import { and, cosineDistance, count, desc, eq, gte, inArray, lte, or, sql as sql13 } from "drizzle-orm";
 import { v4 } from "uuid";
 
 // src/schema/embedding.ts
-import { sql as sql6 } from "drizzle-orm";
-import { check as check2, foreignKey as foreignKey2, index as index2, pgTable as pgTable6, uuid as uuid6, vector as vector2 } from "drizzle-orm/pg-core";
+import { sql as sql5 } from "drizzle-orm";
+import { check as check2, foreignKey as foreignKey2, index as index2, pgTable as pgTable5, uuid as uuid5, vector as vector2 } from "drizzle-orm/pg-core";
 import { VECTOR_DIMS } from "@elizaos/core";
 
 // src/schema/memory.ts
-import { relations, sql as sql5 } from "drizzle-orm";
+import { relations, sql as sql4 } from "drizzle-orm";
 import {
   boolean as boolean2,
   check,
   foreignKey,
   index,
-  jsonb as jsonb5,
-  pgTable as pgTable5,
-  text as text5,
-  uuid as uuid5
+  jsonb as jsonb4,
+  pgTable as pgTable4,
+  text as text4,
+  uuid as uuid4
 } from "drizzle-orm/pg-core";
 
 // src/schema/agent.ts
@@ -79,8 +79,8 @@ var agentTable = pgTable(
     // Character
     name: text("name").notNull(),
     username: text("username"),
-    system: text("system").notNull(),
-    bio: jsonb("bio").$type().notNull(),
+    system: text("system").default(""),
+    bio: jsonb("bio").$type().default(sql`'[]'::jsonb`),
     messageExamples: jsonb("message_examples").$type().default(sql`'[]'::jsonb`).notNull(),
     postExamples: jsonb("post_examples").$type().default(sql`'[]'::jsonb`).notNull(),
     topics: jsonb("topics").$type().default(sql`'[]'::jsonb`).notNull(),
@@ -119,61 +119,50 @@ var entityTable = pgTable2(
 );
 
 // src/schema/room.ts
-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/world.ts
 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", {
+var roomTable = pgTable3("rooms", {
   id: uuid3("id").notNull().primaryKey().default(sql3`gen_random_uuid()`),
-  agentId: uuid3("agentId").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
-  name: text3("name").notNull(),
-  metadata: jsonb3("metadata"),
-  serverId: text3("serverId").notNull(),
-  createdAt: numberTimestamp("createdAt").default(sql3`now()`).notNull()
-});
-
-// src/schema/room.ts
-var roomTable = pgTable4("rooms", {
-  id: uuid4("id").notNull().primaryKey().default(sql4`gen_random_uuid()`),
-  agentId: uuid4("agentId").references(() => agentTable.id, {
+  agentId: uuid3("agentId").references(() => agentTable.id, {
     onDelete: "cascade"
   }),
-  source: text4("source").notNull(),
-  type: text4("type").notNull(),
-  serverId: text4("serverId"),
-  worldId: uuid4("worldId").references(() => worldTable.id, {
-    onDelete: "cascade"
-  }),
-  name: text4("name"),
-  metadata: jsonb4("metadata"),
-  channelId: text4("channelId"),
-  createdAt: numberTimestamp("createdAt").default(sql4`now()`).notNull()
+  source: text3("source").notNull(),
+  type: text3("type").notNull(),
+  serverId: text3("serverId"),
+  worldId: uuid3("worldId"),
+  // no guarantee that world exists, it is optional for now
+  // .references(() => worldTable.id, {
+  //   onDelete: 'cascade',
+  // }),
+  name: text3("name"),
+  metadata: jsonb3("metadata"),
+  channelId: text3("channelId"),
+  createdAt: numberTimestamp("createdAt").default(sql3`now()`).notNull()
 });
 
 // src/schema/memory.ts
-var memoryTable = pgTable5(
+var memoryTable = pgTable4(
   "memories",
   {
-    id: uuid5("id").primaryKey().notNull(),
-    type: text5("type").notNull(),
-    createdAt: numberTimestamp("createdAt").default(sql5`now()`).notNull(),
-    content: jsonb5("content").notNull(),
-    entityId: uuid5("entityId").references(() => entityTable.id, {
+    id: uuid4("id").primaryKey().notNull(),
+    type: text4("type").notNull(),
+    createdAt: numberTimestamp("createdAt").default(sql4`now()`).notNull(),
+    content: jsonb4("content").notNull(),
+    entityId: uuid4("entityId").references(() => entityTable.id, {
       onDelete: "cascade"
     }),
-    agentId: uuid5("agentId").references(() => agentTable.id, {
+    agentId: uuid4("agentId").references(() => agentTable.id, {
       onDelete: "cascade"
-    }),
-    roomId: uuid5("roomId").references(() => roomTable.id, {
+    }).notNull(),
+    roomId: uuid4("roomId").references(() => roomTable.id, {
       onDelete: "cascade"
     }),
-    worldId: uuid5("worldId").references(() => worldTable.id, {
-      onDelete: "set null"
-    }),
+    worldId: uuid4("worldId"),
+    // .references(() => worldTable.id, {
+    //   onDelete: 'set null',
+    // }),
     unique: boolean2("unique").default(true).notNull(),
-    metadata: jsonb5("metadata").default({}).notNull()
+    metadata: jsonb4("metadata").default({}).notNull()
   },
   (table) => [
     index("idx_memories_type_room").on(table.type, table.roomId),
@@ -193,20 +182,20 @@ var memoryTable = pgTable5(
       columns: [table.agentId],
       foreignColumns: [agentTable.id]
     }).onDelete("cascade"),
-    foreignKey({
-      name: "fk_world",
-      columns: [table.worldId],
-      foreignColumns: [worldTable.id]
-    }).onDelete("set null"),
-    index("idx_memories_metadata_type").on(sql5`((metadata->>'type'))`),
-    index("idx_memories_document_id").on(sql5`((metadata->>'documentId'))`),
+    // foreignKey({
+    //   name: 'fk_world',
+    //   columns: [table.worldId],
+    //   foreignColumns: [worldTable.id],
+    // }).onDelete('set null'),
+    index("idx_memories_metadata_type").on(sql4`((metadata->>'type'))`),
+    index("idx_memories_document_id").on(sql4`((metadata->>'documentId'))`),
     index("idx_fragments_order").on(
-      sql5`((metadata->>'documentId'))`,
-      sql5`((metadata->>'position'))`
+      sql4`((metadata->>'documentId'))`,
+      sql4`((metadata->>'position'))`
     ),
     check(
       "fragment_metadata_check",
-      sql5`
+      sql4`
             CASE 
                 WHEN metadata->>'type' = 'fragment' THEN
                     metadata ? 'documentId' AND 
@@ -217,7 +206,7 @@ var memoryTable = pgTable5(
     ),
     check(
       "document_metadata_check",
-      sql5`
+      sql4`
             CASE 
                 WHEN metadata->>'type' = 'document' THEN
                     metadata ? 'timestamp'
@@ -240,12 +229,12 @@ var DIMENSION_MAP = {
   [VECTOR_DIMS.XXL]: "dim1536",
   [VECTOR_DIMS.XXXL]: "dim3072"
 };
-var embeddingTable = pgTable6(
+var embeddingTable = pgTable5(
   "embeddings",
   {
-    id: uuid6("id").primaryKey().defaultRandom().notNull(),
-    memoryId: uuid6("memory_id").references(() => memoryTable.id),
-    createdAt: numberTimestamp("created_at").default(sql6`now()`).notNull(),
+    id: uuid5("id").primaryKey().defaultRandom().notNull(),
+    memoryId: uuid5("memory_id").references(() => memoryTable.id),
+    createdAt: numberTimestamp("created_at").default(sql5`now()`).notNull(),
     dim384: vector2("dim_384", { dimensions: VECTOR_DIMS.SMALL }),
     dim512: vector2("dim_512", { dimensions: VECTOR_DIMS.MEDIUM }),
     dim768: vector2("dim_768", { dimensions: VECTOR_DIMS.LARGE }),
@@ -254,7 +243,7 @@ var embeddingTable = pgTable6(
     dim3072: vector2("dim_3072", { dimensions: VECTOR_DIMS.XXXL })
   },
   (table) => [
-    check2("embedding_source_check", sql6`"memory_id" IS NOT NULL`),
+    check2("embedding_source_check", sql5`"memory_id" IS NOT NULL`),
     index2("idx_embedding_memory").on(table.memoryId),
     foreignKey2({
       name: "fk_embedding_memory",
@@ -265,16 +254,16 @@ var embeddingTable = pgTable6(
 );
 
 // src/schema/cache.ts
-import { sql as sql7 } from "drizzle-orm";
-import { jsonb as jsonb6, pgTable as pgTable7, text as text6, unique as unique4, uuid as uuid7 } from "drizzle-orm/pg-core";
-var cacheTable = pgTable7(
+import { sql as sql6 } from "drizzle-orm";
+import { jsonb as jsonb5, pgTable as pgTable6, text as text5, unique as unique4, uuid as uuid6 } from "drizzle-orm/pg-core";
+var cacheTable = pgTable6(
   "cache",
   {
-    id: uuid7("id").notNull().primaryKey().default(sql7`gen_random_uuid()`),
-    key: text6("key").notNull(),
-    agentId: uuid7("agentId").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
-    value: jsonb6("value").notNull(),
-    createdAt: numberTimestamp("createdAt").default(sql7`now()`).notNull(),
+    id: uuid6("id").notNull().primaryKey().default(sql6`gen_random_uuid()`),
+    key: text5("key").notNull(),
+    agentId: uuid6("agentId").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
+    value: jsonb5("value").notNull(),
+    createdAt: numberTimestamp("createdAt").default(sql6`now()`).notNull(),
     expiresAt: numberTimestamp("expiresAt")
   },
   (table) => [unique4("cache_key_agent_unique").on(table.key, table.agentId)]
@@ -283,6 +272,20 @@ var cacheTable = pgTable7(
 // src/schema/component.ts
 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";
+
+// src/schema/world.ts
+import { sql as sql7 } from "drizzle-orm";
+import { jsonb as jsonb6, pgTable as pgTable7, text as text6, uuid as uuid7 } from "drizzle-orm/pg-core";
+var worldTable = pgTable7("worlds", {
+  id: uuid7("id").notNull().primaryKey().default(sql7`gen_random_uuid()`),
+  agentId: uuid7("agentId").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
+  name: text6("name").notNull(),
+  metadata: jsonb6("metadata"),
+  serverId: text6("serverId").notNull(),
+  createdAt: numberTimestamp("createdAt").default(sql7`now()`).notNull()
+});
+
+// src/schema/component.ts
 var componentTable = pgTable8("components", {
   id: uuid8("id").primaryKey().defaultRandom(),
   entityId: uuid8("entityId").notNull().references(() => entityTable.id, { onDelete: "cascade" }),
@@ -394,17 +397,19 @@ var relationshipTable = pgTable11(
 
 // src/schema/tasks.ts
 import { jsonb as jsonb10, pgTable as pgTable12, text as text11, timestamp, uuid as uuid12 } from "drizzle-orm/pg-core";
+import { sql as sql12 } from "drizzle-orm";
 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"),
+  description: text11("description"),
+  roomId: uuid12("roomId"),
+  worldId: uuid12("worldId"),
+  entityId: uuid12("entityId"),
   agentId: uuid12("agent_id").notNull(),
-  tags: text11("tags").array(),
-  metadata: jsonb10("metadata"),
-  createdAt: timestamp("created_at").defaultNow(),
-  updatedAt: timestamp("updated_at").defaultNow()
+  tags: text11("tags").array().default(sql12`'{}'::text[]`),
+  metadata: jsonb10("metadata").default(sql12`'{}'::jsonb`),
+  createdAt: timestamp("created_at", { withTimezone: true }).defaultNow(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow()
 });
 
 // src/base.ts
@@ -514,6 +519,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       const row = rows[0];
       return {
         ...row,
+        username: row.username || "",
         id: row.id
       };
     });
@@ -763,15 +769,10 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
               logger.debug(`[DB] Checking for world references`);
               const worlds = await tx.select({ id: worldTable.id }).from(worldTable).where(eq(worldTable.agentId, agentId));
               if (worlds.length > 0) {
-                const newAgent = await tx.select({ newAgentId: agentTable.id }).from(agentTable).where(not(eq(agentTable.id, agentId))).limit(1);
-                if (newAgent.length > 0) {
-                  await tx.update(worldTable).set({ agentId: newAgent[0].newAgentId }).where(eq(worldTable.agentId, agentId));
-                } else {
-                  const worldIds = worlds.map((w) => w.id);
-                  logger.debug(`[DB] Found ${worldIds.length} worlds to delete`);
-                  await tx.delete(worldTable).where(inArray(worldTable.id, worldIds));
-                  logger.debug(`[DB] Worlds deleted successfully`);
-                }
+                const worldIds = worlds.map((w) => w.id);
+                logger.debug(`[DB] Found ${worldIds.length} worlds to delete`);
+                await tx.delete(worldTable).where(inArray(worldTable.id, worldIds));
+                logger.debug(`[DB] Worlds deleted successfully`);
               } else {
                 logger.debug(`[DB] No worlds found for this agent`);
               }
@@ -889,8 +890,8 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
         if (!entitiesByIdMap.has(entityId)) {
           const entity = {
             ...row.entity,
-            id: stringToUuid(entityId),
-            agentId: stringToUuid(row.entity.agentId),
+            id: entityId,
+            agentId: row.entity.agentId,
             metadata: row.entity.metadata,
             components: includeComponents ? [] : void 0
           };
@@ -1241,7 +1242,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
   async getCachedEmbeddings(opts) {
     return this.withDatabase(async () => {
       try {
-        const results = await this.db.execute(sql12`
+        const results = await this.db.execute(sql13`
                     WITH content_text AS (
                         SELECT
                             m.id,
@@ -1305,9 +1306,11 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
   async log(params) {
     return this.withDatabase(async () => {
       try {
+        const sanitizedBody = this.sanitizeJsonObject(params.body);
+        const jsonString = JSON.stringify(sanitizedBody);
         await this.db.transaction(async (tx) => {
           await tx.insert(logTable).values({
-            body: sql12`${params.body}::jsonb`,
+            body: sql13`${jsonString}::jsonb`,
             entityId: params.entityId,
             roomId: params.roomId,
             type: params.type
@@ -1324,6 +1327,34 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       }
     });
   }
+  /**
+   * Sanitizes a JSON object by replacing problematic Unicode escape sequences
+   * that could cause errors during JSON serialization/storage
+   *
+   * @param value - The value to sanitize
+   * @returns The sanitized value
+   */
+  sanitizeJsonObject(value) {
+    if (value === null || value === void 0) {
+      return value;
+    }
+    if (typeof value === "string") {
+      return value.replace(/\u0000/g, "").replace(/\\(?!["\\/bfnrtu])/g, "\\\\").replace(/\\u(?![0-9a-fA-F]{4})/g, "\\\\u");
+    }
+    if (typeof value === "object") {
+      if (Array.isArray(value)) {
+        return value.map((item) => this.sanitizeJsonObject(item));
+      } else {
+        const result = {};
+        for (const [key, val] of Object.entries(value)) {
+          const sanitizedKey = typeof key === "string" ? key.replace(/\u0000/g, "").replace(/\\u(?![0-9a-fA-F]{4})/g, "\\\\u") : key;
+          result[sanitizedKey] = this.sanitizeJsonObject(val);
+        }
+        return result;
+      }
+    }
+    return value;
+  }
   /**
    * Asynchronously retrieves logs from the database based on the provided parameters.
    * @param {Object} params - The parameters for retrieving logs.
@@ -1408,7 +1439,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
   async searchMemoriesByEmbedding(embedding, params) {
     return this.withDatabase(async () => {
       const cleanVector = embedding.map((n) => Number.isFinite(n) ? Number(n.toFixed(6)) : 0);
-      const similarity = sql12`1 - (${cosineDistance(
+      const similarity = sql13`1 - (${cosineDistance(
         embeddingTable[this.embeddingDimension],
         cleanVector
       )})`;
@@ -1490,13 +1521,13 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
         {
           id: memoryId,
           type: tableName,
-          content: sql12`${contentToInsert}::jsonb`,
-          metadata: sql12`${memory.metadata || {}}::jsonb`,
+          content: sql13`${contentToInsert}::jsonb`,
+          metadata: sql13`${memory.metadata || {}}::jsonb`,
           entityId: memory.entityId,
           roomId: memory.roomId,
           worldId: memory.worldId,
           // Include worldId
-          agentId: memory.agentId,
+          agentId: this.agentId,
           unique: memory.unique ?? isUnique,
           createdAt: memory.createdAt
         }
@@ -1532,12 +1563,12 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
           if (memory.content) {
             const contentToUpdate = typeof memory.content === "string" ? JSON.parse(memory.content) : memory.content;
             await tx.update(memoryTable).set({
-              content: sql12`${contentToUpdate}::jsonb`,
-              ...memory.metadata && { metadata: sql12`${memory.metadata}::jsonb` }
+              content: sql13`${contentToUpdate}::jsonb`,
+              ...memory.metadata && { metadata: sql13`${memory.metadata}::jsonb` }
             }).where(eq(memoryTable.id, memory.id));
           } else if (memory.metadata) {
             await tx.update(memoryTable).set({
-              metadata: sql12`${memory.metadata}::jsonb`
+              metadata: sql13`${memory.metadata}::jsonb`
             }).where(eq(memoryTable.id, memory.id));
           }
           if (memory.embedding && Array.isArray(memory.embedding)) {
@@ -1619,7 +1650,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
     const fragments = await tx.select({ id: memoryTable.id }).from(memoryTable).where(
       and(
         eq(memoryTable.agentId, this.agentId),
-        sql12`${memoryTable.metadata}->>'documentId' = ${documentId}`
+        sql13`${memoryTable.metadata}->>'documentId' = ${documentId}`
       )
     );
     return fragments.map((f) => ({ id: f.id }));
@@ -1664,7 +1695,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       if (unique7) {
         conditions.push(eq(memoryTable.unique, true));
       }
-      const result = await this.db.select({ count: sql12`count(*)` }).from(memoryTable).where(and(...conditions));
+      const result = await this.db.select({ count: sql13`count(*)` }).from(memoryTable).where(and(...conditions));
       return Number(result[0]?.count ?? 0);
     });
   }
@@ -1746,6 +1777,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
     worldId,
     metadata
   }) {
+    if (!worldId) throw new Error("worldId is required");
     return this.withDatabase(async () => {
       const newRoomId = id || v4();
       await this.db.insert(roomTable).values({
@@ -2044,7 +2076,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
         ),
         eq(relationshipTable.agentId, this.agentId),
         ...params.tags && params.tags.length > 0 ? [
-          sql12`${relationshipTable.tags} @> ARRAY[${sql12.raw(
+          sql13`${relationshipTable.tags} @> ARRAY[${sql13.raw(
             params.tags.map((tag) => `'${tag.replace(/'/g, "''")}'`).join(", ")
           )}]::text[]`
         ] : []
@@ -2198,6 +2230,9 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
    * @returns {Promise<UUID>} A Promise that resolves to the ID of the created task.
    */
   async createTask(task) {
+    if (!task.worldId) {
+      throw new Error("worldId is required");
+    }
     return this.withRetry(async () => {
       return this.withDatabase(async () => {
         const now = /* @__PURE__ */ new Date();
@@ -2221,7 +2256,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
   }
   /**
    * Asynchronously retrieves tasks based on specified parameters.
-   * @param params Object containing optional roomId and tags to filter tasks
+   * @param params Object containing optional roomId, tags, and entityId to filter tasks
    * @returns Promise resolving to an array of Task objects
    */
   async getTasks(params) {
@@ -2232,7 +2267,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
             eq(taskTable.agentId, this.agentId),
             ...params.roomId ? [eq(taskTable.roomId, params.roomId)] : [],
             ...params.tags && params.tags.length > 0 ? [
-              sql12`${taskTable.tags} @> ARRAY[${sql12.raw(
+              sql13`${taskTable.tags} @> ARRAY[${sql13.raw(
                 params.tags.map((t) => `'${t.replace(/'/g, "''")}'`).join(", ")
               )}]::text[]`
             ] : []
@@ -2455,6 +2490,14 @@ var PgliteDatabaseAdapter = class extends BaseDrizzleAdapter {
   async close() {
     await this.manager.close();
   }
+  /**
+   * Asynchronously retrieves the connection from the manager.
+   *
+   * @returns {Promise<PGlite>} A Promise that resolves with the connection.
+   */
+  async getConnection() {
+    return this.manager.getConnection();
+  }
 };
 
 // src/pg/adapter.ts
@@ -2517,9 +2560,19 @@ var PgDatabaseAdapter = class extends BaseDrizzleAdapter {
   async close() {
     await this.manager.close();
   }
+  /**
+   * Asynchronously retrieves the connection from the manager.
+   *
+   * @returns {Promise<PgPool>} A Promise that resolves with the connection.
+   */
+  async getConnection() {
+    return this.manager.getConnection();
+  }
 };
 
 // src/index.ts
+import path from "node:path";
+import { stringToUuid as stringToUuid2 } from "@elizaos/core";
 var GLOBAL_SINGLETONS = Symbol.for("@elizaos/plugin-sql/global-singletons");
 var globalSymbols = global;
 if (!globalSymbols[GLOBAL_SINGLETONS]) {
@@ -2545,7 +2598,7 @@ function createDatabaseAdapter(config, agentId) {
     }
     return new PgDatabaseAdapter(agentId, globalSingletons.postgresConnectionManager);
   }
-  const dataDir = config.dataDir ?? "./elizadb";
+  const dataDir = config.dataDir ?? path.join(os.homedir(), ".eliza", stringToUuid2(process.cwd()), "pglite");
   if (!globalSingletons.pgLiteClientManager) {
     globalSingletons.pgLiteClientManager = new PGliteClientManager({ dataDir });
   }
@@ -2557,7 +2610,7 @@ var sqlPlugin = {
   description: "SQL database adapter plugin using Drizzle ORM",
   init: /* @__PURE__ */ __name(async (_, runtime) => {
     const config = {
-      dataDir: runtime.getSetting("PGLITE_DATA_DIR") ?? "./pglite",
+      dataDir: runtime.getSetting("PGLITE_DATA_DIR") ?? path.join(os.homedir(), ".eliza", stringToUuid2(process.cwd()), "pglite"),
       postgresUrl: runtime.getSetting("POSTGRES_URL")
     };
     try {