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

package/dist/index.js

@@ -1,6 +1,13 @@
+import {
+  PGliteClientManager,
+  PostgresConnectionManager,
+  __name
+} from "./chunk-LLEN3JTK.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
@@ -27,15 +34,39 @@ import {
 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" }),
@@ -319,8 +326,8 @@ var componentTable = pgTable8("components", {
 });
 
 // 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";
 import { sql as sql9 } from "drizzle-orm";
+import { foreignKey as foreignKey3, jsonb as jsonb8, pgTable as pgTable9, text as text8, uuid as uuid9 } from "drizzle-orm/pg-core";
 var goalTable = pgTable9(
   "goals",
   {
@@ -355,8 +362,8 @@ 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";
+import { foreignKey as foreignKey4, jsonb as jsonb9, pgTable as pgTable10, text as text9, uuid as uuid10 } from "drizzle-orm/pg-core";
 var logTable = pgTable10(
   "logs",
   {
@@ -382,14 +389,14 @@ var logTable = pgTable10(
 );
 
 // src/schema/participant.ts
+import { sql as sql11 } from "drizzle-orm";
 import {
+  foreignKey as foreignKey5,
+  index as index3,
   pgTable as pgTable11,
-  uuid as uuid11,
   text as text10,
-  index as index3,
-  foreignKey as foreignKey5
+  uuid as uuid11
 } from "drizzle-orm/pg-core";
-import { sql as sql11 } from "drizzle-orm";
 var participantTable = pgTable11(
   "participants",
   {
@@ -485,16 +492,30 @@ var taskTable = pgTable13("tasks", {
 
 // 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 +537,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 +549,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 +569,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
@@ -555,6 +589,11 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
     }
     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 +601,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 +640,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 +672,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 +690,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 +796,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;
       }
     });
@@ -1566,7 +1633,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[]`
+            sql13`${relationshipTable.tags} @> ARRAY[${sql13.raw(
+              tagParams
+            )}]::text[]`
           );
         }
         const results = await query;
@@ -1847,13 +1916,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 +1945,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 +1958,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 +2003,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 {