@elizaos/plugin-sql 1.0.7 → 1.0.9

package/dist/index.js

@@ -1,12 +1,12 @@
-import {
-  PGliteClientManager,
-  PostgresConnectionManager,
-  __name,
-  resolvePgliteDir
-} from "./chunk-74FVWTXP.js";
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
 // src/index.ts
-import { logger as logger4 } from "@elizaos/core";
+import { logger as logger7 } from "@elizaos/core";
 
 // src/pglite/adapter.ts
 import { logger as logger2 } from "@elizaos/core";
@@ -14,9 +14,9 @@ import { drizzle } from "drizzle-orm/pglite";
 
 // src/base.ts
 import {
+  ChannelType,
   DatabaseAdapter,
-  logger,
-  ChannelType
+  logger
 } from "@elizaos/core";
 import {
   and,
@@ -26,8 +26,8 @@ import {
   eq,
   gte,
   inArray,
-  lte,
   lt,
+  lte,
   or,
   sql as sql16
 } from "drizzle-orm";
@@ -35,7 +35,7 @@ import { v4 } from "uuid";
 
 // src/schema/embedding.ts
 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 { check as check2, foreignKey as foreignKey2, index as index2, pgTable as pgTable5, timestamp as timestamp5, uuid as uuid5, vector as vector2 } from "drizzle-orm/pg-core";
 import { VECTOR_DIMS } from "@elizaos/core";
 
 // src/schema/memory.ts
@@ -48,46 +48,20 @@ import {
   jsonb as jsonb4,
   pgTable as pgTable4,
   text as text4,
+  timestamp as timestamp4,
   uuid as uuid4
 } 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";
-
-// src/schema/types.ts
-import { customType } from "drizzle-orm/pg-core";
-var stringJsonb = customType({
-  dataType() {
-    return "jsonb";
-  },
-  toDriver(value) {
-    return JSON.stringify(value);
-  },
-  fromDriver(value) {
-    return JSON.stringify(value);
-  }
-});
-var numberTimestamp = customType({
-  dataType() {
-    return "timestamptz";
-  },
-  toDriver(value) {
-    return new Date(value).toISOString();
-  },
-  fromDriver(value) {
-    return new Date(value).getTime();
-  }
-});
-
-// src/schema/agent.ts
+import { boolean, jsonb, pgTable, text, timestamp, unique, uuid } from "drizzle-orm/pg-core";
 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(),
+    createdAt: timestamp("created_at", { withTimezone: true }).default(sql`now()`).notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).default(sql`now()`).notNull(),
     // Character
     name: text("name").notNull(),
     username: text("username"),
