@elizaos/plugin-sql 1.0.0-alpha.1

package/dist/index.js

@@ -0,0 +1,2177 @@
+// src/index.ts
+import {
+  logger as logger6
+} from "@elizaos/core";
+
+// src/pg-lite/adapter.ts
+import { logger as logger2 } from "@elizaos/core";
+import { drizzle } from "drizzle-orm/pglite";
+
+// src/base.ts
+import {
+  DatabaseAdapter,
+  logger
+} from "@elizaos/core";
+import {
+  and,
+  cosineDistance,
+  count,
+  desc,
+  eq,
+  gte,
+  inArray,
+  lte,
+  or,
+  sql as sql13
+} from "drizzle-orm";
+import { v4 } from "uuid";
+
+// src/schema/embedding.ts
+import {
+  pgTable as pgTable6,
+  uuid as uuid6,
+  vector as vector2,
+  index as index2,
+  foreignKey as foreignKey2,
+  check as check2
+} from "drizzle-orm/pg-core";
+import { sql as sql6 } from "drizzle-orm";
+
+// 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/memory.ts
+import {
+  pgTable as pgTable5,
+  uuid as uuid5,
+  text as text5,
+  jsonb as jsonb5,
+  index,
+  boolean as boolean2,
+  foreignKey,
+  check
+} from "drizzle-orm/pg-core";
+import { relations, sql as sql5 } from "drizzle-orm";
+
+// src/schema/entity.ts
+import { sql as sql2 } from "drizzle-orm";
+import { jsonb as jsonb2, pgTable as pgTable2, text as text2, unique as unique2, uuid as uuid2 } from "drizzle-orm/pg-core";
+
+// src/schema/agent.ts
+import {
+  boolean,
+  jsonb,
+  pgTable,
+  text,
+  uuid,
+  unique
+} from "drizzle-orm/pg-core";
+import { sql } from "drizzle-orm";
+var agentTable = pgTable(
+  "agents",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    createdAt: numberTimestamp("createdAt").default(sql`now()`).notNull(),
+    updatedAt: numberTimestamp("updatedAt").default(sql`now()`).notNull(),
+    enabled: boolean("enabled").default(true).notNull(),
+    // Character
+    name: text("name"),
+    username: text("username"),
+    system: text("system"),
+    bio: jsonb("bio").$type().notNull(),
+    messageExamples: jsonb("message_examples").$type().default(sql`'[]'::jsonb`),
+    postExamples: jsonb("post_examples").$type().default(sql`'[]'::jsonb`),
+    topics: jsonb("topics").$type().default(sql`'[]'::jsonb`),
+    adjectives: jsonb("adjectives").$type().default(sql`'[]'::jsonb`),
+    knowledge: jsonb("knowledge").$type().default(sql`'[]'::jsonb`),
+    plugins: jsonb("plugins").$type().default(sql`'[]'::jsonb`),
+    settings: jsonb("settings").$type().default(sql`'{}'::jsonb`),
+    style: jsonb("style").$type().default(sql`'{}'::jsonb`)
+  },
+  (table) => {
+    return {
+      nameUnique: unique("name_unique").on(table.name)
+    };
+  }
+);
+
+// src/schema/entity.ts
+var entityTable = pgTable2(
+  "entities",
+  {
+    id: uuid2("id").notNull().primaryKey(),
+    agentId: uuid2("agentId").notNull().references(() => agentTable.id, {
+      onDelete: "cascade"
+    }),
+    createdAt: numberTimestamp("createdAt").default(sql2`now()`).notNull(),
+    names: text2("names").array().default(sql2`'{}'::text[]`),
+    metadata: jsonb2("metadata").default(sql2`'{}'::jsonb`)
+  },
+  (table) => {
+    return {
+      idAgentIdUnique: unique2("id_agent_id_unique").on(table.id, table.agentId)
+    };
+  }
+);
+
+// src/schema/room.ts
+import { sql as sql4 } from "drizzle-orm";
+import { jsonb as jsonb4, pgTable as pgTable4, text as text4, uuid as uuid4 } from "drizzle-orm/pg-core";
+
+// src/schema/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";
+var worldTable = pgTable3("worlds", {
+  id: uuid3("id").notNull().primaryKey().default(sql3`gen_random_uuid()`),
+  agentId: uuid3("agentId").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
+  name: text3("name").notNull(),
+  metadata: jsonb3("metadata"),
+  serverId: text3("serverId").notNull(),
+  createdAt: numberTimestamp("createdAt").default(sql3`now()`).notNull()
+});
+
+// src/schema/room.ts
+var roomTable = pgTable4("rooms", {
+  id: uuid4("id").notNull().primaryKey().default(sql4`gen_random_uuid()`),
+  agentId: uuid4("agentId").references(() => agentTable.id, {
+    onDelete: "cascade"
+  }),
+  source: text4("source").notNull(),
+  type: text4("type").notNull(),
+  serverId: text4("serverId"),
+  worldId: uuid4("worldId").references(() => worldTable.id, {
+    onDelete: "cascade"
+  }),
+  name: text4("name"),
+  metadata: jsonb4("metadata"),
+  channelId: text4("channelId"),
+  createdAt: numberTimestamp("createdAt").default(sql4`now()`).notNull()
+});
+
+// src/schema/memory.ts
+var memoryTable = pgTable5(
+  "memories",
+  {
+    id: uuid5("id").primaryKey().notNull(),
+    type: text5("type").notNull(),
+    createdAt: numberTimestamp("createdAt").default(sql5`now()`).notNull(),
+    content: jsonb5("content").notNull(),
+    entityId: uuid5("entityId").references(() => entityTable.id, {
+      onDelete: "cascade"
+    }),
+    agentId: uuid5("agentId").references(() => agentTable.id, {
+      onDelete: "cascade"
+    }),
+    roomId: uuid5("roomId").references(() => roomTable.id, {
+      onDelete: "cascade"
+    }),
+    unique: boolean2("unique").default(true).notNull(),
+    metadata: jsonb5("metadata").default({}).notNull()
+  },
+  (table) => [
+    index("idx_memories_type_room").on(table.type, table.roomId),
+    foreignKey({
+      name: "fk_room",
+      columns: [table.roomId],
+      foreignColumns: [roomTable.id]
+    }).onDelete("cascade"),
+    foreignKey({
+      name: "fk_user",
+      columns: [table.entityId],
+      foreignColumns: [entityTable.id]
+    }).onDelete("cascade"),
+    foreignKey({
+      name: "fk_agent",
+      columns: [table.agentId],
+      foreignColumns: [entityTable.id]
+    }).onDelete("cascade"),
+    index("idx_memories_metadata_type").on(sql5`((metadata->>'type'))`),
+    index("idx_memories_document_id").on(sql5`((metadata->>'documentId'))`),
+    index("idx_fragments_order").on(
+      sql5`((metadata->>'documentId'))`,
+      sql5`((metadata->>'position'))`
+    ),
+    check(
+      "fragment_metadata_check",
+      sql5`
+            CASE 
+                WHEN metadata->>'type' = 'fragment' THEN
+                    metadata ? 'documentId' AND 
+                    metadata ? 'position'
+                ELSE true
+            END
+        `
+    ),
+    check(
+      "document_metadata_check",
+      sql5`
+            CASE 
+                WHEN metadata->>'type' = 'document' THEN
+                    metadata ? 'timestamp'
+                ELSE true
+            END
+        `
+    )
+  ]
+);
+var memoryRelations = relations(memoryTable, ({ one }) => ({
+  embedding: one(embeddingTable)
+}));
+
+// src/schema/embedding.ts
+var VECTOR_DIMS = {
+  SMALL: 384,
+  MEDIUM: 512,
+  LARGE: 768,
+  XL: 1024,
+  XXL: 1536,
+  XXXL: 3072
+};
+var DIMENSION_MAP = {
+  [VECTOR_DIMS.SMALL]: "dim384",
+  [VECTOR_DIMS.MEDIUM]: "dim512",
+  [VECTOR_DIMS.LARGE]: "dim768",
+  [VECTOR_DIMS.XL]: "dim1024",
+  [VECTOR_DIMS.XXL]: "dim1536",
+  [VECTOR_DIMS.XXXL]: "dim3072"
+};
+var embeddingTable = pgTable6(
+  "embeddings",
+  {
+    id: uuid6("id").primaryKey().defaultRandom().notNull(),
+    memoryId: uuid6("memory_id").references(() => memoryTable.id),
+    createdAt: numberTimestamp("created_at").default(sql6`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 }),
+    dim1024: vector2("dim_1024", { dimensions: VECTOR_DIMS.XL }),
+    dim1536: vector2("dim_1536", { dimensions: VECTOR_DIMS.XXL }),
+    dim3072: vector2("dim_3072", { dimensions: VECTOR_DIMS.XXXL })
+  },
+  (table) => [
+    check2("embedding_source_check", sql6`"memory_id" IS NOT NULL`),
+    index2("idx_embedding_memory").on(table.memoryId),
+    foreignKey2({
+      name: "fk_embedding_memory",
+      columns: [table.memoryId],
+      foreignColumns: [memoryTable.id]
+    }).onDelete("cascade")
+  ]
+);
+
+// src/schema/cache.ts
+import { sql as sql7 } from "drizzle-orm";
+import { jsonb as jsonb6, pgTable as pgTable7, text as text6, unique as unique4, uuid as uuid7 } from "drizzle-orm/pg-core";
+var cacheTable = pgTable7(
+  "cache",
+  {
+    id: uuid7("id").notNull().primaryKey().default(sql7`gen_random_uuid()`),
+    key: text6("key").notNull(),
+    agentId: uuid7("agentId").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
+    value: jsonb6("value").notNull(),
+    createdAt: numberTimestamp("createdAt").default(sql7`now()`).notNull(),
+    expiresAt: numberTimestamp("expiresAt")
+  },
+  (table) => [unique4("cache_key_agent_unique").on(table.key, table.agentId)]
+);
+
+// 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";
+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"
+  }),
+  type: text7("type").notNull(),
+  data: jsonb7("data").default(sql8`'{}'::jsonb`),
+  createdAt: numberTimestamp("createdAt").default(sql8`now()`).notNull()
+});
+
+// src/schema/goal.ts
+import { pgTable as pgTable9, uuid as uuid9, text as text8, jsonb as jsonb8, foreignKey as foreignKey3 } from "drizzle-orm/pg-core";
+import { sql as sql9 } from "drizzle-orm";
+var goalTable = pgTable9(
+  "goals",
+  {
+    id: uuid9("id").notNull().primaryKey().default(sql9`gen_random_uuid()`),
+    createdAt: numberTimestamp("createdAt").default(sql9`now()`).notNull(),
+    entityId: uuid9("entityId").references(() => entityTable.id, {
+      onDelete: "cascade"
+    }),
+    agentId: uuid9("agentId").references(() => agentTable.id, {
+      onDelete: "cascade"
+    }),
+    name: text8("name"),
+    status: text8("status"),
+    description: text8("description"),
+    roomId: uuid9("roomId").references(() => roomTable.id, {
+      onDelete: "cascade"
+    }),
+    objectives: jsonb8("objectives").default("[]").notNull()
+  },
+  (table) => [
+    foreignKey3({
+      name: "fk_room",
+      columns: [table.roomId],
+      foreignColumns: [roomTable.id]
+    }).onDelete("cascade"),
+    foreignKey3({
+      name: "fk_user",
+      columns: [table.entityId],
+      foreignColumns: [entityTable.id]
+    }).onDelete("cascade")
+  ]
+);
+
+// src/schema/log.ts
+import { pgTable as pgTable10, uuid as uuid10, text as text9, jsonb as jsonb9, foreignKey as foreignKey4 } from "drizzle-orm/pg-core";
+import { sql as sql10 } from "drizzle-orm";
+var logTable = pgTable10(
+  "logs",
+  {
+    id: uuid10("id").defaultRandom().notNull(),
+    createdAt: numberTimestamp("createdAt").default(sql10`now()`).notNull(),
+    entityId: uuid10("entityId").notNull().references(() => entityTable.id),
+    body: jsonb9("body").notNull(),
+    type: text9("type").notNull(),
+    roomId: uuid10("roomId").notNull().references(() => roomTable.id)
+  },
+  (table) => [
+    foreignKey4({
+      name: "fk_room",
+      columns: [table.roomId],
+      foreignColumns: [roomTable.id]
+    }).onDelete("cascade"),
+    foreignKey4({
+      name: "fk_user",
+      columns: [table.entityId],
+      foreignColumns: [entityTable.id]
+    }).onDelete("cascade")
+  ]
+);
+
+// src/schema/participant.ts
+import {
+  pgTable as pgTable11,
+  uuid as uuid11,
+  text as text10,
+  index as index3,
+  foreignKey as foreignKey5
+} from "drizzle-orm/pg-core";
+import { sql as sql11 } from "drizzle-orm";
+var participantTable = pgTable11(
+  "participants",
+  {
+    id: uuid11("id").notNull().primaryKey().default(sql11`gen_random_uuid()`),
+    createdAt: numberTimestamp("createdAt").default(sql11`now()`).notNull(),
+    entityId: uuid11("entityId").references(() => entityTable.id, {
+      onDelete: "cascade"
+    }),
+    roomId: uuid11("roomId").references(() => roomTable.id, {
+      onDelete: "cascade"
+    }),
+    agentId: uuid11("agentId").references(() => agentTable.id, {
+      onDelete: "cascade"
+    }),
+    roomState: text10("roomState")
+  },
+  (table) => [
+    // unique("participants_user_room_agent_unique").on(table.entityId, table.roomId, table.agentId),
+    index3("idx_participants_user").on(table.entityId),
+    index3("idx_participants_room").on(table.roomId),
+    foreignKey5({
+      name: "fk_room",
+      columns: [table.roomId],
+      foreignColumns: [roomTable.id]
+    }).onDelete("cascade"),
+    foreignKey5({
+      name: "fk_user",
+      columns: [table.entityId],
+      foreignColumns: [entityTable.id]
+    }).onDelete("cascade")
+  ]
+);
+
+// src/schema/relationship.ts
+import { sql as sql12 } from "drizzle-orm";
+import {
+  foreignKey as foreignKey6,
+  index as index4,
+  jsonb as jsonb10,
+  pgTable as pgTable12,
+  text as text11,
+  unique as unique6,
+  uuid as uuid12
+} from "drizzle-orm/pg-core";
+var relationshipTable = pgTable12(
+  "relationships",
+  {
+    id: uuid12("id").notNull().primaryKey().default(sql12`gen_random_uuid()`),
+    createdAt: numberTimestamp("createdAt").default(sql12`now()`).notNull(),
+    sourceEntityId: uuid12("sourceEntityId").notNull().references(() => entityTable.id, { onDelete: "cascade" }),
+    targetEntityId: uuid12("targetEntityId").notNull().references(() => entityTable.id, { onDelete: "cascade" }),
+    agentId: uuid12("agentId").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
+    tags: text11("tags").array(),
+    metadata: jsonb10("metadata")
+  },
+  (table) => [
+    index4("idx_relationships_users").on(
+      table.sourceEntityId,
+      table.targetEntityId
+    ),
+    unique6("unique_relationship").on(
+      table.sourceEntityId,
+      table.targetEntityId,
+      table.agentId
+    ),
+    foreignKey6({
+      name: "fk_user_a",
+      columns: [table.sourceEntityId],
+      foreignColumns: [entityTable.id]
+    }).onDelete("cascade"),
+    foreignKey6({
+      name: "fk_user_b",
+      columns: [table.targetEntityId],
+      foreignColumns: [entityTable.id]
+    }).onDelete("cascade")
+  ]
+);
+
+// src/schema/tasks.ts
+import { jsonb as jsonb11, pgTable as pgTable13, text as text12, timestamp, uuid as uuid13 } from "drizzle-orm/pg-core";
+var taskTable = pgTable13("tasks", {
+  id: uuid13("id").primaryKey().defaultRandom(),
+  name: text12("name").notNull(),
+  description: text12("description").notNull(),
+  roomId: uuid13("room_id"),
+  worldId: uuid13("world_id"),
+  agentId: uuid13("agent_id").notNull(),
+  tags: text12("tags").array(),
+  metadata: jsonb11("metadata"),
+  createdAt: timestamp("created_at").defaultNow(),
+  updatedAt: timestamp("updated_at").defaultNow()
+});
+
+// src/base.ts
+var BaseDrizzleAdapter = class extends DatabaseAdapter {
+  maxRetries = 3;
+  baseDelay = 1e3;
+  maxDelay = 1e4;
+  jitterMax = 1e3;
+  embeddingDimension = DIMENSION_MAP[384];
+  agentId;
+  constructor(agentId) {
+    super();
+    this.agentId = agentId;
+  }
+  async withRetry(operation) {
+    let lastError = new Error("Unknown error");
+    for (let attempt = 1; attempt <= this.maxRetries; attempt++) {
+      try {
+        return await operation();
+      } catch (error) {
+        lastError = error;
+        if (attempt < this.maxRetries) {
+          const backoffDelay = Math.min(
+            this.baseDelay * 2 ** (attempt - 1),
+            this.maxDelay
+          );
+          const jitter = Math.random() * this.jitterMax;
+          const delay = backoffDelay + jitter;
+          logger.warn(
+            `Database operation failed (attempt ${attempt}/${this.maxRetries}):`,
+            {
+              error: error instanceof Error ? error.message : String(error),
+              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:", {
+            error: error instanceof Error ? error.message : String(error),
+            totalAttempts: attempt
+          });
+          throw error instanceof Error ? error : new Error(String(error));
+        }
+      }
+    }
+    throw lastError;
+  }
+  async ensureAgentExists(agent) {
+    if (!agent.name) {
+      throw new Error("Agent name is required");
+    }
+    const agents = await this.getAgents();
+    const existingAgent = agents.find(
+      (a) => a.name === agent.name
+    );
+    if (!existingAgent) {
+      await this.createAgent(agent);
+    }
+  }
+  async ensureEmbeddingDimension(dimension) {
+    const existingMemory = await this.db.select({
+      embedding: embeddingTable
+    }).from(memoryTable).innerJoin(embeddingTable, eq(embeddingTable.memoryId, memoryTable.id)).where(eq(memoryTable.agentId, this.agentId)).limit(1);
+    if (existingMemory.length > 0) {
+      const usedDimension = Object.entries(DIMENSION_MAP).find(
+        ([_, colName]) => existingMemory[0].embedding[colName] !== null
+      );
+      if (usedDimension && usedDimension[1] !== DIMENSION_MAP[dimension]) {
+        throw new Error("Cannot change embedding dimension for agent");
+      }
+    }
+    this.embeddingDimension = DIMENSION_MAP[dimension];
+  }
+  async getAgent(agentId) {
+    return this.withDatabase(async () => {
+      const result = await this.db.select().from(agentTable).where(eq(agentTable.id, agentId)).limit(1);
+      if (result.length === 0) return null;
+      return result[0];
+    });
+  }
+  async getAgents() {
+    return this.withDatabase(async () => {
+      const result = await this.db.select().from(agentTable);
+      return result;
+    });
+  }
+  async createAgent(agent) {
+    return this.withDatabase(async () => {
+      try {
+        await this.db.transaction(async (tx) => {
+          await tx.insert(agentTable).values({
+            ...agent
+          });
+        });
+        logger.debug("Agent created successfully:", {
+          agentId: agent.id
+        });
+        return true;
+      } catch (error) {
+        logger.error("Error creating agent:", {
+          error: error instanceof Error ? error.message : String(error),
+          agentId: agent.id,
+          agent
+        });
+        return false;
+      }
+    });
+  }
+  async updateAgent(agentId, agent) {
+    return this.withDatabase(async () => {
+      try {
+        if (!agent.id) {
+          throw new Error("Agent ID is required for update");
+        }
+        await this.db.transaction(async (tx) => {
+          await tx.update(agentTable).set({
+            ...agent,
+            updatedAt: Date.now()
+          }).where(eq(agentTable.id, agentId));
+        });
+        logger.debug("Agent updated successfully:", {
+          agentId
+        });
+        return true;
+      } catch (error) {
+        logger.error("Error updating agent:", {
+          error: error instanceof Error ? error.message : String(error),
+          agentId,
+          agent
+        });
+        return false;
+      }
+    });
+  }
+  async deleteAgent(agentId) {
+    return this.withDatabase(async () => {
+      await this.db.transaction(async (tx) => {
+        await tx.delete(agentTable).where(eq(agentTable.id, agentId));
+      });
+      return true;
+    });
+  }
+  /**
+   * Count all agents in the database
+   * Used primarily for maintenance and cleanup operations
+   */
+  async countAgents() {
+    return this.withDatabase(async () => {
+      try {
+        const result = await this.db.select({ count: count() }).from(agentTable);
+        return result[0]?.count || 0;
+      } catch (error) {
+        logger.error("Error counting agents:", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+        return 0;
+      }
+    });
+  }
+  /**
+   * Clean up the agents table by removing all agents
+   * This is used during server startup to ensure no orphaned agents exist
+   * from previous crashes or improper shutdowns
+   */
+  async cleanupAgents() {
+    return this.withDatabase(async () => {
+      try {
+        await this.db.delete(agentTable);
+        logger.success("Successfully cleaned up agent table");
+      } catch (error) {
+        logger.error("Error cleaning up agent table:", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+        throw error;
+      }
+    });
+  }
+  async getEntityById(entityId) {
+    return this.withDatabase(async () => {
+      const result = await this.db.select({
+        entity: entityTable,
+        components: componentTable
+      }).from(entityTable).leftJoin(componentTable, eq(componentTable.entityId, entityTable.id)).where(
+        and(
+          eq(entityTable.id, entityId),
+          eq(entityTable.agentId, this.agentId)
+        )
+      );
+      if (result.length === 0) return null;
+      const entity = result[0].entity;
+      entity.components = result.filter((row) => row.components).map((row) => row.components);
+      return entity;
+    });
+  }
+  async getEntitiesForRoom(roomId, includeComponents) {
+    return this.withDatabase(async () => {
+      const query = this.db.select({
+        entity: entityTable,
+        ...includeComponents && { components: componentTable }
+      }).from(participantTable).leftJoin(
+        entityTable,
+        and(
+          eq(participantTable.entityId, entityTable.id),
+          eq(entityTable.agentId, this.agentId)
+        )
+      );
+      if (includeComponents) {
+        query.leftJoin(
+          componentTable,
+          eq(componentTable.entityId, entityTable.id)
+        );
+      }
+      const result = await query.where(eq(participantTable.roomId, roomId));
+      const entitiesByIdMap = /* @__PURE__ */ new Map();
+      for (const row of result) {
+        if (!row.entity) continue;
+        const entityId = row.entity.id;
+        if (!entitiesByIdMap.has(entityId)) {
+          const entity = {
+            ...row.entity,
+            components: includeComponents ? [] : void 0
+          };
+          entitiesByIdMap.set(entityId, entity);
+        }
+        if (includeComponents && row.components) {
+          const entity = entitiesByIdMap.get(entityId);
+          if (entity) {
+            if (!entity.components) {
+              entity.components = [];
+            }
+            entity.components.push(row.components);
+          }
+        }
+      }
+      return Array.from(entitiesByIdMap.values());
+    });
+  }
+  async createEntity(entity) {
+    return this.withDatabase(async () => {
+      try {
+        return await this.db.transaction(async (tx) => {
+          await tx.insert(entityTable).values(entity);
+          logger.debug("Entity created successfully:", {
+            entity
+          });
+          return true;
+        });
+      } catch (error) {
+        logger.error("Error creating account:", {
+          error: error instanceof Error ? error.message : String(error),
+          entityId: entity.id,
+          name: entity.metadata?.name
+        });
+        return false;
+      }
+    });
+  }
+  /**
+   * Ensures an entity exists, creating it if it doesn't
+   * @param entity The entity to ensure exists
+   * @returns Promise resolving to boolean indicating success
+   */
+  async ensureEntityExists(entity) {
+    if (!entity.id) {
+      logger.error("Entity ID is required for ensureEntityExists");
+      return false;
+    }
+    try {
+      const existingEntity = await this.getEntityById(entity.id);
+      if (!existingEntity) {
+        return await this.createEntity(entity);
+      }
+      return true;
+    } catch (error) {
+      logger.error("Error ensuring entity exists:", {
+        error: error instanceof Error ? error.message : String(error),
+        entityId: entity.id
+      });
+      return false;
+    }
+  }
+  async updateEntity(entity) {
+    return this.withDatabase(async () => {
+      await this.db.update(entityTable).set(entity).where(
+        and(
+          eq(entityTable.id, entity.id),
+          eq(entityTable.agentId, entity.agentId)
+        )
+      );
+    });
+  }
+  async getComponent(entityId, type, worldId, sourceEntityId) {
+    return this.withDatabase(async () => {
+      const conditions = [
+        eq(componentTable.entityId, entityId),
+        eq(componentTable.type, type)
+      ];
+      if (worldId) {
+        conditions.push(eq(componentTable.worldId, worldId));
+      }
+      if (sourceEntityId) {
+        conditions.push(eq(componentTable.sourceEntityId, sourceEntityId));
+      }
+      const result = await this.db.select().from(componentTable).where(and(...conditions));
+      return result.length > 0 ? result[0] : null;
+    });
+  }
+  async getComponents(entityId, worldId, sourceEntityId) {
+    return this.withDatabase(async () => {
+      const conditions = [eq(componentTable.entityId, entityId)];
+      if (worldId) {
+        conditions.push(eq(componentTable.worldId, worldId));
+      }
+      if (sourceEntityId) {
+        conditions.push(eq(componentTable.sourceEntityId, sourceEntityId));
+      }
+      const result = await this.db.select({
+        id: componentTable.id,
+        entityId: componentTable.entityId,
+        type: componentTable.type,
+        data: componentTable.data,
+        worldId: componentTable.worldId,
+        sourceEntityId: componentTable.sourceEntityId,
+        createdAt: componentTable.createdAt
+      }).from(componentTable).where(and(...conditions));
+      return result;
+    });
+  }
+  async createComponent(component) {
+    return this.withDatabase(async () => {
+      await this.db.insert(componentTable).values(component);
+      return true;
+    });
+  }
+  async updateComponent(component) {
+    return this.withDatabase(async () => {
+      await this.db.update(componentTable).set(component).where(eq(componentTable.id, component.id));
+    });
+  }
+  async deleteComponent(componentId) {
+    return this.withDatabase(async () => {
+      await this.db.delete(componentTable).where(eq(componentTable.id, componentId));
+    });
+  }
+  async getMemories(params) {
+    if (!params.tableName) throw new Error("tableName is required");
+    if (!params.roomId) throw new Error("roomId is required");
+    return this.withDatabase(async () => {
+      const conditions = [
+        eq(memoryTable.type, params.tableName),
+        eq(memoryTable.roomId, params.roomId)
+      ];
+      if (params.start) {
+        conditions.push(gte(memoryTable.createdAt, params.start));
+      }
+      if (params.end) {
+        conditions.push(lte(memoryTable.createdAt, params.end));
+      }
+      if (params.unique) {
+        conditions.push(eq(memoryTable.unique, true));
+      }
+      conditions.push(eq(memoryTable.agentId, this.agentId));
+      const query = this.db.select({
+        memory: {
+          id: memoryTable.id,
+          type: memoryTable.type,
+          createdAt: memoryTable.createdAt,
+          content: memoryTable.content,
+          entityId: memoryTable.entityId,
+          agentId: memoryTable.agentId,
+          roomId: memoryTable.roomId,
+          unique: memoryTable.unique
+        },
+        embedding: embeddingTable[this.embeddingDimension]
+      }).from(memoryTable).leftJoin(embeddingTable, eq(embeddingTable.memoryId, memoryTable.id)).where(and(...conditions)).orderBy(desc(memoryTable.createdAt));
+      const rows = params.count ? await query.limit(params.count) : await query;
+      return rows.map((row) => ({
+        id: row.memory.id,
+        type: row.memory.type,
+        createdAt: row.memory.createdAt,
+        content: typeof row.memory.content === "string" ? JSON.parse(row.memory.content) : row.memory.content,
+        entityId: row.memory.entityId,
+        agentId: row.memory.agentId,
+        roomId: row.memory.roomId,
+        unique: row.memory.unique,
+        embedding: row.embedding ? Array.from(row.embedding) : void 0
+      }));
+    });
+  }
+  async getMemoriesByRoomIds(params) {
+    return this.withDatabase(async () => {
+      if (params.roomIds.length === 0) return [];
+      const conditions = [
+        eq(memoryTable.type, params.tableName),
+        inArray(memoryTable.roomId, params.roomIds)
+      ];
+      conditions.push(eq(memoryTable.agentId, this.agentId));
+      const query = this.db.select({
+        id: memoryTable.id,
+        type: memoryTable.type,
+        createdAt: memoryTable.createdAt,
+        content: memoryTable.content,
+        entityId: memoryTable.entityId,
+        agentId: memoryTable.agentId,
+        roomId: memoryTable.roomId,
+        unique: memoryTable.unique
+      }).from(memoryTable).where(and(...conditions)).orderBy(desc(memoryTable.createdAt));
+      const rows = params.limit ? await query.limit(params.limit) : await query;
+      return rows.map((row) => ({
+        id: row.id,
+        createdAt: row.createdAt,
+        content: typeof row.content === "string" ? JSON.parse(row.content) : row.content,
+        entityId: row.entityId,
+        agentId: row.agentId,
+        roomId: row.roomId,
+        unique: row.unique
+      }));
+    });
+  }
+  async getMemoryById(id) {
+    return this.withDatabase(async () => {
+      const result = await this.db.select({
+        memory: memoryTable,
+        embedding: embeddingTable[this.embeddingDimension]
+      }).from(memoryTable).leftJoin(embeddingTable, eq(memoryTable.id, embeddingTable.memoryId)).where(eq(memoryTable.id, id)).limit(1);
+      if (result.length === 0) return null;
+      const row = result[0];
+      return {
+        id: row.memory.id,
+        createdAt: row.memory.createdAt,
+        content: typeof row.memory.content === "string" ? JSON.parse(row.memory.content) : row.memory.content,
+        entityId: row.memory.entityId,
+        agentId: row.memory.agentId,
+        roomId: row.memory.roomId,
+        unique: row.memory.unique,
+        embedding: row.embedding ?? void 0
+      };
+    });
+  }
+  async getMemoriesByIds(memoryIds, tableName) {
+    return this.withDatabase(async () => {
+      if (memoryIds.length === 0) return [];
+      const conditions = [inArray(memoryTable.id, memoryIds)];
+      if (tableName) {
+        conditions.push(eq(memoryTable.type, tableName));
+      }
+      const rows = await this.db.select({
+        memory: memoryTable,
+        embedding: embeddingTable[this.embeddingDimension]
+      }).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,
+        content: typeof row.memory.content === "string" ? JSON.parse(row.memory.content) : row.memory.content,
+        entityId: row.memory.entityId,
+        agentId: row.memory.agentId,
+        roomId: row.memory.roomId,
+        unique: row.memory.unique,
+        embedding: row.embedding ?? void 0
+      }));
+    });
+  }
+  async getCachedEmbeddings(opts) {
+    return this.withDatabase(async () => {
+      try {
+        const results = await this.db.execute(sql13`
+                    WITH content_text AS (
+                        SELECT
+                            m.id,
+                            COALESCE(
+                                m.content->>${opts.query_field_sub_name},
+                                ''
+                            ) as content_text
+                        FROM memories m
+                        WHERE m.type = ${opts.query_table_name}
+                            AND m.content->>${opts.query_field_sub_name} IS NOT NULL
+                    ),
+                    embedded_text AS (
+                        SELECT 
+                            ct.content_text,
+                            COALESCE(
+                                e.dim_384,
+                                e.dim_512,
+                                e.dim_768,
+                                e.dim_1024,
+                                e.dim_1536,
+                                e.dim_3072
+                            ) as embedding
+                        FROM content_text ct
+                        LEFT JOIN embeddings e ON e.memory_id = ct.id
+                        WHERE e.memory_id IS NOT NULL
+                    )
+                    SELECT
+                        embedding,
+                        levenshtein(${opts.query_input}, content_text) as levenshtein_score
+                    FROM embedded_text
+                    WHERE levenshtein(${opts.query_input}, content_text) <= ${opts.query_threshold}
+                    ORDER BY levenshtein_score
+                    LIMIT ${opts.query_match_count}
+                `);
+        return results.rows.map((row) => ({
+          embedding: Array.isArray(row.embedding) ? row.embedding : typeof row.embedding === "string" ? JSON.parse(row.embedding) : [],
+          levenshtein_score: Number(row.levenshtein_score)
+        })).filter((row) => Array.isArray(row.embedding));
+      } catch (error) {
+        logger.error("Error in getCachedEmbeddings:", {
+          error: error instanceof Error ? error.message : String(error),
+          tableName: opts.query_table_name,
+          fieldName: opts.query_field_name
+        });
+        if (error instanceof Error && error.message === "levenshtein argument exceeds maximum length of 255 characters") {
+          return [];
+        }
+        throw error;
+      }
+    });
+  }
+  async log(params) {
+    return this.withDatabase(async () => {
+      try {
+        await this.db.transaction(async (tx) => {
+          await tx.insert(logTable).values({
+            body: sql13`${params.body}::jsonb`,
+            entityId: params.entityId,
+            roomId: params.roomId,
+            type: params.type
+          });
+        });
+      } catch (error) {
+        logger.error("Failed to create log entry:", {
+          error: error instanceof Error ? error.message : String(error),
+          type: params.type,
+          roomId: params.roomId,
+          entityId: params.entityId
+        });
+        throw error;
+      }
+    });
+  }
+  async searchMemories(params) {
+    return await this.searchMemoriesByEmbedding(params.embedding, {
+      match_threshold: params.match_threshold,
+      count: params.count,
+      roomId: params.roomId,
+      unique: params.unique,
+      tableName: params.tableName
+    });
+  }
+  async updateGoalStatus(params) {
+    return this.withDatabase(async () => {
+      try {
+        await this.db.transaction(async (tx) => {
+          await tx.update(goalTable).set({
+            status: params.status
+          }).where(eq(goalTable.id, params.goalId));
+        });
+      } catch (error) {
+        logger.error("Failed to update goal status:", {
+          goalId: params.goalId,
+          status: params.status,
+          error: error instanceof Error ? error.message : String(error)
+        });
+        throw error;
+      }
+    });
+  }
+  async searchMemoriesByEmbedding(embedding, params) {
+    return this.withDatabase(async () => {
+      const cleanVector = embedding.map(
+        (n) => Number.isFinite(n) ? Number(n.toFixed(6)) : 0
+      );
+      const similarity = sql13`1 - (${cosineDistance(
+        embeddingTable[this.embeddingDimension],
+        cleanVector
+      )})`;
+      const conditions = [eq(memoryTable.type, params.tableName)];
+      if (params.unique) {
+        conditions.push(eq(memoryTable.unique, true));
+      }
+      conditions.push(eq(memoryTable.agentId, this.agentId));
+      if (params.roomId) {
+        conditions.push(eq(memoryTable.roomId, params.roomId));
+      }
+      if (params.match_threshold) {
+        conditions.push(gte(similarity, params.match_threshold));
+      }
+      const results = await this.db.select({
+        memory: memoryTable,
+        similarity,
+        embedding: embeddingTable[this.embeddingDimension]
+      }).from(embeddingTable).innerJoin(memoryTable, eq(memoryTable.id, embeddingTable.memoryId)).where(and(...conditions)).orderBy(desc(similarity)).limit(params.count ?? 10);
+      return results.map((row) => ({
+        id: row.memory.id,
+        type: row.memory.type,
+        createdAt: row.memory.createdAt,
+        content: typeof row.memory.content === "string" ? JSON.parse(row.memory.content) : row.memory.content,
+        entityId: row.memory.entityId,
+        agentId: row.memory.agentId,
+        roomId: row.memory.roomId,
+        unique: row.memory.unique,
+        embedding: row.embedding ?? void 0,
+        similarity: row.similarity
+      }));
+    });
+  }
+  async createMemory(memory, tableName) {
+    logger.debug("DrizzleAdapter createMemory:", {
+      memoryId: memory.id,
+      embeddingLength: memory.embedding?.length,
+      contentLength: memory.content?.text?.length
+    });
+    let isUnique = true;
+    if (memory.embedding && Array.isArray(memory.embedding)) {
+      const similarMemories = await this.searchMemoriesByEmbedding(
+        memory.embedding,
+        {
+          tableName,
+          roomId: memory.roomId,
+          match_threshold: 0.95,
+          count: 1
+        }
+      );
+      isUnique = similarMemories.length === 0;
+    }
+    const contentToInsert = typeof memory.content === "string" ? JSON.parse(memory.content) : memory.content;
+    const memoryId = memory.id ?? v4();
+    await this.db.transaction(async (tx) => {
+      await tx.insert(memoryTable).values([
+        {
+          id: memoryId,
+          type: tableName,
+          content: sql13`${contentToInsert}::jsonb`,
+          metadata: sql13`${memory.metadata || {}}::jsonb`,
+          entityId: memory.entityId,
+          roomId: memory.roomId,
+          agentId: memory.agentId,
+          unique: memory.unique ?? isUnique,
+          createdAt: memory.createdAt
+        }
+      ]);
+      if (memory.embedding && Array.isArray(memory.embedding)) {
+        const embeddingValues = {
+          id: v4(),
+          memoryId,
+          createdAt: memory.createdAt
+        };
+        const cleanVector = memory.embedding.map(
+          (n) => Number.isFinite(n) ? Number(n.toFixed(6)) : 0
+        );
+        embeddingValues[this.embeddingDimension] = cleanVector;
+        await tx.insert(embeddingTable).values([embeddingValues]);
+      }
+    });
+    return memoryId;
+  }
+  async removeMemory(memoryId, tableName) {
+    return this.withDatabase(async () => {
+      await this.db.transaction(async (tx) => {
+        await tx.delete(embeddingTable).where(eq(embeddingTable.memoryId, memoryId));
+        await tx.delete(memoryTable).where(
+          and(eq(memoryTable.id, memoryId), eq(memoryTable.type, tableName))
+        );
+      });
+      logger.debug("Memory removed successfully:", {
+        memoryId,
+        tableName
+      });
+    });
+  }
+  async removeAllMemories(roomId, tableName) {
+    return this.withDatabase(async () => {
+      await this.db.transaction(async (tx) => {
+        const memoryIds = await tx.select({ id: memoryTable.id }).from(memoryTable).where(
+          and(
+            eq(memoryTable.roomId, roomId),
+            eq(memoryTable.type, tableName)
+          )
+        );
+        if (memoryIds.length > 0) {
+          await tx.delete(embeddingTable).where(
+            inArray(
+              embeddingTable.memoryId,
+              memoryIds.map((m) => m.id)
+            )
+          );
+          await tx.delete(memoryTable).where(
+            and(
+              eq(memoryTable.roomId, roomId),
+              eq(memoryTable.type, tableName)
+            )
+          );
+        }
+      });
+      logger.debug("All memories removed successfully:", {
+        roomId,
+        tableName
+      });
+    });
+  }
+  async countMemories(roomId, unique7 = 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) {
+        conditions.push(eq(memoryTable.unique, true));
+      }
+      const result = await this.db.select({ count: sql13`count(*)` }).from(memoryTable).where(and(...conditions));
+      return Number(result[0]?.count ?? 0);
+    });
+  }
+  async getGoals(params) {
+    return this.withDatabase(async () => {
+      const conditions = [eq(goalTable.roomId, params.roomId)];
+      if (params.entityId) {
+        conditions.push(eq(goalTable.entityId, params.entityId));
+      }
+      if (params.onlyInProgress) {
+        conditions.push(eq(goalTable.status, "IN_PROGRESS"));
+      }
+      const query = this.db.select().from(goalTable).where(and(...conditions)).orderBy(desc(goalTable.createdAt));
+      const result = await (params.count ? query.limit(params.count) : query);
+      return result.map((row) => ({
+        id: row.id,
+        roomId: row.roomId,
+        entityId: row.entityId,
+        name: row.name ?? "",
+        status: row.status ?? "NOT_STARTED",
+        description: row.description ?? "",
+        objectives: row.objectives,
+        createdAt: row.createdAt
+      }));
+    });
+  }
+  async updateGoal(goal) {
+    return this.withDatabase(async () => {
+      try {
+        await this.db.transaction(async (tx) => {
+          await tx.update(goalTable).set({
+            name: goal.name,
+            status: goal.status,
+            objectives: goal.objectives
+          }).where(eq(goalTable.id, goal.id));
+        });
+      } catch (error) {
+        logger.error("Failed to update goal:", {
+          error: error instanceof Error ? error.message : String(error),
+          goalId: goal.id,
+          status: goal.status
+        });
+        throw error;
+      }
+    });
+  }
+  async createGoal(goal) {
+    return this.withDatabase(async () => {
+      try {
+        await this.db.transaction(async (tx) => {
+          await tx.insert(goalTable).values({
+            id: goal.id ?? v4(),
+            roomId: goal.roomId,
+            entityId: goal.entityId,
+            name: goal.name,
+            status: goal.status,
+            objectives: sql13`${goal.objectives}::jsonb`
+          });
+        });
+      } catch (error) {
+        logger.error("Failed to update goal:", {
+          goalId: goal.id,
+          error: error instanceof Error ? error.message : String(error),
+          status: goal.status
+        });
+        throw error;
+      }
+    });
+  }
+  async removeGoal(goalId) {
+    if (!goalId) throw new Error("Goal ID is required");
+    return this.withDatabase(async () => {
+      try {
+        await this.db.transaction(async (tx) => {
+          await tx.delete(goalTable).where(eq(goalTable.id, goalId));
+        });
+        logger.debug("Goal removal attempt:", {
+          goalId,
+          removed: true
+        });
+      } catch (error) {
+        logger.error("Failed to remove goal:", {
+          error: error instanceof Error ? error.message : String(error),
+          goalId
+        });
+        throw error;
+      }
+    });
+  }
+  async removeAllGoals(roomId) {
+    return this.withDatabase(async () => {
+      await this.db.transaction(async (tx) => {
+        await tx.delete(goalTable).where(eq(goalTable.roomId, roomId));
+      });
+    });
+  }
+  async getRoom(roomId) {
+    return this.withDatabase(async () => {
+      const result = await this.db.select({
+        id: roomTable.id,
+        channelId: roomTable.channelId,
+        agentId: roomTable.agentId,
+        serverId: roomTable.serverId,
+        worldId: roomTable.worldId,
+        type: roomTable.type,
+        source: roomTable.source
+      }).from(roomTable).where(
+        and(eq(roomTable.id, roomId), eq(roomTable.agentId, this.agentId))
+      ).limit(1);
+      if (result.length === 0) return null;
+      return result[0];
+    });
+  }
+  async getRooms(worldId) {
+    return this.withDatabase(async () => {
+      const result = await this.db.select().from(roomTable).where(eq(roomTable.worldId, worldId));
+      return result;
+    });
+  }
+  async updateRoom(room) {
+    return this.withDatabase(async () => {
+      await this.db.update(roomTable).set({ ...room, agentId: this.agentId }).where(eq(roomTable.id, room.id));
+    });
+  }
+  async createRoom({
+    id,
+    name,
+    source,
+    type,
+    channelId,
+    serverId,
+    worldId
+  }) {
+    return this.withDatabase(async () => {
+      const newRoomId = id || v4();
+      await this.db.insert(roomTable).values({
+        id: newRoomId,
+        name,
+        agentId: this.agentId,
+        source,
+        type,
+        channelId,
+        serverId,
+        worldId
+      }).onConflictDoNothing({ target: roomTable.id });
+      return newRoomId;
+    });
+  }
+  async deleteRoom(roomId) {
+    if (!roomId) throw new Error("Room ID is required");
+    return this.withDatabase(async () => {
+      await this.db.transaction(async (tx) => {
+        await tx.delete(roomTable).where(eq(roomTable.id, roomId));
+      });
+    });
+  }
+  async getRoomsForParticipant(entityId) {
+    return this.withDatabase(async () => {
+      const result = await this.db.select({ roomId: participantTable.roomId }).from(participantTable).innerJoin(roomTable, eq(participantTable.roomId, roomTable.id)).where(
+        and(
+          eq(participantTable.entityId, entityId),
+          eq(roomTable.agentId, this.agentId)
+        )
+      );
+      return result.map((row) => row.roomId);
+    });
+  }
+  async getRoomsForParticipants(entityIds) {
+    return this.withDatabase(async () => {
+      const result = await this.db.selectDistinct({ roomId: participantTable.roomId }).from(participantTable).innerJoin(roomTable, eq(participantTable.roomId, roomTable.id)).where(
+        and(
+          inArray(participantTable.entityId, entityIds),
+          eq(roomTable.agentId, this.agentId)
+        )
+      );
+      return result.map((row) => row.roomId);
+    });
+  }
+  async addParticipant(entityId, roomId) {
+    return this.withDatabase(async () => {
+      try {
+        await this.db.insert(participantTable).values({
+          entityId,
+          roomId,
+          agentId: this.agentId
+        }).onConflictDoNothing();
+        return true;
+      } catch (error) {
+        logger.error("Error adding participant", {
+          error: error instanceof Error ? error.message : String(error),
+          entityId,
+          roomId,
+          agentId: this.agentId
+        });
+        return false;
+      }
+    });
+  }
+  async removeParticipant(entityId, roomId) {
+    return this.withDatabase(async () => {
+      try {
+        const result = await this.db.transaction(async (tx) => {
+          return await tx.delete(participantTable).where(
+            and(
+              eq(participantTable.entityId, entityId),
+              eq(participantTable.roomId, roomId)
+            )
+          ).returning();
+        });
+        const removed = result.length > 0;
+        logger.debug(`Participant ${removed ? "removed" : "not found"}:`, {
+          entityId,
+          roomId,
+          removed
+        });
+        return removed;
+      } catch (error) {
+        logger.error("Failed to remove participant:", {
+          error: error instanceof Error ? error.message : String(error),
+          entityId,
+          roomId
+        });
+        return false;
+      }
+    });
+  }
+  async getParticipantsForEntity(entityId) {
+    return this.withDatabase(async () => {
+      const result = await this.db.select({
+        id: participantTable.id,
+        entityId: participantTable.entityId,
+        roomId: participantTable.roomId
+      }).from(participantTable).where(eq(participantTable.entityId, entityId));
+      const entity = await this.getEntityById(entityId);
+      if (!entity) {
+        return [];
+      }
+      return result.map((row) => ({
+        id: row.id,
+        entity
+      }));
+    });
+  }
+  async getParticipantsForRoom(roomId) {
+    return this.withDatabase(async () => {
+      const result = await this.db.select({ entityId: participantTable.entityId }).from(participantTable).where(
+        and(
+          eq(participantTable.roomId, roomId),
+          eq(participantTable.agentId, this.agentId)
+        )
+      );
+      return result.map((row) => row.entityId);
+    });
+  }
+  async getParticipantUserState(roomId, entityId) {
+    return this.withDatabase(async () => {
+      const result = await this.db.select({ roomState: participantTable.roomState }).from(participantTable).where(
+        and(
+          eq(participantTable.roomId, roomId),
+          eq(participantTable.entityId, entityId),
+          eq(participantTable.agentId, this.agentId)
+        )
+      ).limit(1);
+      return result[0]?.roomState ?? null;
+    });
+  }
+  async setParticipantUserState(roomId, entityId, state) {
+    return this.withDatabase(async () => {
+      try {
+        await this.db.transaction(async (tx) => {
+          await tx.update(participantTable).set({ roomState: state }).where(
+            and(
+              eq(participantTable.roomId, roomId),
+              eq(participantTable.entityId, entityId),
+              eq(participantTable.agentId, this.agentId)
+            )
+          );
+        });
+      } catch (error) {
+        logger.error("Failed to set participant user state:", {
+          roomId,
+          entityId,
+          state,
+          error: error instanceof Error ? error.message : String(error)
+        });
+        throw error;
+      }
+    });
+  }
+  async createRelationship(params) {
+    return this.withDatabase(async () => {
+      const id = v4();
+      const saveParams = {
+        id,
+        sourceEntityId: params.sourceEntityId,
+        targetEntityId: params.targetEntityId,
+        agentId: this.agentId,
+        tags: params.tags || [],
+        metadata: params.metadata || {}
+      };
+      try {
+        await this.db.insert(relationshipTable).values(saveParams);
+        return true;
+      } catch (error) {
+        logger.error("Error creating relationship:", {
+          error: error instanceof Error ? error.message : String(error),
+          saveParams
+        });
+        return false;
+      }
+    });
+  }
+  async updateRelationship(relationship) {
+    return this.withDatabase(async () => {
+      try {
+        await this.db.update(relationshipTable).set({
+          tags: relationship.tags || [],
+          metadata: relationship.metadata || {}
+        }).where(eq(relationshipTable.id, relationship.id));
+      } catch (error) {
+        logger.error("Error updating relationship:", {
+          error: error instanceof Error ? error.message : String(error),
+          relationship
+        });
+        throw error;
+      }
+    });
+  }
+  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;
+      }
+    });
+  }
+  async getRelationships(params) {
+    return this.withDatabase(async () => {
+      try {
+        let query = this.db.select().from(relationshipTable).where(
+          and(
+            or(
+              eq(relationshipTable.sourceEntityId, params.entityId),
+              eq(relationshipTable.targetEntityId, params.entityId)
+            ),
+            eq(relationshipTable.agentId, this.agentId)
+          )
+        );
+        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[]`
+          );
+        }
+        const results = await query;
+        return results.map((result) => ({
+          id: result.id,
+          sourceEntityId: result.sourceEntityId,
+          targetEntityId: result.targetEntityId,
+          agentId: result.agentId,
+          tags: result.tags || [],
+          metadata: result.metadata || {},
+          createdAt: result.createdAt?.toString()
+        }));
+      } catch (error) {
+        logger.error("Error getting relationships:", {
+          error: error instanceof Error ? error.message : String(error),
+          params
+        });
+        return [];
+      }
+    });
+  }
+  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;
+      } catch (error) {
+        logger.error("Error fetching cache", {
+          error: error instanceof Error ? error.message : String(error),
+          key,
+          agentId: this.agentId
+        });
+        return void 0;
+      }
+    });
+  }
+  async setCache(key, value) {
+    return this.withDatabase(async () => {
+      try {
+        await this.db.transaction(async (tx) => {
+          await tx.insert(cacheTable).values({
+            key,
+            agentId: this.agentId,
+            value
+          }).onConflictDoUpdate({
+            target: [cacheTable.key, cacheTable.agentId],
+            set: {
+              value
+            }
+          });
+        });
+        return true;
+      } catch (error) {
+        logger.error("Error setting cache", {
+          error: error instanceof Error ? error.message : String(error),
+          key,
+          agentId: this.agentId
+        });
+        return false;
+      }
+    });
+  }
+  async deleteCache(key) {
+    return this.withDatabase(async () => {
+      try {
+        await this.db.transaction(async (tx) => {
+          await tx.delete(cacheTable).where(
+            and(
+              eq(cacheTable.agentId, this.agentId),
+              eq(cacheTable.key, key)
+            )
+          );
+        });
+        return true;
+      } catch (error) {
+        logger.error("Error deleting cache", {
+          error: error instanceof Error ? error.message : String(error),
+          key,
+          agentId: this.agentId
+        });
+        return false;
+      }
+    });
+  }
+  async createWorld(world) {
+    return this.withDatabase(async () => {
+      const newWorldId = world.id || v4();
+      await this.db.insert(worldTable).values({
+        ...world,
+        id: newWorldId
+      });
+      return newWorldId;
+    });
+  }
+  async getWorld(id) {
+    return this.withDatabase(async () => {
+      const result = await this.db.select().from(worldTable).where(eq(worldTable.id, id));
+      return result[0];
+    });
+  }
+  async getAllWorlds() {
+    return this.withDatabase(async () => {
+      const result = await this.db.select().from(worldTable).where(eq(worldTable.agentId, this.agentId));
+      return result;
+    });
+  }
+  async updateWorld(world) {
+    return this.withDatabase(async () => {
+      await this.db.update(worldTable).set(world).where(eq(worldTable.id, world.id));
+    });
+  }
+  async removeWorld(id) {
+    return this.withDatabase(async () => {
+      await this.db.delete(worldTable).where(eq(worldTable.id, id));
+    });
+  }
+  /**
+   * Creates a new task in the database.
+   * @param task The task object to create
+   * @returns Promise resolving to the UUID of the created task
+   */
+  async createTask(task) {
+    return this.withRetry(async () => {
+      return this.withDatabase(async () => {
+        const now = /* @__PURE__ */ new Date();
+        const metadata = task.metadata || {};
+        const values = {
+          id: task.id,
+          name: task.name,
+          description: task.description,
+          roomId: task.roomId,
+          worldId: task.worldId,
+          tags: task.tags,
+          metadata,
+          createdAt: now,
+          updatedAt: now,
+          agentId: this.agentId
+        };
+        const result = await this.db.insert(taskTable).values(values).returning({ id: taskTable.id });
+        return result[0].id;
+      });
+    });
+  }
+  /**
+   * Retrieves tasks based on specified parameters.
+   * @param params Object containing optional roomId and tags to filter tasks
+   * @returns Promise resolving to an array of Task objects
+   */
+  async getTasks(params) {
+    return this.withRetry(async () => {
+      return this.withDatabase(async () => {
+        let query = this.db.select().from(taskTable).where(eq(taskTable.agentId, this.agentId));
+        if (params.roomId) {
+          query = query.where(eq(taskTable.roomId, params.roomId));
+        }
+        if (params.tags && params.tags.length > 0) {
+          const tagParams = params.tags.map((tag) => `'${tag.replace(/'/g, "''")}'`).join(", ");
+          query = query.where(
+            sql13`${taskTable.tags} @> ARRAY[${sql13.raw(tagParams)}]::text[]`
+          );
+        }
+        const result = await query;
+        return result.map((row) => ({
+          id: row.id,
+          name: row.name,
+          description: row.description,
+          roomId: row.roomId,
+          worldId: row.worldId,
+          tags: row.tags,
+          metadata: row.metadata
+        }));
+      });
+    });
+  }
+  /**
+   * Retrieves a specific task by its name.
+   * @param name The name of the task to retrieve
+   * @returns Promise resolving to the Task object if found, null otherwise
+   */
+  async getTasksByName(name) {
+    return this.withRetry(async () => {
+      return this.withDatabase(async () => {
+        const result = await this.db.select().from(taskTable).where(
+          and(eq(taskTable.name, name), eq(taskTable.agentId, this.agentId))
+        );
+        return result.map((row) => ({
+          id: row.id,
+          name: row.name,
+          description: row.description,
+          roomId: row.roomId,
+          worldId: row.worldId,
+          tags: row.tags || [],
+          metadata: row.metadata || {}
+        }));
+      });
+    });
+  }
+  /**
+   * Retrieves a specific task by its ID.
+   * @param id The UUID of the task to retrieve
+   * @returns Promise resolving to the Task object if found, null otherwise
+   */
+  async getTask(id) {
+    return this.withRetry(async () => {
+      return this.withDatabase(async () => {
+        const result = await this.db.select().from(taskTable).where(and(eq(taskTable.id, id), eq(taskTable.agentId, this.agentId))).limit(1);
+        if (result.length === 0) {
+          return null;
+        }
+        const row = result[0];
+        return {
+          id: row.id,
+          name: row.name,
+          description: row.description,
+          roomId: row.roomId,
+          worldId: row.worldId,
+          tags: row.tags || [],
+          metadata: row.metadata || {}
+        };
+      });
+    });
+  }
+  /**
+   * Updates an existing task in the database.
+   * @param id The UUID of the task to update
+   * @param task Partial Task object containing the fields to update
+   * @returns Promise resolving when the update is complete
+   */
+  async updateTask(id, task) {
+    await this.withRetry(async () => {
+      await this.withDatabase(async () => {
+        const updateValues = {};
+        if (task.name !== void 0) updateValues.name = task.name;
+        if (task.description !== void 0)
+          updateValues.description = task.description;
+        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
+            };
+          }
+        }
+        await this.db.update(taskTable).set(updateValues).where(
+          and(eq(taskTable.id, id), eq(taskTable.agentId, this.agentId))
+        );
+      });
+    });
+  }
+  /**
+   * Deletes a task from the database.
+   * @param id The UUID of the task to delete
+   * @returns Promise resolving when the deletion is complete
+   */
+  async deleteTask(id) {
+    await this.withRetry(async () => {
+      await this.withDatabase(async () => {
+        await this.db.delete(taskTable).where(
+          and(eq(taskTable.id, id), eq(taskTable.agentId, this.agentId))
+        );
+      });
+    });
+  }
+};
+
+// src/pg-lite/adapter.ts
+var PgliteDatabaseAdapter = class extends BaseDrizzleAdapter {
+  manager;
+  embeddingDimension = DIMENSION_MAP[384];
+  constructor(agentId, manager) {
+    super(agentId);
+    this.manager = manager;
+    this.db = drizzle(this.manager.getConnection());
+  }
+  async withDatabase(operation) {
+    if (this.manager.isShuttingDown()) {
+      logger2.warn("Database is shutting down");
+      return null;
+    }
+    return operation();
+  }
+  async init() {
+    try {
+      await this.manager.runMigrations();
+    } catch (error) {
+      logger2.error("Failed to initialize database:", error);
+      throw error;
+    }
+  }
+  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";
+var PgDatabaseAdapter = class extends BaseDrizzleAdapter {
+  constructor(agentId, manager) {
+    super(agentId);
+    this.manager = manager;
+    this.manager = manager;
+  }
+  embeddingDimension = DIMENSION_MAP[384];
+  async withDatabase(operation) {
+    return await this.withRetry(async () => {
+      const client = await this.manager.getClient();
+      try {
+        const db = drizzle3(client);
+        this.db = db;
+        return await operation();
+      } finally {
+        client.release();
+      }
+    });
+  }
+  async init() {
+    try {
+      await this.manager.runMigrations();
+      logger4.info("PgDatabaseAdapter initialized successfully");
+    } catch (error) {
+      logger4.error("Failed to initialize PgDatabaseAdapter:", error);
+      throw error;
+    }
+  }
+  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;
+function createDatabaseAdapter(config, agentId) {
+  if (config.postgresUrl) {
+    const manager = new PostgresConnectionManager(config.postgresUrl);
+    return new PgDatabaseAdapter(agentId, manager);
+  }
+  const dataDir = config.dataDir ?? "../../pgLite";
+  if (!pgLiteClientManager) {
+    pgLiteClientManager = new PGliteClientManager({ dataDir });
+  }
+  return new PgliteDatabaseAdapter(agentId, pgLiteClientManager);
+}
+var drizzlePlugin = {
+  name: "drizzle",
+  description: "Database adapter plugin using Drizzle ORM",
+  init: async (_, runtime) => {
+    const config = {
+      dataDir: runtime.getSetting("PGLITE_DATA_DIR"),
+      postgresUrl: runtime.getSetting("POSTGRES_URL")
+    };
+    try {
+      const db = createDatabaseAdapter(config, runtime.agentId);
+      logger6.success("Database connection established successfully");
+      runtime.registerDatabaseAdapter(db);
+    } catch (error) {
+      logger6.error("Failed to initialize database:", error);
+      throw error;
+    }
+  }
+};
+var index_default = drizzlePlugin;
+export {
+  createDatabaseAdapter,
+  index_default as default
+};
+//# sourceMappingURL=index.js.map