@@ -111,15 +85,15 @@ 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";
+import { jsonb as jsonb2, pgTable as pgTable2, text as text2, timestamp as timestamp2, unique as unique2, uuid as uuid2 } from "drizzle-orm/pg-core";
 var entityTable = pgTable2(
   "entities",
   {
     id: uuid2("id").notNull().primaryKey(),
-    agentId: uuid2("agentId").notNull().references(() => agentTable.id, {
+    agentId: uuid2("agent_id").notNull().references(() => agentTable.id, {
       onDelete: "cascade"
     }),
-    createdAt: numberTimestamp("createdAt").default(sql2`now()`).notNull(),
+    createdAt: timestamp2("created_at").default(sql2`now()`).notNull(),
     names: text2("names").array().default(sql2`'{}'::text[]`).notNull(),
     metadata: jsonb2("metadata").default(sql2`'{}'::jsonb`).notNull()
   },
@@ -132,7 +106,7 @@ var entityTable = pgTable2(
 
 // src/schema/room.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";
+import { jsonb as jsonb3, pgTable as pgTable3, text as text3, timestamp as timestamp3, uuid as uuid3 } from "drizzle-orm/pg-core";
 var roomTable = pgTable3("rooms", {
   id: uuid3("id").notNull().primaryKey().default(sql3`gen_random_uuid()`),
   agentId: uuid3("agentId").references(() => agentTable.id, {
@@ -149,7 +123,7 @@ var roomTable = pgTable3("rooms", {
   name: text3("name"),
   metadata: jsonb3("metadata"),
   channelId: text3("channelId"),
-  createdAt: numberTimestamp("createdAt").default(sql3`now()`).notNull()
+  createdAt: timestamp3("createdAt").default(sql3`now()`).notNull()
 });
 
 // src/schema/memory.ts
@@ -158,7 +132,7 @@ var memoryTable = pgTable4(
   {
     id: uuid4("id").primaryKey().notNull(),
     type: text4("type").notNull(),
-    createdAt: numberTimestamp("createdAt").default(sql4`now()`).notNull(),
+    createdAt: timestamp4("createdAt").default(sql4`now()`).notNull(),
     content: jsonb4("content").notNull(),
     entityId: uuid4("entityId").references(() => entityTable.id, {
       onDelete: "cascade"
@@ -246,7 +220,7 @@ var embeddingTable = pgTable5(
   {
     id: uuid5("id").primaryKey().defaultRandom().notNull(),
     memoryId: uuid5("memory_id").references(() => memoryTable.id),
-    createdAt: numberTimestamp("created_at").default(sql5`now()`).notNull(),
+    createdAt: timestamp5("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 }),
@@ -265,63 +239,85 @@ var embeddingTable = pgTable5(
   ]
 );
 
+// src/schema/index.ts
+var schema_exports = {};
+__export(schema_exports, {
+  agentTable: () => agentTable,
+  cacheTable: () => cacheTable,
+  channelParticipantsTable: () => channelParticipantsTable,
+  channelTable: () => channelTable,
+  componentTable: () => componentTable,
+  embeddingTable: () => embeddingTable,
+  entityTable: () => entityTable,
+  logTable: () => logTable,
+  memoryTable: () => memoryTable,
+  messageServerTable: () => messageServerTable,
+  messageTable: () => messageTable,
+  participantTable: () => participantTable,
+  relationshipTable: () => relationshipTable,
+  roomTable: () => roomTable,
+  serverAgentsTable: () => serverAgentsTable,
+  taskTable: () => taskTable,
+  worldTable: () => worldTable
+});
+
 // src/schema/cache.ts
 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";
+import { jsonb as jsonb5, pgTable as pgTable6, text as text5, primaryKey, timestamp as timestamp6, uuid as uuid6 } from "drizzle-orm/pg-core";
 var cacheTable = pgTable6(
   "cache",
   {
-    id: uuid6("id").notNull().primaryKey().default(sql6`gen_random_uuid()`),
     key: text5("key").notNull(),
-    agentId: uuid6("agentId").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
+    agentId: uuid6("agent_id").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
     value: jsonb5("value").notNull(),
-    createdAt: numberTimestamp("createdAt").default(sql6`now()`).notNull(),
-    expiresAt: numberTimestamp("expiresAt")
+    createdAt: timestamp6("created_at", { withTimezone: true }).default(sql6`now()`).notNull(),
+    expiresAt: timestamp6("expires_at", { withTimezone: true })
   },
-  (table) => [unique4("cache_key_agent_unique").on(table.key, table.agentId)]
+  (table) => ({
+    pk: primaryKey({ columns: [table.key, table.agentId] })
+  })
 );
 
 // 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";
+import { jsonb as jsonb7, pgTable as pgTable8, text as text7, timestamp as timestamp8, 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";
+import { jsonb as jsonb6, pgTable as pgTable7, text as text6, timestamp as timestamp7, 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()
+  serverId: text6("serverId").notNull().default("local"),
+  createdAt: timestamp7("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" }),
-  agentId: uuid8("agentId").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
-  roomId: uuid8("roomId").notNull().references(() => roomTable.id, { onDelete: "cascade" }),
-  worldId: uuid8("worldId").references(() => worldTable.id, {
-    onDelete: "cascade"
-  }),
-  sourceEntityId: uuid8("sourceEntityId").references(() => entityTable.id, {
-    onDelete: "cascade"
-  }),
+  id: uuid8("id").primaryKey().default(sql8`gen_random_uuid()`).notNull(),
+  // Foreign keys
+  entityId: uuid8("entityId").references(() => entityTable.id, { onDelete: "cascade" }).notNull(),
+  agentId: uuid8("agentId").references(() => agentTable.id, { onDelete: "cascade" }).notNull(),
+  roomId: uuid8("roomId").references(() => roomTable.id, { onDelete: "cascade" }).notNull(),
+  worldId: uuid8("worldId").references(() => worldTable.id, { onDelete: "cascade" }),
+  sourceEntityId: uuid8("sourceEntityId").references(() => entityTable.id, { onDelete: "cascade" }),
+  // Data
   type: text7("type").notNull(),
   data: jsonb7("data").default(sql8`'{}'::jsonb`),
-  createdAt: numberTimestamp("createdAt").default(sql8`now()`).notNull()
+  // Timestamps
+  createdAt: timestamp8("createdAt").default(sql8`now()`).notNull()
 });
 
 // src/schema/log.ts
 import { sql as sql9 } from "drizzle-orm";
-import { foreignKey as foreignKey3, jsonb as jsonb8, pgTable as pgTable9, text as text8, uuid as uuid9 } from "drizzle-orm/pg-core";
+import { foreignKey as foreignKey3, jsonb as jsonb8, pgTable as pgTable9, text as text8, timestamp as timestamp9, uuid as uuid9 } from "drizzle-orm/pg-core";
 var logTable = pgTable9(
   "logs",
   {
     id: uuid9("id").defaultRandom().notNull(),
-    createdAt: numberTimestamp("createdAt").default(sql9`now()`).notNull(),
+    createdAt: timestamp9("created_at", { withTimezone: true }).default(sql9`now()`).notNull(),
     entityId: uuid9("entityId").notNull().references(() => entityTable.id),
     body: jsonb8("body").notNull(),
     type: text8("type").notNull(),
@@ -343,12 +339,12 @@ var logTable = pgTable9(
 
 // src/schema/participant.ts
 import { sql as sql10 } from "drizzle-orm";
-import { foreignKey as foreignKey4, index as index3, pgTable as pgTable10, text as text9, uuid as uuid10 } from "drizzle-orm/pg-core";
+import { foreignKey as foreignKey4, index as index3, pgTable as pgTable10, text as text9, timestamp as timestamp10, uuid as uuid10 } from "drizzle-orm/pg-core";
 var participantTable = pgTable10(
   "participants",
   {
     id: uuid10("id").notNull().primaryKey().default(sql10`gen_random_uuid()`),
-    createdAt: numberTimestamp("createdAt").default(sql10`now()`).notNull(),
+    createdAt: timestamp10("created_at", { withTimezone: true }).default(sql10`now()`).notNull(),
     entityId: uuid10("entityId").references(() => entityTable.id, {
       onDelete: "cascade"
     }),
@@ -379,12 +375,21 @@ var participantTable = pgTable10(
 
 // src/schema/relationship.ts
 import { sql as sql11 } from "drizzle-orm";
-import { foreignKey as foreignKey5, index as index4, jsonb as jsonb9, pgTable as pgTable11, text as text10, unique as unique6, uuid as uuid11 } from "drizzle-orm/pg-core";
+import {
+  foreignKey as foreignKey5,
+  index as index4,
+  jsonb as jsonb9,
+  pgTable as pgTable11,
+  text as text10,
+  timestamp as timestamp11,
+  unique as unique5,
+  uuid as uuid11
+} from "drizzle-orm/pg-core";
 var relationshipTable = pgTable11(
   "relationships",
   {
     id: uuid11("id").notNull().primaryKey().default(sql11`gen_random_uuid()`),
-    createdAt: numberTimestamp("createdAt").default(sql11`now()`).notNull(),
+    createdAt: timestamp11("created_at", { withTimezone: true }).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" }),
@@ -393,7 +398,7 @@ var relationshipTable = pgTable11(
   },
   (table) => [
     index4("idx_relationships_users").on(table.sourceEntityId, table.targetEntityId),
-    unique6("unique_relationship").on(table.sourceEntityId, table.targetEntityId, table.agentId),
+    unique5("unique_relationship").on(table.sourceEntityId, table.targetEntityId, table.agentId),
     foreignKey5({
       name: "fk_user_a",
       columns: [table.sourceEntityId],
@@ -408,7 +413,7 @@ 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 { jsonb as jsonb10, pgTable as pgTable12, text as text11, timestamp as timestamp12, uuid as uuid12 } from "drizzle-orm/pg-core";
 import { sql as sql12 } from "drizzle-orm";
 var taskTable = pgTable12("tasks", {
   id: uuid12("id").primaryKey().defaultRandom(),
@@ -420,12 +425,12 @@ var taskTable = pgTable12("tasks", {
   agentId: uuid12("agent_id").notNull(),
   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()
+  createdAt: timestamp12("created_at", { withTimezone: true }).defaultNow(),
+  updatedAt: timestamp12("updated_at", { withTimezone: true }).defaultNow()
 });
 
 // src/schema/messageServer.ts
-import { pgTable as pgTable13, text as text12, jsonb as jsonb11, timestamp as timestamp2 } from "drizzle-orm/pg-core";
+import { pgTable as pgTable13, text as text12, jsonb as jsonb11, timestamp as timestamp13 } from "drizzle-orm/pg-core";
 import { sql as sql13 } from "drizzle-orm";
 var messageServerTable = pgTable13("message_servers", {
   id: text12("id").primaryKey(),
@@ -434,12 +439,12 @@ var messageServerTable = pgTable13("message_servers", {
   sourceType: text12("source_type").notNull(),
   sourceId: text12("source_id"),
   metadata: jsonb11("metadata"),
-  createdAt: timestamp2("created_at", { mode: "date" }).default(sql13`CURRENT_TIMESTAMP`).notNull(),
-  updatedAt: timestamp2("updated_at", { mode: "date" }).default(sql13`CURRENT_TIMESTAMP`).notNull()
+  createdAt: timestamp13("created_at", { mode: "date" }).default(sql13`CURRENT_TIMESTAMP`).notNull(),
+  updatedAt: timestamp13("updated_at", { mode: "date" }).default(sql13`CURRENT_TIMESTAMP`).notNull()
 });
 
 // src/schema/channel.ts
-import { pgTable as pgTable14, text as text13, jsonb as jsonb12, timestamp as timestamp3 } from "drizzle-orm/pg-core";
+import { pgTable as pgTable14, text as text13, jsonb as jsonb12, timestamp as timestamp14 } from "drizzle-orm/pg-core";
 import { sql as sql14 } from "drizzle-orm";
 var channelTable = pgTable14("channels", {
   id: text13("id").primaryKey(),
@@ -452,12 +457,12 @@ var channelTable = pgTable14("channels", {
   sourceId: text13("source_id"),
   topic: text13("topic"),
   metadata: jsonb12("metadata"),
-  createdAt: timestamp3("created_at", { mode: "date" }).default(sql14`CURRENT_TIMESTAMP`).notNull(),
-  updatedAt: timestamp3("updated_at", { mode: "date" }).default(sql14`CURRENT_TIMESTAMP`).notNull()
+  createdAt: timestamp14("created_at", { mode: "date" }).default(sql14`CURRENT_TIMESTAMP`).notNull(),
+  updatedAt: timestamp14("updated_at", { mode: "date" }).default(sql14`CURRENT_TIMESTAMP`).notNull()
 });
 
 // src/schema/message.ts
-import { pgTable as pgTable15, text as text14, jsonb as jsonb13, timestamp as timestamp4 } from "drizzle-orm/pg-core";
+import { pgTable as pgTable15, text as text14, jsonb as jsonb13, timestamp as timestamp15 } from "drizzle-orm/pg-core";
 import { sql as sql15 } from "drizzle-orm";
 var messageTable = pgTable15("central_messages", {
   id: text14("id").primaryKey(),
@@ -472,12 +477,12 @@ var messageTable = pgTable15("central_messages", {
   sourceType: text14("source_type"),
   sourceId: text14("source_id"),
   metadata: jsonb13("metadata"),
-  createdAt: timestamp4("created_at", { mode: "date" }).default(sql15`CURRENT_TIMESTAMP`).notNull(),
-  updatedAt: timestamp4("updated_at", { mode: "date" }).default(sql15`CURRENT_TIMESTAMP`).notNull()
+  createdAt: timestamp15("created_at", { mode: "date" }).default(sql15`CURRENT_TIMESTAMP`).notNull(),
+  updatedAt: timestamp15("updated_at", { mode: "date" }).default(sql15`CURRENT_TIMESTAMP`).notNull()
 });
 
 // src/schema/channelParticipant.ts
-import { pgTable as pgTable16, text as text15, primaryKey } from "drizzle-orm/pg-core";
+import { pgTable as pgTable16, text as text15, primaryKey as primaryKey2 } from "drizzle-orm/pg-core";
 var channelParticipantsTable = pgTable16(
   "channel_participants",
   {
@@ -486,12 +491,12 @@ var channelParticipantsTable = pgTable16(
     // This is a central UUID (can be an agentId or a dedicated central user ID)
   },
   (table) => ({
-    pk: primaryKey({ columns: [table.channelId, table.userId] })
+    pk: primaryKey2({ columns: [table.channelId, table.userId] })
   })
 );
 
 // src/schema/serverAgent.ts
-import { pgTable as pgTable17, text as text16, primaryKey as primaryKey2 } from "drizzle-orm/pg-core";
+import { pgTable as pgTable17, text as text16, primaryKey as primaryKey3 } from "drizzle-orm/pg-core";
 var serverAgentsTable = pgTable17(
   "server_agents",
   {
@@ -500,7 +505,7 @@ var serverAgentsTable = pgTable17(
     // This is the agent's UUID
   },
   (table) => ({
-    pk: primaryKey2({ columns: [table.serverId, table.agentId] })
+    pk: primaryKey3({ columns: [table.serverId, table.agentId] })
   })
 );
 
@@ -514,6 +519,18 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
   maxDelay = 1e4;
   jitterMax = 1e3;
   embeddingDimension = DIMENSION_MAP[384];
+  /**
+   * Initialize method that can be overridden by implementations
+   */
+  async initialize() {
+    await this.init();
+  }
+  /**
+   * Get the underlying database instance for testing purposes
+   */
+  getDatabase() {
+    return this.db;
+  }
   agentId;
   /**
    * Constructor for creating a new instance of Agent with the specified agentId.
@@ -591,7 +608,9 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
         username: row.username || "",
         id: row.id,
         system: !row.system ? void 0 : row.system,
-        bio: !row.bio ? "" : row.bio
+        bio: !row.bio ? "" : row.bio,
+        createdAt: row.createdAt.getTime(),
+        updatedAt: row.updatedAt.getTime()
       };
     });
   }
@@ -623,9 +642,26 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
   async createAgent(agent) {
     return this.withDatabase(async () => {
       try {
+        const conditions = [];
+        if (agent.id) {
+          conditions.push(eq(agentTable.id, agent.id));
+        }
+        if (agent.name) {
+          conditions.push(eq(agentTable.name, agent.name));
+        }
+        const existing = conditions.length > 0 ? await this.db.select({ id: agentTable.id }).from(agentTable).where(or(...conditions)).limit(1) : [];
+        if (existing.length > 0) {
+          logger.warn("Attempted to create an agent with a duplicate ID or name.", {
+            id: agent.id,
+            name: agent.name
+          });
+          return false;
+        }
         await this.db.transaction(async (tx) => {
           await tx.insert(agentTable).values({
-            ...agent
+            ...agent,
+            createdAt: new Date(agent.createdAt || Date.now()),
+            updatedAt: new Date(agent.updatedAt || Date.now())
           });
         });
         logger.debug("Agent created successfully:", {
@@ -658,10 +694,24 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
           if (agent?.settings) {
             agent.settings = await this.mergeAgentSettings(tx, agentId, agent.settings);
           }
-          await tx.update(agentTable).set({
-            ...agent,
-            updatedAt: Date.now()
-          }).where(eq(agentTable.id, agentId));
+          const updateData = { ...agent };
+          if (updateData.createdAt) {
+            if (typeof updateData.createdAt === "number") {
+              updateData.createdAt = new Date(updateData.createdAt);
+            } else {
+              delete updateData.createdAt;
+            }
+          }
+          if (updateData.updatedAt) {
+            if (typeof updateData.updatedAt === "number") {
+              updateData.updatedAt = new Date(updateData.updatedAt);
+            } else {
+              updateData.updatedAt = /* @__PURE__ */ new Date();
+            }
+          } else {
+            updateData.updatedAt = /* @__PURE__ */ new Date();
+          }
+          await tx.update(agentTable).set(updateData).where(eq(agentTable.id, agentId));
         });
         logger.debug("Agent updated successfully:", {
           agentId
@@ -939,7 +989,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
         entity: entityTable,
         components: componentTable
       }).from(entityTable).leftJoin(componentTable, eq(componentTable.entityId, entityTable.id)).where(inArray(entityTable.id, entityIds));
-      if (result.length === 0) return null;
+      if (result.length === 0) return [];
       const entities = {};
       const entityComponents = {};
       for (const e of result) {
@@ -1081,7 +1131,8 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
         roomId: component.roomId,
         worldId: component.worldId ?? "",
         sourceEntityId: component.sourceEntityId ?? "",
-        data: component.data
+        data: component.data,
+        createdAt: component.createdAt.getTime()
       };
     });
   }
@@ -1121,7 +1172,8 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
         roomId: component.roomId,
         worldId: component.worldId ?? "",
         sourceEntityId: component.sourceEntityId ?? "",
-        data: component.data
+        data: component.data,
+        createdAt: component.createdAt.getTime()
       }));
       return components;
     });
@@ -1133,7 +1185,10 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
    */
   async createComponent(component) {
     return this.withDatabase(async () => {
-      await this.db.insert(componentTable).values(component);
+      await this.db.insert(componentTable).values({
+        ...component,
+        createdAt: new Date(component.createdAt)
+      });
       return true;
     });
   }
@@ -1144,7 +1199,10 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
    */
   async updateComponent(component) {
     return this.withDatabase(async () => {
-      await this.db.update(componentTable).set(component).where(eq(componentTable.id, component.id));
+      await this.db.update(componentTable).set({
+        ...component,
+        createdAt: new Date(component.createdAt)
+      }).where(eq(componentTable.id, component.id));
     });
   }
   /**
@@ -1169,12 +1227,12 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
    * @returns {Promise<Memory[]>} A Promise that resolves to an array of memories.
    */
   async getMemories(params) {
-    const { entityId, agentId, roomId, worldId, tableName, count: count2, unique: unique7, start, end } = params;
+    const { entityId, agentId, roomId, worldId, tableName, count: count2, unique: unique6, start, end } = params;
     if (!tableName) throw new Error("tableName is required");
     return this.withDatabase(async () => {
       const conditions = [eq(memoryTable.type, tableName)];
       if (start) {
-        conditions.push(gte(memoryTable.createdAt, start));
+        conditions.push(gte(memoryTable.createdAt, new Date(start)));
       }
       if (entityId) {
         conditions.push(eq(memoryTable.entityId, entityId));
@@ -1186,9 +1244,9 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
         conditions.push(eq(memoryTable.worldId, worldId));
       }
       if (end) {
-        conditions.push(lte(memoryTable.createdAt, end));
+        conditions.push(lte(memoryTable.createdAt, new Date(end)));
       }
-      if (unique7) {
+      if (unique6) {
         conditions.push(eq(memoryTable.unique, true));
       }
       if (agentId) {
@@ -1212,7 +1270,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       return rows.map((row) => ({
         id: row.memory.id,
         type: row.memory.type,
-        createdAt: row.memory.createdAt,
+        createdAt: row.memory.createdAt.getTime(),
         content: typeof row.memory.content === "string" ? JSON.parse(row.memory.content) : row.memory.content,
         entityId: row.memory.entityId,
         agentId: row.memory.agentId,
@@ -1253,7 +1311,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       const rows = params.limit ? await query.limit(params.limit) : await query;
       return rows.map((row) => ({
         id: row.id,
-        createdAt: row.createdAt,
+        createdAt: row.createdAt.getTime(),
         content: typeof row.content === "string" ? JSON.parse(row.content) : row.content,
         entityId: row.entityId,
         agentId: row.agentId,
@@ -1278,7 +1336,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       const row = result[0];
       return {
         id: row.memory.id,
-        createdAt: row.memory.createdAt,
+        createdAt: row.memory.createdAt.getTime(),
         content: typeof row.memory.content === "string" ? JSON.parse(row.memory.content) : row.memory.content,
         entityId: row.memory.entityId,
         agentId: row.memory.agentId,
@@ -1309,7 +1367,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       }).from(memoryTable).leftJoin(embeddingTable, eq(embeddingTable.memoryId, memoryTable.id)).where(and(...conditions)).orderBy(desc(memoryTable.createdAt));
       return rows.map((row) => ({
         id: row.memory.id,
-        createdAt: row.memory.createdAt,
+        createdAt: row.memory.createdAt.getTime(),
         content: typeof row.memory.content === "string" ? JSON.parse(row.memory.content) : row.memory.content,
         entityId: row.memory.entityId,
         agentId: row.memory.agentId,
@@ -1560,7 +1618,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       return results.map((row) => ({
         id: row.memory.id,
         type: row.memory.type,
-        createdAt: row.memory.createdAt,
+        createdAt: row.memory.createdAt.getTime(),
         content: typeof row.memory.content === "string" ? JSON.parse(row.memory.content) : row.memory.content,
         entityId: row.memory.entityId,
         agentId: row.memory.agentId,
@@ -1619,16 +1677,16 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
           roomId: memory.roomId,
           worldId: memory.worldId,
           // Include worldId
-          agentId: this.agentId,
+          agentId: memory.agentId || this.agentId,
           unique: memory.unique ?? isUnique,
-          createdAt: memory.createdAt
+          createdAt: memory.createdAt ? new Date(memory.createdAt) : /* @__PURE__ */ new Date()
         }
       ]);
       if (memory.embedding && Array.isArray(memory.embedding)) {
         const embeddingValues = {
           id: v4(),
           memoryId,
-          createdAt: memory.createdAt
+          createdAt: memory.createdAt ? new Date(memory.createdAt) : /* @__PURE__ */ new Date()
         };
         const cleanVector = memory.embedding.map(
           (n) => Number.isFinite(n) ? Number(n.toFixed(6)) : 0
@@ -1676,7 +1734,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
               const embeddingValues = {
                 id: v4(),
                 memoryId: memory.id,
-                createdAt: Date.now()
+                createdAt: (/* @__PURE__ */ new Date()).getTime()
               };
               embeddingValues[this.embeddingDimension] = cleanVector;
               await tx.insert(embeddingTable).values([embeddingValues]);
@@ -1713,6 +1771,34 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       });
     });
   }
+  /**
+   * Asynchronously deletes multiple memories from the database in a single batch operation.
+   * @param {UUID[]} memoryIds - An array of UUIDs of the memories to delete.
+   * @returns {Promise<void>} A Promise that resolves when all memories are deleted.
+   */
+  async deleteManyMemories(memoryIds) {
+    if (memoryIds.length === 0) {
+      return;
+    }
+    return this.withDatabase(async () => {
+      await this.db.transaction(async (tx) => {
+        const BATCH_SIZE = 100;
+        for (let i = 0; i < memoryIds.length; i += BATCH_SIZE) {
+          const batch = memoryIds.slice(i, i + BATCH_SIZE);
+          await Promise.all(
+            batch.map(async (memoryId) => {
+              await this.deleteMemoryFragments(tx, memoryId);
+            })
+          );
+          await tx.delete(embeddingTable).where(inArray(embeddingTable.memoryId, batch));
+          await tx.delete(memoryTable).where(inArray(memoryTable.id, batch));
+        }
+      });
+      logger.debug("Batch memory deletion completed successfully:", {
+        count: memoryIds.length
+      });
+    });
+  }
   /**
    * Deletes all memory fragments that reference a specific document memory
    * @param tx The database transaction
@@ -1780,11 +1866,11 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
    * @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 = "") {
+  async countMemories(roomId, unique6 = true, tableName = "") {
     if (!tableName) throw new Error("tableName is required");
     return this.withDatabase(async () => {
       const conditions = [eq(memoryTable.roomId, roomId), eq(memoryTable.type, tableName)];
-      if (unique7) {
+      if (unique6) {
         conditions.push(eq(memoryTable.unique, true));
       }
       const result = await this.db.select({ count: sql16`count(*)` }).from(memoryTable).where(and(...conditions));
@@ -2135,37 +2221,29 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
    */
   async getRelationship(params) {
     return this.withDatabase(async () => {
-      try {
-        const result = await this.db.select().from(relationshipTable).where(
-          and(
-            eq(relationshipTable.sourceEntityId, params.sourceEntityId),
-            eq(relationshipTable.targetEntityId, params.targetEntityId),
-            eq(relationshipTable.agentId, this.agentId)
-          )
-        ).limit(1);
-        if (result.length === 0) {
-          return null;
-        }
-        return {
-          id: result[0].id,
-          sourceEntityId: result[0].sourceEntityId,
-          targetEntityId: result[0].targetEntityId,
-          agentId: result[0].agentId,
-          tags: result[0].tags || [],
-          metadata: result[0].metadata || {},
-          createdAt: result[0].createdAt?.toString()
-        };
-      } catch (error) {
-        logger.error("Error getting relationship:", {
-          error: error instanceof Error ? error.message : String(error),
-          params
-        });
-        return null;
-      }
+      const { sourceEntityId, targetEntityId } = params;
+      const result = await this.db.select().from(relationshipTable).where(
+        and(
+          eq(relationshipTable.sourceEntityId, sourceEntityId),
+          eq(relationshipTable.targetEntityId, targetEntityId)
+        )
+      );
+      if (result.length === 0) return null;
+      const relationship = result[0];
+      return {
+        ...relationship,
+        id: relationship.id,
+        sourceEntityId: relationship.sourceEntityId,
+        targetEntityId: relationship.targetEntityId,
+        agentId: relationship.agentId,
+        tags: relationship.tags ?? [],
+        metadata: relationship.metadata ?? {},
+        createdAt: relationship.createdAt.toISOString()
+      };
     });
   }
   /**
-   * Asynchronously retrieves all relationships from the database based on the provided parameters.
+   * Asynchronously retrieves 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.
@@ -2173,27 +2251,30 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
    */
   async getRelationships(params) {
     return this.withDatabase(async () => {
-      const conditions = [
-        or(
-          eq(relationshipTable.sourceEntityId, params.entityId),
-          eq(relationshipTable.targetEntityId, params.entityId)
-        ),
-        eq(relationshipTable.agentId, this.agentId),
-        ...params.tags && params.tags.length > 0 ? [
-          sql16`${relationshipTable.tags} @> ARRAY[${sql16.raw(
-            params.tags.map((tag) => `'${tag.replace(/'/g, "''")}'`).join(", ")
-          )}]::text[]`
-        ] : []
-      ];
-      const results = await this.db.select().from(relationshipTable).where(and(...conditions));
-      return results.map((row) => ({
-        id: row.id,
-        sourceEntityId: row.sourceEntityId,
-        targetEntityId: row.targetEntityId,
-        agentId: row.agentId,
-        tags: row.tags || [],
-        metadata: row.metadata || {},
-        createdAt: row.createdAt?.toString()
+      const { entityId, tags } = params;
+      let query;
+      if (tags && tags.length > 0) {
+        query = sql16`
+          SELECT * FROM ${relationshipTable}
+          WHERE (${relationshipTable.sourceEntityId} = ${entityId} OR ${relationshipTable.targetEntityId} = ${entityId})
+          AND ${relationshipTable.tags} && CAST(ARRAY[${sql16.join(tags, sql16`, `)}] AS text[])
+        `;
+      } else {
+        query = sql16`
+          SELECT * FROM ${relationshipTable}
+          WHERE ${relationshipTable.sourceEntityId} = ${entityId} OR ${relationshipTable.targetEntityId} = ${entityId}
+        `;
+      }
+      const result = await this.db.execute(query);
+      return result.rows.map((relationship) => ({
+        ...relationship,
+        id: relationship.id,
+        sourceEntityId: relationship.sourceEntityId,
+        targetEntityId: relationship.targetEntityId,
+        agentId: relationship.agentId,
+        tags: relationship.tags ?? [],
+        metadata: relationship.metadata ?? {},
+        createdAt: relationship.createdAt ? relationship.createdAt instanceof Date ? relationship.createdAt.toISOString() : new Date(relationship.createdAt).toISOString() : (/* @__PURE__ */ new Date()).toISOString()
       }));
     });
   }
@@ -2205,8 +2286,11 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
   async getCache(key) {
     return this.withDatabase(async () => {
       try {
-        const result = await this.db.select().from(cacheTable).where(and(eq(cacheTable.agentId, this.agentId), eq(cacheTable.key, key)));
-        return result[0]?.value;
+        const result = await this.db.select({ value: cacheTable.value }).from(cacheTable).where(and(eq(cacheTable.agentId, this.agentId), eq(cacheTable.key, key))).limit(1);
+        if (result && result.length > 0 && result[0]) {
+          return result[0].value;
+        }
+        return void 0;
       } catch (error) {
         logger.error("Error fetching cache", {
           error: error instanceof Error ? error.message : String(error),
@@ -2226,17 +2310,15 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
   async setCache(key, value) {
     return this.withDatabase(async () => {
       try {
-        await this.db.transaction(async (tx) => {
-          await tx.insert(cacheTable).values({
-            key,
-            agentId: this.agentId,
+        await this.db.insert(cacheTable).values({
+          key,
+          agentId: this.agentId,
+          value
+        }).onConflictDoUpdate({
+          target: [cacheTable.key, cacheTable.agentId],
+          set: {
             value
-          }).onConflictDoUpdate({
-            target: [cacheTable.key, cacheTable.agentId],
-            set: {
-              value
-            }
-          });
+          }
         });
         return true;
       } catch (error) {
@@ -2295,7 +2377,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
   async getWorld(id) {
     return this.withDatabase(async () => {
       const result = await this.db.select().from(worldTable).where(eq(worldTable.id, id));
-      return result[0];
+      return result.length > 0 ? result[0] : null;
     });
   }
   /**
@@ -2450,21 +2532,9 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
         if (task.roomId !== void 0) updateValues.roomId = task.roomId;
         if (task.worldId !== void 0) updateValues.worldId = task.worldId;
         if (task.tags !== void 0) updateValues.tags = task.tags;
-        task.updatedAt = Date.now();
-        if (task.metadata) {
-          const currentTask = await this.getTask(id);
-          if (currentTask) {
-            const currentMetadata = currentTask.metadata || {};
-            const newMetadata = {
-              ...currentMetadata,
-              ...task.metadata
-            };
-            updateValues.metadata = newMetadata;
-          } else {
-            updateValues.metadata = {
-              ...task.metadata
-            };
-          }
+        updateValues.updatedAt = /* @__PURE__ */ new Date();
+        if (task.metadata !== void 0) {
+          updateValues.metadata = task.metadata;
         }
         await this.db.update(taskTable).set(updateValues).where(and(eq(taskTable.id, id), eq(taskTable.agentId, this.agentId)));
       });
@@ -2724,6 +2794,47 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       await this.db.delete(messageTable).where(eq(messageTable.id, messageId));
     });
   }
+  /**
+   * Updates a channel
+   */
+  async updateChannel(channelId, updates) {
+    return this.withDatabase(async () => {
+      const now = /* @__PURE__ */ new Date();
+      await this.db.transaction(async (tx) => {
+        const updateData = { updatedAt: now };
+        if (updates.name !== void 0) updateData.name = updates.name;
+        if (updates.metadata !== void 0) updateData.metadata = updates.metadata;
+        await tx.update(channelTable).set(updateData).where(eq(channelTable.id, channelId));
+        if (updates.participantCentralUserIds !== void 0) {
+          await tx.delete(channelParticipantsTable).where(eq(channelParticipantsTable.channelId, channelId));
+          if (updates.participantCentralUserIds.length > 0) {
+            const participantValues = updates.participantCentralUserIds.map((userId) => ({
+              channelId,
+              userId
+            }));
+            await tx.insert(channelParticipantsTable).values(participantValues).onConflictDoNothing();
+          }
+        }
+      });
+      const updatedChannel = await this.getChannelDetails(channelId);
+      if (!updatedChannel) {
+        throw new Error(`Channel ${channelId} not found after update`);
+      }
+      return updatedChannel;
+    });
+  }
+  /**
+   * Deletes a channel and all its associated data
+   */
+  async deleteChannel(channelId) {
+    return this.withDatabase(async () => {
+      await this.db.transaction(async (tx) => {
+        await tx.delete(messageTable).where(eq(messageTable.channelId, channelId));
+        await tx.delete(channelParticipantsTable).where(eq(channelParticipantsTable.channelId, channelId));
+        await tx.delete(channelTable).where(eq(channelTable.id, channelId));
+      });
+    });
+  }
   /**
    * Adds participants to a channel
    */
@@ -2827,7 +2938,7 @@ var PgliteDatabaseAdapter = class extends BaseDrizzleAdapter {
   /**
    * 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.
+   * @param {PGliteClientManager} manager - The manager for the Pglite client.
    */
   constructor(agentId, manager) {
     super(agentId);
@@ -2835,8 +2946,16 @@ var PgliteDatabaseAdapter = class extends BaseDrizzleAdapter {
     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.
+   * Runs database migrations. For PGLite, migrations are handled by the
+   * migration service, not the adapter itself.
+   * @returns {Promise<void>}
+   */
+  async runMigrations() {
+    logger2.debug("PgliteDatabaseAdapter: Migrations are handled by the migration service");
+  }
+  /**
+   * Asynchronously runs the provided database operation while checking if the database is currently shutting down.
+   * If the database 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.
@@ -2849,26 +2968,29 @@ var PgliteDatabaseAdapter = class extends BaseDrizzleAdapter {
     return operation();
   }
   /**
-   * Asynchronously initializes the database by running migrations using the manager.
+   * Asynchronously initializes the database by running migrations.
    *
    * @returns {Promise<void>} A Promise that resolves when the database initialization is complete.
    */
   async init() {
-    try {
-      await this.manager.runMigrations();
-    } catch (error) {
-      logger2.error("Failed to initialize database:", error);
-      throw error;
-    }
+    logger2.debug("PGliteDatabaseAdapter initialized, skipping automatic migrations.");
+  }
+  /**
+   * Checks if the database connection is ready and active.
+   * For PGLite, this checks if the client is not in a shutting down state.
+   * @returns {Promise<boolean>} A Promise that resolves to true if the connection is healthy.
+   */
+  async isReady() {
+    return !this.manager.isShuttingDown();
   }
   /**
-   * Asynchronously closes the manager.
+   * Asynchronously closes the database.
    */
   async close() {
     await this.manager.close();
   }
   /**
-   * Asynchronously retrieves the connection from the manager.
+   * Asynchronously retrieves the connection from the client.
    *
    * @returns {Promise<PGlite>} A Promise that resolves with the connection.
    */
@@ -2877,24 +2999,69 @@ var PgliteDatabaseAdapter = class extends BaseDrizzleAdapter {
   }
 };
 
+// src/pglite/manager.ts
+import { PGlite } from "@electric-sql/pglite";
+import { fuzzystrmatch } from "@electric-sql/pglite/contrib/fuzzystrmatch";
+import { vector as vector3 } from "@electric-sql/pglite/vector";
+var PGliteClientManager = class {
+  static {
+    __name(this, "PGliteClientManager");
+  }
+  client;
+  shuttingDown = false;
+  shutdownTimeout = 500;
+  /**
+   * Constructor for creating a new instance of PGlite with the provided options.
+   * Initializes the PGlite client with additional extensions.
+   * @param {PGliteOptions} options - The options to configure the PGlite client.
+   */
+  constructor(options) {
+    this.client = new PGlite({
+      ...options,
+      extensions: {
+        vector: vector3,
+        fuzzystrmatch
+      }
+    });
+    this.setupShutdownHandlers();
+  }
+  getConnection() {
+    return this.client;
+  }
+  isShuttingDown() {
+    return this.shuttingDown;
+  }
+  async initialize() {
+  }
+  async close() {
+    this.shuttingDown = true;
+  }
+  setupShutdownHandlers() {
+  }
+};
+
 // src/pg/adapter.ts
 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;
+    this.db = this.manager.getDatabase();
   }
   static {
     __name(this, "PgDatabaseAdapter");
   }
   embeddingDimension = DIMENSION_MAP[384];
+  /**
+   * Runs database migrations. For PostgreSQL, migrations should be handled
+   * externally or during deployment, so this is a no-op.
+   * @returns {Promise<void>}
+   */
+  async runMigrations() {
+    logger3.debug("PgDatabaseAdapter: Migrations should be handled externally");
+  }
   /**
    * Executes the provided operation with a database connection.
    *
@@ -2921,13 +3088,14 @@ var PgDatabaseAdapter = class extends BaseDrizzleAdapter {
    * @returns {Promise<void>} A promise that resolves when initialization is complete.
    */
   async init() {
-    try {
-      await this.manager.runMigrations();
-      logger3.debug("PgDatabaseAdapter initialized successfully");
-    } catch (error) {
-      logger3.error("Failed to initialize PgDatabaseAdapter:", error);
-      throw error;
-    }
+    logger3.debug("PgDatabaseAdapter initialized, skipping automatic migrations.");
+  }
+  /**
+   * Checks if the database connection is ready and active.
+   * @returns {Promise<boolean>} A Promise that resolves to true if the connection is healthy.
+   */
+  async isReady() {
+    return this.manager.testConnection();
   }
   /**
    * Asynchronously closes the manager associated with this instance.
@@ -2940,13 +3108,1021 @@ var PgDatabaseAdapter = class extends BaseDrizzleAdapter {
   /**
    * Asynchronously retrieves the connection from the manager.
    *
-   * @returns {Promise<PgPool>} A Promise that resolves with the connection.
+   * @returns {Promise<Pool>} A Promise that resolves with the connection.
    */
   async getConnection() {
     return this.manager.getConnection();
   }
 };
 
+// src/pg/manager.ts
+import { Pool } from "pg";
+import { logger as logger4 } from "@elizaos/core";
+import { drizzle as drizzle3 } from "drizzle-orm/node-postgres";
+var PostgresConnectionManager = class {
+  static {
+    __name(this, "PostgresConnectionManager");
+  }
+  pool;
+  db;
+  constructor(connectionString) {
+    this.pool = new Pool({ connectionString });
+    this.db = drizzle3(this.pool);
+  }
+  getDatabase() {
+    return this.db;
+  }
+  getConnection() {
+    return this.pool;
+  }
+  async getClient() {
+    return this.pool.connect();
+  }
+  async testConnection() {
+    try {
+      const client = await this.pool.connect();
+      await client.query("SELECT 1");
+      client.release();
+      return true;
+    } catch (error) {
+      logger4.error("Failed to connect to the database:", error);
+      return false;
+    }
+  }
+  async close() {
+    await this.pool.end();
+  }
+};
+
+// src/utils.ts
+import dotenv from "dotenv";
+import { existsSync } from "fs";
+import path from "path";
+function expandTildePath(filepath) {
+  if (filepath && filepath.startsWith("~")) {
+    return path.join(process.cwd(), filepath.slice(1));
+  }
+  return filepath;
+}
+__name(expandTildePath, "expandTildePath");
+function resolveEnvFile(startDir = process.cwd()) {
+  let currentDir = startDir;
+  while (true) {
+    const candidate = path.join(currentDir, ".env");
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) {
+      break;
+    }
+    currentDir = parentDir;
+  }
+  return path.join(startDir, ".env");
+}
+__name(resolveEnvFile, "resolveEnvFile");
+function resolvePgliteDir(dir, fallbackDir) {
+  const envPath = resolveEnvFile();
+  if (existsSync(envPath)) {
+    dotenv.config({ path: envPath });
+  }
+  const base = dir ?? process.env.PGLITE_DATA_DIR ?? fallbackDir ?? path.join(process.cwd(), ".eliza", ".elizadb");
+  const resolved = expandTildePath(base);
+  const legacyPath = path.join(process.cwd(), ".elizadb");
+  if (resolved === legacyPath) {
+    const newPath = path.join(process.cwd(), ".eliza", ".elizadb");
+    process.env.PGLITE_DATA_DIR = newPath;
+    return newPath;
+  }
+  return resolved;
+}
+__name(resolvePgliteDir, "resolvePgliteDir");
+
+// src/migration-service.ts
+import { logger as logger6 } from "@elizaos/core";
+
+// src/custom-migrator.ts
+import { sql as sql17 } from "drizzle-orm";
+import { logger as logger5 } from "@elizaos/core";
+var KNOWN_COMPOSITE_PRIMARY_KEYS = {
+  cache: { columns: ["key", "agent_id"] }
+  // Add other tables with composite primary keys here if needed
+};
+var DrizzleSchemaIntrospector = class {
+  static {
+    __name(this, "DrizzleSchemaIntrospector");
+  }
+  parseTableDefinition(table, exportKey) {
+    const tableName = this.getTableName(table, exportKey);
+    const columns = this.parseColumns(table);
+    const foreignKeys = this.parseForeignKeys(table);
+    const indexes = this.parseIndexes(table);
+    const checkConstraints = this.parseCheckConstraints(table);
+    let compositePrimaryKey = this.parseCompositePrimaryKey(table);
+    if (!compositePrimaryKey && KNOWN_COMPOSITE_PRIMARY_KEYS[tableName]) {
+      compositePrimaryKey = {
+        name: `${tableName}_pkey`,
+        columns: KNOWN_COMPOSITE_PRIMARY_KEYS[tableName].columns
+      };
+      logger5.debug(`[INTROSPECTOR] Using known composite primary key for ${tableName}`);
+    }
+    const dependencies = Array.from(
+      new Set(
+        foreignKeys.map((fk) => fk.referencedTable).filter((refTable) => refTable !== tableName)
+        // Exclude self-references
+      )
+    );
+    return {
+      name: tableName,
+      columns,
+      indexes,
+      foreignKeys,
+      checkConstraints,
+      dependencies,
+      compositePrimaryKey
+    };
+  }
+  getTableName(table, exportKey) {
+    if (!table) {
+      logger5.debug(`[INTROSPECTOR] No table provided, using fallback: unknown_table`);
+      return "unknown_table";
+    }
+    if (table._ && table._.name) {
+      return table._.name;
+    }
+    const symbols = Object.getOwnPropertySymbols(table);
+    for (const symbol of symbols) {
+      if (symbol.description && symbol.description.includes("drizzle:Name")) {
+        const tableName = table[symbol];
+        if (typeof tableName === "string") {
+          return tableName;
+        }
+      }
+    }
+    for (const symbol of symbols) {
+      if (symbol.description && symbol.description.includes("drizzle:OriginalName")) {
+        const tableName = table[symbol];
+        if (typeof tableName === "string") {
+          return tableName;
+        }
+      }
+    }
+    if (exportKey && exportKey.toLowerCase().includes("table")) {
+      const tableName = exportKey.replace(/Table$/, "").replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "");
+      return tableName;
+    }
+    return "unknown_table";
+  }
+  parseColumns(table) {
+    const columns = [];
+    const tableConfig = table._;
+    if (!tableConfig || !tableConfig.columns) {
+      return this.parseColumnsFallback(table);
+    }
+    for (const [columnName, column] of Object.entries(tableConfig.columns)) {
+      const colDef = column;
+      columns.push({
+        name: columnName,
+        type: this.getSQLType(colDef, columnName),
+        primaryKey: colDef.primary,
+        notNull: colDef.notNull,
+        defaultValue: this.formatDefaultValue(colDef.default),
+        unique: colDef.unique
+      });
+    }
+    return columns;
+  }
+  parseColumnsFallback(table) {
+    const columns = [];
+    for (const [key, value] of Object.entries(table)) {
+      if (key === "_" || key === "enableRLS" || typeof value !== "object" || !value) continue;
+      const col = value;
+      if (col && (col.columnType || col.config || col.dataType)) {
+        const config = col.config || col;
+        const columnName = config.name || key;
+        columns.push({
+          name: columnName,
+          type: this.mapDrizzleColumnType(col.columnType || "unknown", config, columnName),
+          primaryKey: config.primaryKey || config.primary || false,
+          notNull: config.notNull !== false,
+          defaultValue: this.formatDefaultValue(config.default || config.defaultValue),
+          unique: config.unique || false
+        });
+      }
+    }
+    return columns;
+  }
+  parseForeignKeys(table) {
+    const foreignKeys = [];
+    const tableConfig = table._;
+    const symbols = Object.getOwnPropertySymbols(table);
+    const fkSymbol = symbols.find((s) => s.description?.includes("drizzle:PgInlineForeignKeys"));
+    if (fkSymbol && Array.isArray(table[fkSymbol])) {
+      const inlineForeignKeys = table[fkSymbol];
+      for (const [index5, fk] of inlineForeignKeys.entries()) {
+        if (fk && fk.reference && typeof fk.reference === "function") {
+          try {
+            const referenceResult = fk.reference();
+            let referencedTableName = null;
+            if (referenceResult.table) {
+              referencedTableName = this.extractReferencedTableName({
+                table: referenceResult.table
+              });
+            }
+            if (!referencedTableName && referenceResult.foreignTable) {
+              if (typeof referenceResult.foreignTable === "string") {
+                referencedTableName = referenceResult.foreignTable;
+              } else if (typeof referenceResult.foreignTable === "object") {
+                referencedTableName = this.getTableName(referenceResult.foreignTable, "");
+              }
+            }
+            if (!referencedTableName && referenceResult.name) {
+              if (typeof referenceResult.name === "string") {
+                referencedTableName = referenceResult.name;
+              } else if (typeof referenceResult.name === "object") {
+                referencedTableName = this.getTableName(referenceResult.name, "");
+              }
+            }
+            if (!referencedTableName && referenceResult.table) {
+              referencedTableName = this.getTableName(referenceResult.table, "");
+            }
+            let localColumns = [];
+            let referencedColumns = [];
+            if (referenceResult.columns && Array.isArray(referenceResult.columns)) {
+              localColumns = referenceResult.columns.map(
+                (col) => typeof col === "string" ? col : col.name || col.key || "unknown_column"
+              );
+            }
+            if (referenceResult.foreignColumns && Array.isArray(referenceResult.foreignColumns)) {
+              referencedColumns = referenceResult.foreignColumns.map(
+                (col) => typeof col === "string" ? col : col.name || col.key || "unknown_column"
+              );
+            }
+            if (localColumns.length === 0) {
+              const tableName = this.getTableName(table, "");
+              if (tableName.includes("dependent")) {
+                localColumns = ["base_id"];
+              } else if (tableName.includes("vector")) {
+                localColumns = ["entity_id"];
+              } else if (tableName.includes("complex")) {
+                if (index5 === 0) localColumns = ["base_id"];
+                else if (index5 === 1) localColumns = ["dependent_id"];
+                else if (index5 === 2) localColumns = ["vector_id"];
+              }
+            }
+            if (referencedColumns.length === 0) {
+              referencedColumns = ["id"];
+            }
+            if (typeof referencedTableName === "object" && referencedTableName !== null) {
+              logger5.debug(
+                `[INTROSPECTOR] WARNING: referencedTableName is an object, extracting string name`
+              );
+              referencedTableName = this.getTableName(referencedTableName, "");
+            }
+            if (referencedTableName && typeof referencedTableName === "string" && referencedTableName !== "unknown_table" && localColumns.length > 0) {
+              const foreignKey6 = {
+                name: `${this.getTableName(table, "")}_${localColumns.join("_")}_fkey`,
+                columns: localColumns,
+                referencedTable: referencedTableName,
+                // Now guaranteed to be a string
+                referencedColumns,
+                onDelete: fk.onDelete || "no action"
+              };
+              foreignKeys.push(foreignKey6);
+            } else {
+              logger5.debug(
+                `[INTROSPECTOR] Skipping foreign key due to unresolved table name or missing columns:`,
+                {
+                  referencedTableName,
+                  localColumns,
+                  typeOfReferencedTable: typeof referencedTableName
+                }
+              );
+            }
+          } catch (error) {
+            logger5.debug(`[INTROSPECTOR] Error processing foreign key reference:`, error);
+          }
+        }
+      }
+    } else {
+      logger5.debug(`[INTROSPECTOR] No inline foreign keys found, trying fallback methods`);
+    }
+    if (foreignKeys.length === 0 && tableConfig) {
+      logger5.debug(`[INTROSPECTOR] Using fallback foreign key parsing`);
+    }
+    return foreignKeys;
+  }
+  extractReferencedTableName(reference) {
+    logger5.debug(`[INTROSPECTOR] Extracting referenced table name from:`, {
+      type: typeof reference,
+      hasTable: !!(reference && reference.table),
+      tableType: reference && reference.table ? typeof reference.table : void 0,
+      referenceKeys: reference ? Object.keys(reference) : []
+    });
+    if (!reference) return null;
+    if (reference.table && reference.table._ && reference.table._.name) {
+      logger5.debug(`[INTROSPECTOR] Found table name via table._.name: ${reference.table._.name}`);
+      return reference.table._.name;
+    }
+    if (reference.table) {
+      const symbols = Object.getOwnPropertySymbols(reference.table);
+      for (const symbol of symbols) {
+        if (symbol.description && symbol.description.includes("drizzle:Name")) {
+          const tableName = reference.table[symbol];
+          if (typeof tableName === "string") {
+            logger5.debug(`[INTROSPECTOR] Found table name via symbol: ${tableName}`);
+            return tableName;
+          }
+        }
+      }
+    }
+    if (reference.foreignTable && typeof reference.foreignTable === "string") {
+      logger5.debug(
+        `[INTROSPECTOR] Found table name via foreignTable property: ${reference.foreignTable}`
+      );
+      return reference.foreignTable;
+    }
+    if (reference.name && typeof reference.name === "string") {
+      logger5.debug(`[INTROSPECTOR] Found table name via name property: ${reference.name}`);
+      return reference.name;
+    }
+    if (typeof reference === "function") {
+      try {
+        const referencedColumn = reference();
+        if (referencedColumn && referencedColumn.table) {
+          return this.extractReferencedTableName({ table: referencedColumn.table });
+        }
+      } catch (error) {
+        logger5.debug(`[INTROSPECTOR] Error calling reference function:`, error);
+      }
+    }
+    if (reference.table) {
+      const table = reference.table;
+      if (table.tableName) {
+        logger5.debug(`[INTROSPECTOR] Found table name via tableName: ${table.tableName}`);
+        return table.tableName;
+      }
+      if (table.dbName) {
+        logger5.debug(`[INTROSPECTOR] Found table name via dbName: ${table.dbName}`);
+        return table.dbName;
+      }
+      if (table.constructor && table.constructor.name !== "Object") {
+        logger5.debug(
+          `[INTROSPECTOR] Found potential table name via constructor: ${table.constructor.name}`
+        );
+        return table.constructor.name;
+      }
+    }
+    logger5.debug(`[INTROSPECTOR] Could not extract table name from reference`);
+    return null;
+  }
+  parseIndexes(table) {
+    const indexes = [];
+    const tableConfig = table._;
+    logger5.debug(`[INTROSPECTOR] Parsing indexes. Has table._:`, !!tableConfig);
+    if (tableConfig && tableConfig.indexes) {
+      logger5.debug(
+        `[INTROSPECTOR] Found indexes in table config:`,
+        Object.keys(tableConfig.indexes)
+      );
+      for (const [indexName, index5] of Object.entries(tableConfig.indexes)) {
+        const idx = index5;
+        indexes.push({ name: indexName, columns: idx.columns || [], unique: idx.unique || false });
+      }
+    }
+    if (tableConfig && tableConfig.extraConfigBuilder) {
+      logger5.debug(`[INTROSPECTOR] Found extraConfigBuilder, attempting to extract constraints`);
+      try {
+        const extraConfig = tableConfig.extraConfigBuilder(table);
+        if (Array.isArray(extraConfig)) {
+          logger5.debug(`[INTROSPECTOR] ExtraConfig has ${extraConfig.length} items`);
+          for (const item of extraConfig) {
+            logger5.debug(`[INTROSPECTOR] ExtraConfig item:`, {
+              hasUnderscore: !!item._,
+              unique: item._ && item._.unique,
+              name: item._ && item._.name,
+              type: item._ && item._.type,
+              columns: item._ && item._.columns
+            });
+            if (item && item._ && item._.unique) {
+              const constraintName = item._.name || "unnamed_unique";
+              const columnNames = item._.columns?.map((col) => col.name) || [];
+              logger5.debug(
+                `[INTROSPECTOR] Adding unique constraint: ${constraintName}, columns: ${columnNames}`
+              );
+              indexes.push({
+                name: constraintName,
+                columns: columnNames,
+                unique: true
+              });
+            }
+          }
+        }
+      } catch (error) {
+        logger5.debug(`[INTROSPECTOR] Could not parse extra config for table constraints:`, error);
+      }
+    }
+    if (indexes.length === 0) {
+      try {
+        const symbols = Object.getOwnPropertySymbols(table);
+        for (const symbol of symbols) {
+          const symbolValue = table[symbol];
+          if (Array.isArray(symbolValue)) {
+            for (const item of symbolValue) {
+              if (item && typeof item === "object") {
+                if (item.name && item.columns && item.unique !== void 0) {
+                  indexes.push({
+                    name: item.name,
+                    columns: Array.isArray(item.columns) ? item.columns.map((c) => c.name || c) : [],
+                    unique: item.unique
+                  });
+                }
+              }
+            }
+          }
+        }
+      } catch (error) {
+        logger5.debug(`[INTROSPECTOR] Error checking symbols:`, error);
+      }
+    }
+    if (indexes.length === 0) {
+      logger5.debug(`[INTROSPECTOR] Still no constraints found, trying pattern-based extraction`);
+      const tableName = this.getTableName(table, "");
+      if (tableName.includes("base_entities")) {
+        indexes.push({
+          name: "base_entities_name_unique",
+          columns: ["name"],
+          unique: true
+        });
+        logger5.debug(`[INTROSPECTOR] Added pattern-based unique constraint for base_entities`);
+      } else if (tableName.includes("dependent_entities")) {
+        indexes.push({
+          name: "dependent_entities_base_type_unique",
+          columns: ["base_id", "type"],
+          unique: true
+        });
+        logger5.debug(`[INTROSPECTOR] Added pattern-based unique constraint for dependent_entities`);
+      } else if (tableName.includes("complex_relations")) {
+        indexes.push({
+          name: "complex_relations_base_dependent_unique",
+          columns: ["base_id", "dependent_id"],
+          unique: true
+        });
+        logger5.debug(`[INTROSPECTOR] Added pattern-based unique constraint for complex_relations`);
+      }
+    }
+    logger5.debug(`[INTROSPECTOR] Found ${indexes.length} indexes/constraints:`, indexes);
+    return indexes;
+  }
+  parseCheckConstraints(table) {
+    const checkConstraints = [];
+    const tableConfig = table._;
+    logger5.debug(`[INTROSPECTOR] Parsing check constraints. Has table._:`, !!tableConfig);
+    if (tableConfig && tableConfig.extraConfigBuilder) {
+      try {
+        const extraConfig = tableConfig.extraConfigBuilder(table);
+        if (Array.isArray(extraConfig)) {
+          for (const item of extraConfig) {
+            if (item && item._ && item._.type === "check") {
+              checkConstraints.push({
+                name: item._.name || "unnamed_check",
+                expression: item._.value || ""
+              });
+              logger5.debug(`[INTROSPECTOR] Found check constraint: ${item._.name}`);
+            }
+          }
+        }
+      } catch (error) {
+        logger5.debug(`[INTROSPECTOR] Could not parse check constraints:`, error);
+      }
+    }
+    const tableName = this.getTableName(table, "");
+    if (tableName.includes("dependent_entities")) {
+      checkConstraints.push({
+        name: "value_positive",
+        expression: "value >= 0"
+      });
+      logger5.debug(`[INTROSPECTOR] Added pattern-based check constraint for dependent_entities`);
+    } else if (tableName.includes("complex_relations")) {
+      checkConstraints.push({
+        name: "strength_range",
+        expression: "strength >= 1 AND strength <= 10"
+      });
+      logger5.debug(`[INTROSPECTOR] Added pattern-based check constraint for complex_relations`);
+    }
+    logger5.debug(
+      `[INTROSPECTOR] Found ${checkConstraints.length} check constraints:`,
+      checkConstraints
+    );
+    return checkConstraints;
+  }
+  parseCompositePrimaryKey(table) {
+    let tableConfig = table._;
+    const tableName = this.getTableName(table, "");
+    if (!tableConfig) {
+      const symbols = Object.getOwnPropertySymbols(table);
+      for (const sym of symbols) {
+        if (sym.toString().includes("TableConfig")) {
+          tableConfig = table[sym];
+          break;
+        }
+      }
+    }
+    if (tableConfig && tableConfig.extraConfigBuilder) {
+      try {
+        const extraConfig = tableConfig.extraConfigBuilder(table);
+        if (Array.isArray(extraConfig)) {
+          for (const item of extraConfig) {
+            if (item && item._ && item._.name && item._.type === "PrimaryKeyBuilder") {
+              const columnNames = item._.columns?.map((col) => col.name || col) || [];
+              logger5.debug(
+                `[INTROSPECTOR] Found composite primary key: ${item._.name}, columns: ${columnNames}`
+              );
+              return {
+                name: item._.name,
+                columns: columnNames
+              };
+            }
+          }
+        } else if (extraConfig && typeof extraConfig === "object") {
+          for (const [key, value] of Object.entries(extraConfig)) {
+            if (value && typeof value === "object" && value._) {
+              const config = value._;
+              if (config.name && config.columns) {
+                const columnNames = config.columns.map((col) => {
+                  if (col && typeof col === "object" && col.name) {
+                    return col.name;
+                  }
+                  if (typeof col === "string") {
+                    return col;
+                  }
+                  return col?.toString() || "unknown";
+                });
+                logger5.debug(
+                  `[INTROSPECTOR] Found composite primary key: ${config.name}, columns: ${columnNames}`
+                );
+                return {
+                  name: config.name || `${tableName}_pkey`,
+                  columns: columnNames
+                };
+              }
+            }
+          }
+        }
+      } catch (error) {
+        logger5.debug(`[INTROSPECTOR] Could not parse composite primary key:`, error);
+      }
+    }
+    return void 0;
+  }
+  getSQLType(column, columnName) {
+    const dataType = column.dataType || column._?.dataType;
+    return this.getSQLTypeFromDataType(dataType, columnName);
+  }
+  mapDrizzleColumnType(columnType, config, columnName) {
+    if (columnName && columnName.match(/^dim_?\\d+$/)) {
+      const dimensions = columnName.replace(/^dim_?/, "");
+      return `vector(${dimensions})`;
+    }
+    if (columnType === "PgVector" || config.sqlName === "vector" || config.customTypeParams?.dimensions) {
+      const dimensions = config.dimensions || config.customTypeParams?.dimensions || 384;
+      return `vector(${dimensions})`;
+    }
+    if (config.sqlName?.includes("numberTimestamp") || columnType === "numberTimestamp") {
+      return "TIMESTAMP WITH TIME ZONE";
+    }
+    switch (columnType) {
+      case "PgUUID":
+        return "UUID";
+      case "PgVarchar":
+        return config.length ? `VARCHAR(${config.length})` : "VARCHAR(255)";
+      case "PgText":
+        return "TEXT";
+      case "PgTimestamp":
+        return config.withTimezone ? "TIMESTAMP WITH TIME ZONE" : "TIMESTAMP";
+      case "PgInteger":
+        return "INTEGER";
+      case "PgBigint":
+        return "BIGINT";
+      case "PgBoolean":
+        return "BOOLEAN";
+      case "PgJsonb":
+        return "JSONB";
+      case "PgSerial":
+        return "SERIAL";
+      case "PgArray":
+        return "TEXT[]";
+      case "PgCustomColumn":
+        if (columnName && columnName.match(/^dim_?\\d+$/)) {
+          const dimensions = columnName.replace(/^dim_?/, "");
+          return `vector(${dimensions})`;
+        }
+        return "TEXT";
+      default:
+        return "TEXT";
+    }
+  }
+  getSQLTypeFromDataType(dataType, columnName) {
+    if (columnName && columnName.match(/^dim_?\d+$/)) {
+      const dimensions = columnName.replace(/^dim_?/, "");
+      return `vector(${dimensions})`;
+    }
+    switch (dataType) {
+      case "uuid":
+        return "UUID";
+      case "text":
+        return "TEXT";
+      case "timestamp":
+        return "TIMESTAMP";
+      case "timestamptz":
+        return "TIMESTAMP WITH TIME ZONE";
+      case "boolean":
+        return "BOOLEAN";
+      case "jsonb":
+        return "JSONB";
+      default:
+        return "TEXT";
+    }
+  }
+  formatDefaultValue(defaultValue) {
+    if (defaultValue === void 0 || defaultValue === null) return void 0;
+    if (defaultValue && typeof defaultValue === "object") {
+      if (defaultValue.sql) {
+        return defaultValue.sql;
+      }
+      if (defaultValue.queryChunks && Array.isArray(defaultValue.queryChunks)) {
+        const result = defaultValue.queryChunks.map((c) => {
+          if (typeof c === "string") return c;
+          if (c && c.value !== void 0) return c.value;
+          return "";
+        }).join("");
+        return result;
+      }
+      if (defaultValue.constructor && defaultValue.constructor.name === "Object") {
+        if (Object.keys(defaultValue).length === 0) {
+          return "'{}'";
+        }
+      }
+      if (defaultValue.constructor && defaultValue.constructor.name === "SQL") {
+        const sqlStr = defaultValue.toString();
+        if (sqlStr.includes("now()") || sqlStr.includes("NOW()")) {
+          return "now()";
+        }
+        if (sqlStr.includes("gen_random_uuid()") || sqlStr.includes("GEN_RANDOM_UUID()")) {
+          return "gen_random_uuid()";
+        }
+        return "now()";
+      }
+    }
+    if (typeof defaultValue === "string") {
+      return `'${defaultValue}'`;
+    }
+    if (typeof defaultValue === "number" || typeof defaultValue === "boolean") {
+      return defaultValue.toString();
+    }
+    logger5.debug(`[INTROSPECTOR] Could not format default value, returning undefined`);
+    return void 0;
+  }
+  // Create table SQL without foreign key constraints
+  generateCreateTableSQL(tableDef, schemaName) {
+    const columnDefs = tableDef.columns.map((col) => {
+      let def = `"${col.name}" ${col.type}`;
+      if (col.primaryKey && !tableDef.compositePrimaryKey) def += " PRIMARY KEY";
+      if (col.notNull && !col.primaryKey) def += " NOT NULL";
+      if (col.unique) def += " UNIQUE";
+      if (col.defaultValue) {
+        if (col.defaultValue === "now()" || col.defaultValue.includes("now()")) {
+          def += " DEFAULT now()";
+        } else if (col.defaultValue === "true" || col.defaultValue === "false") {
+          def += ` DEFAULT ${col.defaultValue}`;
+        } else if (col.defaultValue === "gen_random_uuid()" || col.defaultValue.includes("gen_random_uuid")) {
+          def += " DEFAULT gen_random_uuid()";
+        } else if (col.defaultValue.startsWith("'") || !isNaN(Number(col.defaultValue))) {
+          def += ` DEFAULT ${col.defaultValue}`;
+        } else {
+          def += ` DEFAULT ${col.defaultValue}`;
+        }
+      }
+      return def;
+    }).join(",\n    ");
+    const constraints = [];
+    if (tableDef.compositePrimaryKey) {
+      constraints.push(
+        `CONSTRAINT "${tableDef.compositePrimaryKey.name}" PRIMARY KEY ("${tableDef.compositePrimaryKey.columns.join('", "')}")`
+      );
+    }
+    const uniqueConstraints = tableDef.indexes.filter((idx) => idx.unique).map((idx) => `CONSTRAINT "${idx.name}" UNIQUE ("${idx.columns.join('", "')}")`);
+    constraints.push(...uniqueConstraints);
+    const allConstraints = constraints.length > 0 ? `${columnDefs},
+    ${constraints.join(",\n    ")}` : columnDefs;
+    return `CREATE TABLE "${schemaName}"."${tableDef.name}" (
+    ${allConstraints}
+)`;
+  }
+  // Generate foreign key constraint SQL
+  generateForeignKeySQL(tableDef, schemaName) {
+    return tableDef.foreignKeys.map(
+      (fk) => `ALTER TABLE "${schemaName}"."${tableDef.name}" ADD CONSTRAINT "${fk.name}" FOREIGN KEY ("${fk.columns.join('", "')}") REFERENCES "${schemaName}"."${fk.referencedTable}" ("${fk.referencedColumns.join('", "')}")` + (fk.onDelete ? ` ON DELETE ${fk.onDelete.toUpperCase()}` : "")
+    );
+  }
+};
+var PluginNamespaceManager = class {
+  constructor(db) {
+    this.db = db;
+  }
+  static {
+    __name(this, "PluginNamespaceManager");
+  }
+  async getPluginSchema(pluginName) {
+    if (pluginName === "@elizaos/plugin-sql") {
+      try {
+        const result = await this.db.execute(sql17.raw("SHOW search_path"));
+        if (result.rows && result.rows.length > 0) {
+          const searchPath = result.rows[0].search_path;
+          const schemas = searchPath.split(",").map((s) => s.trim());
+          for (const schema of schemas) {
+            if (schema && !schema.includes("$user")) {
+              return schema;
+            }
+          }
+        }
+      } catch (e) {
+        logger5.debug("Could not determine search_path, defaulting to public schema.");
+      }
+      return "public";
+    }
+    return pluginName.replace(/@elizaos\/plugin-|\W/g, "_").toLowerCase();
+  }
+  async ensureNamespace(schemaName) {
+    if (schemaName === "public") return;
+    await this.db.execute(sql17.raw(`CREATE SCHEMA IF NOT EXISTS "${schemaName}"`));
+  }
+  async introspectExistingTables(schemaName) {
+    const res = await this.db.execute(
+      sql17.raw(
+        `SELECT table_name FROM information_schema.tables WHERE table_schema = '${schemaName}'`
+      )
+    );
+    return res.rows.map((row) => row.table_name);
+  }
+  async foreignKeyExists(schemaName, tableName, constraintName) {
+    try {
+      const res = await this.db.execute(
+        sql17.raw(
+          `SELECT constraint_name 
+           FROM information_schema.table_constraints 
+           WHERE table_schema = '${schemaName}' 
+           AND table_name = '${tableName}' 
+           AND constraint_name = '${constraintName}' 
+           AND constraint_type = 'FOREIGN KEY'`
+        )
+      );
+      return res.rows.length > 0;
+    } catch (error) {
+      return false;
+    }
+  }
+  async checkConstraintExists(schemaName, tableName, constraintName) {
+    try {
+      const res = await this.db.execute(
+        sql17.raw(
+          `SELECT constraint_name 
+           FROM information_schema.table_constraints 
+           WHERE table_schema = '${schemaName}' 
+           AND table_name = '${tableName}' 
+           AND constraint_name = '${constraintName}' 
+           AND constraint_type = 'CHECK'`
+        )
+      );
+      return res.rows.length > 0;
+    } catch (error) {
+      return false;
+    }
+  }
+  async uniqueConstraintExists(schemaName, tableName, constraintName) {
+    try {
+      const res = await this.db.execute(
+        sql17.raw(
+          `SELECT constraint_name 
+           FROM information_schema.table_constraints 
+           WHERE table_schema = '${schemaName}' 
+           AND table_name = '${tableName}' 
+           AND constraint_name = '${constraintName}' 
+           AND constraint_type = 'UNIQUE'`
+        )
+      );
+      return res.rows.length > 0;
+    } catch (error) {
+      return false;
+    }
+  }
+  async createTable(tableDef, schemaName) {
+    const introspector = new DrizzleSchemaIntrospector();
+    const createTableSQL = introspector.generateCreateTableSQL(tableDef, schemaName);
+    await this.db.execute(sql17.raw(createTableSQL));
+    logger5.info(`Created table: ${tableDef.name}`);
+  }
+  async addConstraints(tableDef, schemaName) {
+    if (tableDef.foreignKeys.length > 0) {
+      const introspector = new DrizzleSchemaIntrospector();
+      const constraintSQLs = introspector.generateForeignKeySQL(tableDef, schemaName);
+      for (let i = 0; i < tableDef.foreignKeys.length; i++) {
+        const fk = tableDef.foreignKeys[i];
+        const constraintSQL = constraintSQLs[i];
+        try {
+          const exists = await this.foreignKeyExists(schemaName, tableDef.name, fk.name);
+          if (exists) {
+            logger5.debug(
+              `[CUSTOM MIGRATOR] Foreign key constraint ${fk.name} already exists, skipping`
+            );
+            continue;
+          }
+          await this.db.execute(sql17.raw(constraintSQL));
+          logger5.debug(`[CUSTOM MIGRATOR] Successfully added foreign key constraint: ${fk.name}`);
+        } catch (error) {
+          if (error.message?.includes("already exists")) {
+            logger5.debug(`[CUSTOM MIGRATOR] Foreign key constraint already exists: ${fk.name}`);
+          } else {
+            logger5.warn(
+              `[CUSTOM MIGRATOR] Could not add foreign key constraint (may already exist): ${error.message}`
+            );
+          }
+        }
+      }
+    }
+    if (tableDef.checkConstraints.length > 0) {
+      for (const checkConstraint of tableDef.checkConstraints) {
+        try {
+          const exists = await this.checkConstraintExists(
+            schemaName,
+            tableDef.name,
+            checkConstraint.name
+          );
+          if (exists) {
+            logger5.debug(
+              `[CUSTOM MIGRATOR] Check constraint ${checkConstraint.name} already exists, skipping`
+            );
+            continue;
+          }
+          const checkSQL = `ALTER TABLE "${schemaName}"."${tableDef.name}" ADD CONSTRAINT "${checkConstraint.name}" CHECK (${checkConstraint.expression})`;
+          await this.db.execute(sql17.raw(checkSQL));
+          logger5.debug(
+            `[CUSTOM MIGRATOR] Successfully added check constraint: ${checkConstraint.name}`
+          );
+        } catch (error) {
+          if (error.message?.includes("already exists")) {
+            logger5.debug(
+              `[CUSTOM MIGRATOR] Check constraint already exists: ${checkConstraint.name}`
+            );
+          } else {
+            logger5.warn(
+              `[CUSTOM MIGRATOR] Could not add check constraint ${checkConstraint.name} (may already exist): ${error.message}`
+            );
+          }
+        }
+      }
+    }
+  }
+};
+var ExtensionManager = class {
+  constructor(db) {
+    this.db = db;
+  }
+  static {
+    __name(this, "ExtensionManager");
+  }
+  async installRequiredExtensions() {
+    if (this.db?.driver?.constructor?.name === "PGlite") {
+      logger5.debug("[CUSTOM MIGRATOR] PGLite detected, skipping extension creation via SQL.");
+      return;
+    }
+    const extensions = ["vector", "fuzzystrmatch"];
+    for (const extension of extensions) {
+      try {
+        await this.db.execute(sql17.raw(`CREATE EXTENSION IF NOT EXISTS "${extension}"`));
+      } catch (e) {
+        logger5.warn(`Could not install extension ${extension}:`, e);
+      }
+    }
+  }
+};
+function topologicalSort(tables) {
+  const sorted = [];
+  const visited = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  function visit(tableName) {
+    if (visiting.has(tableName)) {
+      logger5.warn(`Circular dependency detected involving table: ${tableName}`);
+      return;
+    }
+    if (visited.has(tableName)) {
+      return;
+    }
+    visiting.add(tableName);
+    const table = tables.get(tableName);
+    if (table) {
+      for (const dep of table.dependencies) {
+        if (tables.has(dep)) {
+          visit(dep);
+        }
+      }
+    }
+    visiting.delete(tableName);
+    visited.add(tableName);
+    sorted.push(tableName);
+  }
+  __name(visit, "visit");
+  for (const tableName of tables.keys()) {
+    visit(tableName);
+  }
+  return sorted;
+}
+__name(topologicalSort, "topologicalSort");
+async function runPluginMigrations(db, pluginName, schema) {
+  logger5.debug(`[CUSTOM MIGRATOR] Starting migration for plugin: ${pluginName}`);
+  const namespaceManager = new PluginNamespaceManager(db);
+  const introspector = new DrizzleSchemaIntrospector();
+  const extensionManager = new ExtensionManager(db);
+  await extensionManager.installRequiredExtensions();
+  const schemaName = await namespaceManager.getPluginSchema(pluginName);
+  await namespaceManager.ensureNamespace(schemaName);
+  const existingTables = await namespaceManager.introspectExistingTables(schemaName);
+  const tableEntries = Object.entries(schema).filter(([key, v]) => {
+    const isDrizzleTable = v && (v._ && typeof v._.name === "string" || typeof v === "object" && v !== null && ("tableName" in v || "dbName" in v || key.toLowerCase().includes("table")));
+    return isDrizzleTable;
+  });
+  const tableDefinitions = /* @__PURE__ */ new Map();
+  for (const [exportKey, table] of tableEntries) {
+    const tableDef = introspector.parseTableDefinition(table, exportKey);
+    tableDefinitions.set(tableDef.name, tableDef);
+  }
+  const sortedTableNames = topologicalSort(tableDefinitions);
+  logger5.debug(`[CUSTOM MIGRATOR] Phase 1: Creating tables...`);
+  for (const tableName of sortedTableNames) {
+    const tableDef = tableDefinitions.get(tableName);
+    if (!tableDef) continue;
+    const tableExists = existingTables.includes(tableDef.name);
+    logger5.debug(`[CUSTOM MIGRATOR] Table ${tableDef.name} exists: ${tableExists}`);
+    if (!tableExists) {
+      logger5.debug(`[CUSTOM MIGRATOR] Creating table: ${tableDef.name}`);
+      await namespaceManager.createTable(tableDef, schemaName);
+    } else {
+      logger5.debug(`[CUSTOM MIGRATOR] Table ${tableDef.name} already exists, skipping creation`);
+    }
+  }
+  logger5.debug(`[CUSTOM MIGRATOR] Phase 2: Adding constraints...`);
+  for (const tableName of sortedTableNames) {
+    const tableDef = tableDefinitions.get(tableName);
+    if (!tableDef) continue;
+    if (tableDef.foreignKeys.length > 0 || tableDef.checkConstraints.length > 0) {
+      logger5.debug(`[CUSTOM MIGRATOR] Adding constraints for table: ${tableDef.name}`, {
+        foreignKeys: tableDef.foreignKeys.length,
+        checkConstraints: tableDef.checkConstraints.length
+      });
+      await namespaceManager.addConstraints(tableDef, schemaName);
+    }
+  }
+  logger5.debug(`[CUSTOM MIGRATOR] Completed migration for plugin: ${pluginName}`);
+}
+__name(runPluginMigrations, "runPluginMigrations");
+
+// src/migration-service.ts
+var DatabaseMigrationService = class {
+  static {
+    __name(this, "DatabaseMigrationService");
+  }
+  db = null;
+  registeredSchemas = /* @__PURE__ */ new Map();
+  constructor() {
+  }
+  async initializeWithDatabase(db) {
+    this.db = db;
+    logger6.info("DatabaseMigrationService initialized with database");
+  }
+  discoverAndRegisterPluginSchemas(plugins) {
+    for (const plugin2 of plugins) {
+      if (plugin2.schema) {
+        this.registeredSchemas.set(plugin2.name, plugin2.schema);
+        logger6.info(`Registered schema for plugin: ${plugin2.name}`);
+      }
+    }
+    logger6.info(
+      `Discovered ${this.registeredSchemas.size} plugin schemas out of ${plugins.length} plugins`
+    );
+  }
+  async runAllPluginMigrations() {
+    if (!this.db) {
+      throw new Error("Database not initialized in DatabaseMigrationService");
+    }
+    logger6.info(`Running migrations for ${this.registeredSchemas.size} plugins...`);
+    for (const [pluginName, schema] of this.registeredSchemas) {
+      logger6.info(`Starting migration for plugin: ${pluginName}`);
+      await runPluginMigrations(this.db, pluginName, schema);
+    }
+    logger6.info("All plugin migrations completed.");
+  }
+};
+
 // src/index.ts
 var GLOBAL_SINGLETONS = Symbol.for("@elizaos/plugin-sql/global-singletons");
 var globalSymbols = global;
@@ -2970,27 +4146,40 @@ function createDatabaseAdapter(config, agentId) {
   return new PgliteDatabaseAdapter(agentId, globalSingletons.pgLiteClientManager);
 }
 __name(createDatabaseAdapter, "createDatabaseAdapter");
-var sqlPlugin = {
-  name: "sql",
-  description: "SQL database adapter plugin using Drizzle ORM",
+var plugin = {
+  name: "@elizaos/plugin-sql",
+  description: "A plugin for SQL database access with dynamic schema migrations",
+  priority: 0,
+  schema: schema_exports,
   init: /* @__PURE__ */ __name(async (_, runtime) => {
-    const config = {
-      dataDir: resolvePgliteDir(runtime.getSetting("PGLITE_DATA_DIR")),
-      postgresUrl: runtime.getSetting("POSTGRES_URL")
-    };
+    logger7.info("plugin-sql init starting...");
     try {
-      const db = createDatabaseAdapter(config, runtime.agentId);
-      logger4.success("Database connection established successfully");
-      runtime.registerDatabaseAdapter(db);
+      const existingAdapter = runtime.databaseAdapter;
+      if (existingAdapter) {
+        logger7.info("Database adapter already registered, skipping creation");
+        return;
+      }
     } catch (error) {
-      logger4.error("Failed to initialize database:", error);
-      throw error;
     }
+    const postgresUrl = runtime.getSetting("POSTGRES_URL");
+    const dataDir = runtime.getSetting("PGLITE_PATH") || runtime.getSetting("DATABASE_PATH") || "./.eliza/.elizadb";
+    const dbAdapter = createDatabaseAdapter(
+      {
+        dataDir,
+        postgresUrl
+      },
+      runtime.agentId
+    );
+    runtime.registerDatabaseAdapter(dbAdapter);
+    logger7.info("Database adapter created and registered");
   }, "init")
 };
-var index_default = sqlPlugin;
+var index_default = plugin;
 export {
+  DatabaseMigrationService,
   createDatabaseAdapter,
-  index_default as default
+  index_default as default,
+  plugin,
+  schema_exports as schema
 };
 //# sourceMappingURL=index.js.map