@elizaos/plugin-sql 1.0.0-beta.7 → 1.0.0-beta.71

package/dist/index.js

@@ -1,11 +1,11 @@
 import {
   PGliteClientManager,
   PostgresConnectionManager,
-  __name
-} from "./chunk-ROCRMD5N.js";
+  __name,
+  resolvePgliteDir
+} from "./chunk-QOV7MUNF.js";
 
 // src/index.ts
-import * as os from "node:os";
 import { logger as logger4 } from "@elizaos/core";
 
 // src/pglite/adapter.ts
@@ -15,37 +15,28 @@ import { drizzle } from "drizzle-orm/pglite";
 // src/base.ts
 import {
   DatabaseAdapter,
-  logger
+  logger,
+  stringToUuid
 } from "@elizaos/core";
-import {
-  and,
-  cosineDistance,
-  count,
-  desc,
-  eq,
-  gte,
-  inArray,
-  lte,
-  or,
-  sql as sql12
-} from "drizzle-orm";
+import { and, cosineDistance, count, desc, eq, gte, inArray, lte, or, sql as sql13 } from "drizzle-orm";
 import { v4 } from "uuid";
 
 // src/schema/embedding.ts
-import { sql as sql6 } from "drizzle-orm";
-import { check as check2, foreignKey as foreignKey2, index as index2, pgTable as pgTable6, uuid as uuid6, vector as vector2 } from "drizzle-orm/pg-core";
+import { sql as sql5 } from "drizzle-orm";
+import { check as check2, foreignKey as foreignKey2, index as index2, pgTable as pgTable5, uuid as uuid5, vector as vector2 } from "drizzle-orm/pg-core";
+import { VECTOR_DIMS } from "@elizaos/core";
 
 // src/schema/memory.ts
-import { relations, sql as sql5 } from "drizzle-orm";
+import { relations, sql as sql4 } from "drizzle-orm";
 import {
   boolean as boolean2,
   check,
   foreignKey,
   index,
-  jsonb as jsonb5,
-  pgTable as pgTable5,
-  text as text5,
-  uuid as uuid5
+  jsonb as jsonb4,
+  pgTable as pgTable4,
+  text as text4,
+  uuid as uuid4
 } from "drizzle-orm/pg-core";
 
 // src/schema/agent.ts
@@ -86,18 +77,18 @@ var agentTable = pgTable(
     createdAt: numberTimestamp("createdAt").default(sql`now()`).notNull(),
     updatedAt: numberTimestamp("updatedAt").default(sql`now()`).notNull(),
     // Character
-    name: text("name"),
+    name: text("name").notNull(),
     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`)
+    system: text("system").default(""),
+    bio: jsonb("bio").$type().default(sql`'[]'::jsonb`),
+    messageExamples: jsonb("message_examples").$type().default(sql`'[]'::jsonb`).notNull(),
+    postExamples: jsonb("post_examples").$type().default(sql`'[]'::jsonb`).notNull(),
+    topics: jsonb("topics").$type().default(sql`'[]'::jsonb`).notNull(),
+    adjectives: jsonb("adjectives").$type().default(sql`'[]'::jsonb`).notNull(),
+    knowledge: jsonb("knowledge").$type().default(sql`'[]'::jsonb`).notNull(),
+    plugins: jsonb("plugins").$type().default(sql`'[]'::jsonb`).notNull(),
+    settings: jsonb("settings").$type().default(sql`'{}'::jsonb`).notNull(),
+    style: jsonb("style").$type().default(sql`'{}'::jsonb`).notNull()
   },
   (table) => {
     return {
@@ -117,8 +108,8 @@ var entityTable = pgTable2(
       onDelete: "cascade"
     }),
     createdAt: numberTimestamp("createdAt").default(sql2`now()`).notNull(),
-    names: text2("names").array().default(sql2`'{}'::text[]`),
-    metadata: jsonb2("metadata").default(sql2`'{}'::jsonb`)
+    names: text2("names").array().default(sql2`'{}'::text[]`).notNull(),
+    metadata: jsonb2("metadata").default(sql2`'{}'::jsonb`).notNull()
   },
   (table) => {
     return {
@@ -128,61 +119,54 @@ var entityTable = pgTable2(
 );
 
 // src/schema/room.ts
-import { sql as sql4 } from "drizzle-orm";
-import { jsonb as jsonb4, pgTable as pgTable4, text as text4, uuid as uuid4 } from "drizzle-orm/pg-core";
-
-// src/schema/worldTable.ts
 import { sql as sql3 } from "drizzle-orm";
 import { jsonb as jsonb3, pgTable as pgTable3, text as text3, uuid as uuid3 } from "drizzle-orm/pg-core";
-var worldTable = pgTable3("worlds", {
+var roomTable = pgTable3("rooms", {
   id: uuid3("id").notNull().primaryKey().default(sql3`gen_random_uuid()`),
-  agentId: uuid3("agentId").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
-  name: text3("name").notNull(),
-  metadata: jsonb3("metadata"),
-  serverId: text3("serverId").notNull(),
-  createdAt: numberTimestamp("createdAt").default(sql3`now()`).notNull()
-});
-
-// src/schema/room.ts
-var roomTable = pgTable4("rooms", {
-  id: uuid4("id").notNull().primaryKey().default(sql4`gen_random_uuid()`),
-  agentId: uuid4("agentId").references(() => agentTable.id, {
-    onDelete: "cascade"
-  }),
-  source: text4("source").notNull(),
-  type: text4("type").notNull(),
-  serverId: text4("serverId"),
-  worldId: uuid4("worldId").references(() => worldTable.id, {
+  agentId: uuid3("agentId").references(() => agentTable.id, {
     onDelete: "cascade"
   }),
-  name: text4("name"),
-  metadata: jsonb4("metadata"),
-  channelId: text4("channelId"),
-  createdAt: numberTimestamp("createdAt").default(sql4`now()`).notNull()
+  source: text3("source").notNull(),
+  type: text3("type").notNull(),
+  serverId: text3("serverId"),
+  worldId: uuid3("worldId"),
+  // no guarantee that world exists, it is optional for now
+  // .references(() => worldTable.id, {
+  //   onDelete: 'cascade',
+  // }),
+  name: text3("name"),
+  metadata: jsonb3("metadata"),
+  channelId: text3("channelId"),
+  createdAt: numberTimestamp("createdAt").default(sql3`now()`).notNull()
 });
 
 // src/schema/memory.ts
-var memoryTable = pgTable5(
+var memoryTable = pgTable4(
   "memories",
   {
-    id: uuid5("id").primaryKey().notNull(),
-    type: text5("type").notNull(),
-    createdAt: numberTimestamp("createdAt").default(sql5`now()`).notNull(),
-    content: jsonb5("content").notNull(),
-    entityId: uuid5("entityId").references(() => entityTable.id, {
+    id: uuid4("id").primaryKey().notNull(),
+    type: text4("type").notNull(),
+    createdAt: numberTimestamp("createdAt").default(sql4`now()`).notNull(),
+    content: jsonb4("content").notNull(),
+    entityId: uuid4("entityId").references(() => entityTable.id, {
       onDelete: "cascade"
     }),
-    agentId: uuid5("agentId").references(() => agentTable.id, {
+    agentId: uuid4("agentId").references(() => agentTable.id, {
       onDelete: "cascade"
-    }),
-    roomId: uuid5("roomId").references(() => roomTable.id, {
+    }).notNull(),
+    roomId: uuid4("roomId").references(() => roomTable.id, {
       onDelete: "cascade"
     }),
+    worldId: uuid4("worldId"),
+    // .references(() => worldTable.id, {
+    //   onDelete: 'set null',
+    // }),
     unique: boolean2("unique").default(true).notNull(),
-    metadata: jsonb5("metadata").default({}).notNull()
+    metadata: jsonb4("metadata").default({}).notNull()
   },
   (table) => [
     index("idx_memories_type_room").on(table.type, table.roomId),
+    index("idx_memories_world_id").on(table.worldId),
     foreignKey({
       name: "fk_room",
       columns: [table.roomId],
@@ -196,17 +180,22 @@ var memoryTable = pgTable5(
     foreignKey({
       name: "fk_agent",
       columns: [table.agentId],
-      foreignColumns: [entityTable.id]
+      foreignColumns: [agentTable.id]
     }).onDelete("cascade"),
-    index("idx_memories_metadata_type").on(sql5`((metadata->>'type'))`),
-    index("idx_memories_document_id").on(sql5`((metadata->>'documentId'))`),
+    // foreignKey({
+    //   name: 'fk_world',
+    //   columns: [table.worldId],
+    //   foreignColumns: [worldTable.id],
+    // }).onDelete('set null'),
+    index("idx_memories_metadata_type").on(sql4`((metadata->>'type'))`),
+    index("idx_memories_document_id").on(sql4`((metadata->>'documentId'))`),
     index("idx_fragments_order").on(
-      sql5`((metadata->>'documentId'))`,
-      sql5`((metadata->>'position'))`
+      sql4`((metadata->>'documentId'))`,
+      sql4`((metadata->>'position'))`
     ),
     check(
       "fragment_metadata_check",
-      sql5`
+      sql4`
             CASE 
                 WHEN metadata->>'type' = 'fragment' THEN
                     metadata ? 'documentId' AND 
@@ -217,7 +206,7 @@ var memoryTable = pgTable5(
     ),
     check(
       "document_metadata_check",
-      sql5`
+      sql4`
             CASE 
                 WHEN metadata->>'type' = 'document' THEN
                     metadata ? 'timestamp'
@@ -232,14 +221,6 @@ var memoryRelations = relations(memoryTable, ({ one }) => ({
 }));
 
 // 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",
@@ -248,12 +229,12 @@ var DIMENSION_MAP = {
   [VECTOR_DIMS.XXL]: "dim1536",
   [VECTOR_DIMS.XXXL]: "dim3072"
 };
-var embeddingTable = pgTable6(
+var embeddingTable = pgTable5(
   "embeddings",
   {
-    id: uuid6("id").primaryKey().defaultRandom().notNull(),
-    memoryId: uuid6("memory_id").references(() => memoryTable.id),
-    createdAt: numberTimestamp("created_at").default(sql6`now()`).notNull(),
+    id: uuid5("id").primaryKey().defaultRandom().notNull(),
+    memoryId: uuid5("memory_id").references(() => memoryTable.id),
+    createdAt: numberTimestamp("created_at").default(sql5`now()`).notNull(),
     dim384: vector2("dim_384", { dimensions: VECTOR_DIMS.SMALL }),
     dim512: vector2("dim_512", { dimensions: VECTOR_DIMS.MEDIUM }),
     dim768: vector2("dim_768", { dimensions: VECTOR_DIMS.LARGE }),
@@ -262,7 +243,7 @@ var embeddingTable = pgTable6(
     dim3072: vector2("dim_3072", { dimensions: VECTOR_DIMS.XXXL })
   },
   (table) => [
-    check2("embedding_source_check", sql6`"memory_id" IS NOT NULL`),
+    check2("embedding_source_check", sql5`"memory_id" IS NOT NULL`),
     index2("idx_embedding_memory").on(table.memoryId),
     foreignKey2({
       name: "fk_embedding_memory",
@@ -273,16 +254,16 @@ var embeddingTable = pgTable6(
 );
 
 // src/schema/cache.ts
-import { sql as sql7 } from "drizzle-orm";
-import { jsonb as jsonb6, pgTable as pgTable7, text as text6, unique as unique4, uuid as uuid7 } from "drizzle-orm/pg-core";
-var cacheTable = pgTable7(
+import { sql as sql6 } from "drizzle-orm";
+import { jsonb as jsonb5, pgTable as pgTable6, text as text5, unique as unique4, uuid as uuid6 } from "drizzle-orm/pg-core";
+var cacheTable = pgTable6(
   "cache",
   {
-    id: uuid7("id").notNull().primaryKey().default(sql7`gen_random_uuid()`),
-    key: text6("key").notNull(),
-    agentId: uuid7("agentId").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
-    value: jsonb6("value").notNull(),
-    createdAt: numberTimestamp("createdAt").default(sql7`now()`).notNull(),
+    id: uuid6("id").notNull().primaryKey().default(sql6`gen_random_uuid()`),
+    key: text5("key").notNull(),
+    agentId: uuid6("agentId").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
+    value: jsonb5("value").notNull(),
+    createdAt: numberTimestamp("createdAt").default(sql6`now()`).notNull(),
     expiresAt: numberTimestamp("expiresAt")
   },
   (table) => [unique4("cache_key_agent_unique").on(table.key, table.agentId)]
@@ -291,6 +272,20 @@ var cacheTable = pgTable7(
 // src/schema/component.ts
 import { sql as sql8 } from "drizzle-orm";
 import { jsonb as jsonb7, pgTable as pgTable8, text as text7, uuid as uuid8 } from "drizzle-orm/pg-core";
+
+// src/schema/world.ts
+import { sql as sql7 } from "drizzle-orm";
+import { jsonb as jsonb6, pgTable as pgTable7, text as text6, uuid as uuid7 } from "drizzle-orm/pg-core";
+var worldTable = pgTable7("worlds", {
+  id: uuid7("id").notNull().primaryKey().default(sql7`gen_random_uuid()`),
+  agentId: uuid7("agentId").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
+  name: text6("name").notNull(),
+  metadata: jsonb6("metadata"),
+  serverId: text6("serverId").notNull(),
+  createdAt: numberTimestamp("createdAt").default(sql7`now()`).notNull()
+});
+
+// src/schema/component.ts
 var componentTable = pgTable8("components", {
   id: uuid8("id").primaryKey().defaultRandom(),
   entityId: uuid8("entityId").notNull().references(() => entityTable.id, { onDelete: "cascade" }),
@@ -318,7 +313,7 @@ var logTable = pgTable9(
     entityId: uuid9("entityId").notNull().references(() => entityTable.id),
     body: jsonb8("body").notNull(),
     type: text8("type").notNull(),
-    roomId: uuid9("roomId").notNull().references(() => roomTable.id)
+    roomId: uuid9("roomId").notNull().references(() => roomTable.id, { onDelete: "cascade" })
   },
   (table) => [
     foreignKey3({
@@ -402,17 +397,19 @@ var relationshipTable = pgTable11(
 
 // src/schema/tasks.ts
 import { jsonb as jsonb10, pgTable as pgTable12, text as text11, timestamp, uuid as uuid12 } from "drizzle-orm/pg-core";
+import { sql as sql12 } from "drizzle-orm";
 var taskTable = pgTable12("tasks", {
   id: uuid12("id").primaryKey().defaultRandom(),
   name: text11("name").notNull(),
-  description: text11("description").notNull(),
-  roomId: uuid12("room_id"),
-  worldId: uuid12("world_id"),
+  description: text11("description"),
+  roomId: uuid12("roomId"),
+  worldId: uuid12("worldId"),
+  entityId: uuid12("entityId"),
   agentId: uuid12("agent_id").notNull(),
-  tags: text11("tags").array(),
-  metadata: jsonb10("metadata"),
-  createdAt: timestamp("created_at").defaultNow(),
-  updatedAt: timestamp("updated_at").defaultNow()
+  tags: text11("tags").array().default(sql12`'{}'::text[]`),
+  metadata: jsonb10("metadata").default(sql12`'{}'::jsonb`),
+  createdAt: timestamp("created_at", { withTimezone: true }).defaultNow(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow()
 });
 
 // src/base.ts
@@ -481,12 +478,17 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       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);
+    const existingAgentId = agents.find((a) => a.name === agent.name)?.id;
+    if (existingAgentId) {
+      const existingAgent = await this.getAgent(existingAgentId);
+      return existingAgent;
     }
+    const newAgent = {
+      ...agent,
+      id: stringToUuid(agent.name)
+    };
+    await this.createAgent(newAgent);
+    return newAgent;
   }
   /**
    * Asynchronously ensures that the given embedding dimension is valid for the agent.
@@ -495,15 +497,17 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
    * @returns {Promise<void>} - Resolves once the embedding dimension is ensured.
    */
   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
-      );
-    }
-    this.embeddingDimension = DIMENSION_MAP[dimension];
+    return this.withDatabase(async () => {
+      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
+        );
+      }
+      this.embeddingDimension = DIMENSION_MAP[dimension];
+    });
   }
   /**
    * Asynchronously retrieves an agent by their ID from the database.
@@ -512,20 +516,35 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
    */
   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];
+      const rows = await this.db.select().from(agentTable).where(eq(agentTable.id, agentId)).limit(1);
+      if (rows.length === 0) return null;
+      const row = rows[0];
+      return {
+        ...row,
+        username: row.username || "",
+        id: row.id,
+        system: !row.system ? void 0 : row.system,
+        bio: !row.bio ? "" : row.bio
+      };
     });
   }
   /**
    * Asynchronously retrieves a list of agents from the database.
    *
-   * @returns {Promise<Agent[]>} A Promise that resolves to an array of Agent objects.
+   * @returns {Promise<Partial<Agent>[]>} A Promise that resolves to an array of Agent objects.
    */
   async getAgents() {
     return this.withDatabase(async () => {
-      const result = await this.db.select().from(agentTable);
-      return result;
+      const rows = await this.db.select({
+        id: agentTable.id,
+        name: agentTable.name,
+        bio: agentTable.bio
+      }).from(agentTable);
+      return rows.map((row) => ({
+        ...row,
+        id: row.id,
+        bio: row.bio === null ? "" : row.bio
+      }));
     });
   }
   /**
@@ -565,10 +584,13 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
   async updateAgent(agentId, agent) {
     return this.withDatabase(async () => {
       try {
-        if (!agent.id) {
+        if (!agentId) {
           throw new Error("Agent ID is required for update");
         }
         await this.db.transaction(async (tx) => {
+          if (agent?.settings) {
+            agent.settings = await this.mergeAgentSettings(tx, agentId, agent.settings);
+          }
           await tx.update(agentTable).set({
             ...agent,
             updatedAt: Date.now()
@@ -588,6 +610,54 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       }
     });
   }
+  /**
+   * Merges updated agent settings with existing settings in the database,
+   * with special handling for nested objects like secrets.
+   * @param tx - The database transaction
+   * @param agentId - The ID of the agent
+   * @param updatedSettings - The settings object with updates
+   * @returns The merged settings object
+   * @private
+   */
+  async mergeAgentSettings(tx, agentId, updatedSettings) {
+    const currentAgent = await tx.select({ settings: agentTable.settings }).from(agentTable).where(eq(agentTable.id, agentId)).limit(1);
+    const currentSettings = currentAgent.length > 0 && currentAgent[0].settings ? currentAgent[0].settings : {};
+    const deepMerge = /* @__PURE__ */ __name((target, source) => {
+      if (source === null) {
+        return void 0;
+      }
+      if (Array.isArray(source) || typeof source !== "object") {
+        return source;
+      }
+      const output = typeof target === "object" && target !== null && !Array.isArray(target) ? { ...target } : {};
+      let isEmpty = true;
+      for (const key of Object.keys(source)) {
+        const sourceValue = source[key];
+        if (sourceValue === null) {
+          delete output[key];
+        } else if (typeof sourceValue === "object" && !Array.isArray(sourceValue)) {
+          const nestedMergeResult = deepMerge(output[key], sourceValue);
+          if (nestedMergeResult === void 0) {
+            delete output[key];
+          } else {
+            output[key] = nestedMergeResult;
+            isEmpty = false;
+          }
+        } else {
+          output[key] = sourceValue;
+          isEmpty = false;
+        }
+      }
+      if (Object.keys(output).length === 0) {
+        if (!(typeof source === "object" && source !== null && Object.keys(source).length === 0)) {
+          return void 0;
+        }
+      }
+      return output;
+    }, "deepMerge");
+    const finalSettings = deepMerge(currentSettings, updatedSettings);
+    return finalSettings === void 0 ? {} : finalSettings;
+  }
   /**
    * Asynchronously deletes an agent with the specified UUID and all related entries.
    *
@@ -595,11 +665,161 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
    * @returns {Promise<boolean>} - A boolean indicating if the deletion was successful.
    */
   async deleteAgent(agentId) {
+    logger.debug(`[DB] Starting deletion of agent with ID: ${agentId}`);
     return this.withDatabase(async () => {
-      await this.db.transaction(async (tx) => {
-        await tx.delete(agentTable).where(eq(agentTable.id, agentId));
-      });
-      return true;
+      try {
+        logger.debug(`[DB] Beginning database transaction for deleting agent: ${agentId}`);
+        const deletePromise = new Promise((resolve, reject) => {
+          const timeoutId = setTimeout(() => {
+            logger.error(`[DB] Transaction timeout reached for agent deletion: ${agentId}`);
+            reject(new Error("Database transaction timeout"));
+          }, 3e4);
+          this.db.transaction(async (tx) => {
+            try {
+              logger.debug(`[DB] Fetching entities for agent: ${agentId}`);
+              const entities = await tx.select({ entityId: entityTable.id }).from(entityTable).where(eq(entityTable.agentId, agentId));
+              const entityIds = entities.map((e) => e.entityId);
+              logger.debug(
+                `[DB] Found ${entityIds.length} entities to delete for agent ${agentId}`
+              );
+              logger.debug(`[DB] Fetching rooms for agent: ${agentId}`);
+              const rooms = await tx.select({ roomId: roomTable.id }).from(roomTable).where(eq(roomTable.agentId, agentId));
+              const roomIds = rooms.map((r) => r.roomId);
+              logger.debug(`[DB] Found ${roomIds.length} rooms for agent ${agentId}`);
+              logger.debug(
+                `[DB] Explicitly deleting ALL logs with matching entityIds and roomIds`
+              );
+              if (entityIds.length > 0) {
+                logger.debug(`[DB] Deleting logs for ${entityIds.length} entities (first batch)`);
+                const BATCH_SIZE = 50;
+                for (let i = 0; i < entityIds.length; i += BATCH_SIZE) {
+                  const batch = entityIds.slice(i, i + BATCH_SIZE);
+                  logger.debug(
+                    `[DB] Processing entity logs batch ${i / BATCH_SIZE + 1} with ${batch.length} entities`
+                  );
+                  await tx.delete(logTable).where(inArray(logTable.entityId, batch));
+                }
+                logger.debug(`[DB] Entity logs deletion completed successfully`);
+              }
+              if (roomIds.length > 0) {
+                logger.debug(`[DB] Deleting logs for ${roomIds.length} rooms (first batch)`);
+                const BATCH_SIZE = 50;
+                for (let i = 0; i < roomIds.length; i += BATCH_SIZE) {
+                  const batch = roomIds.slice(i, i + BATCH_SIZE);
+                  logger.debug(
+                    `[DB] Processing room logs batch ${i / BATCH_SIZE + 1} with ${batch.length} rooms`
+                  );
+                  await tx.delete(logTable).where(inArray(logTable.roomId, batch));
+                }
+                logger.debug(`[DB] Room logs deletion completed successfully`);
+              }
+              let memoryIds = [];
+              if (entityIds.length > 0) {
+                logger.debug(`[DB] Finding memories belonging to entities`);
+                const memories = await tx.select({ id: memoryTable.id }).from(memoryTable).where(inArray(memoryTable.entityId, entityIds));
+                memoryIds = memories.map((m) => m.id);
+                logger.debug(`[DB] Found ${memoryIds.length} memories belonging to entities`);
+              }
+              logger.debug(`[DB] Finding memories belonging to agent directly`);
+              const agentMemories = await tx.select({ id: memoryTable.id }).from(memoryTable).where(eq(memoryTable.agentId, agentId));
+              memoryIds = [...memoryIds, ...agentMemories.map((m) => m.id)];
+              logger.debug(`[DB] Found total of ${memoryIds.length} memories to delete`);
+              if (roomIds.length > 0) {
+                logger.debug(`[DB] Finding memories belonging to rooms`);
+                const roomMemories = await tx.select({ id: memoryTable.id }).from(memoryTable).where(inArray(memoryTable.roomId, roomIds));
+                memoryIds = [...memoryIds, ...roomMemories.map((m) => m.id)];
+                logger.debug(`[DB] Updated total to ${memoryIds.length} memories to delete`);
+              }
+              if (memoryIds.length > 0) {
+                logger.debug(`[DB] Deleting embeddings for ${memoryIds.length} memories`);
+                const BATCH_SIZE = 100;
+                for (let i = 0; i < memoryIds.length; i += BATCH_SIZE) {
+                  const batch = memoryIds.slice(i, i + BATCH_SIZE);
+                  await tx.delete(embeddingTable).where(inArray(embeddingTable.memoryId, batch));
+                }
+                logger.debug(`[DB] Embeddings deleted successfully`);
+              }
+              if (memoryIds.length > 0) {
+                logger.debug(`[DB] Deleting ${memoryIds.length} memories`);
+                const BATCH_SIZE = 100;
+                for (let i = 0; i < memoryIds.length; i += BATCH_SIZE) {
+                  const batch = memoryIds.slice(i, i + BATCH_SIZE);
+                  await tx.delete(memoryTable).where(inArray(memoryTable.id, batch));
+                }
+                logger.debug(`[DB] Memories deleted successfully`);
+              }
+              if (entityIds.length > 0) {
+                logger.debug(`[DB] Deleting components for entities`);
+                await tx.delete(componentTable).where(inArray(componentTable.entityId, entityIds));
+                logger.debug(`[DB] Components deleted successfully`);
+              }
+              if (entityIds.length > 0) {
+                logger.debug(`[DB] Deleting source entity references in components`);
+                await tx.delete(componentTable).where(inArray(componentTable.sourceEntityId, entityIds));
+                logger.debug(`[DB] Source entity references deleted successfully`);
+              }
+              if (roomIds.length > 0) {
+                logger.debug(`[DB] Deleting participations for rooms`);
+                await tx.delete(participantTable).where(inArray(participantTable.roomId, roomIds));
+                logger.debug(`[DB] Participations deleted for rooms`);
+              }
+              logger.debug(`[DB] Deleting agent participations`);
+              await tx.delete(participantTable).where(eq(participantTable.agentId, agentId));
+              logger.debug(`[DB] Agent participations deleted`);
+              if (roomIds.length > 0) {
+                logger.debug(`[DB] Deleting rooms`);
+                await tx.delete(roomTable).where(inArray(roomTable.id, roomIds));
+                logger.debug(`[DB] Rooms deleted successfully`);
+              }
+              logger.debug(`[DB] Deleting cache entries`);
+              await tx.delete(cacheTable).where(eq(cacheTable.agentId, agentId));
+              logger.debug(`[DB] Cache entries deleted successfully`);
+              logger.debug(`[DB] Deleting relationships`);
+              if (entityIds.length > 0) {
+                await tx.delete(relationshipTable).where(inArray(relationshipTable.sourceEntityId, entityIds));
+                await tx.delete(relationshipTable).where(inArray(relationshipTable.targetEntityId, entityIds));
+              }
+              await tx.delete(relationshipTable).where(eq(relationshipTable.agentId, agentId));
+              logger.debug(`[DB] Relationships deleted successfully`);
+              if (entityIds.length > 0) {
+                logger.debug(`[DB] Deleting entities`);
+                await tx.delete(entityTable).where(eq(entityTable.agentId, agentId));
+                logger.debug(`[DB] Entities deleted successfully`);
+              }
+              logger.debug(`[DB] Checking for world references`);
+              const worlds = await tx.select({ id: worldTable.id }).from(worldTable).where(eq(worldTable.agentId, agentId));
+              if (worlds.length > 0) {
+                const worldIds = worlds.map((w) => w.id);
+                logger.debug(`[DB] Found ${worldIds.length} worlds to delete`);
+                await tx.delete(worldTable).where(inArray(worldTable.id, worldIds));
+                logger.debug(`[DB] Worlds deleted successfully`);
+              } else {
+                logger.debug(`[DB] No worlds found for this agent`);
+              }
+              logger.debug(`[DB] Deleting agent ${agentId}`);
+              await tx.delete(agentTable).where(eq(agentTable.id, agentId));
+              logger.debug(`[DB] Agent deleted successfully`);
+              resolve(true);
+            } catch (error) {
+              logger.error(`[DB] Error in transaction:`, error);
+              reject(error);
+            }
+          }).catch((transactionError) => {
+            clearTimeout(timeoutId);
+            reject(transactionError);
+          });
+        });
+        await deletePromise;
+        logger.success(`[DB] Agent ${agentId} successfully deleted`);
+        return true;
+      } catch (error) {
+        logger.error(`[DB] Error in database transaction for agent deletion ${agentId}:`, error);
+        if (error instanceof Error) {
+          logger.error(`[DB] Error name: ${error.name}, message: ${error.message}`);
+          logger.error(`[DB] Error stack: ${error.stack}`);
+        }
+        throw error;
+      }
     });
   }
   /**
@@ -642,20 +862,32 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
     });
   }
   /**
-   * Asynchronously retrieves an entity and its components by entity ID.
-   * @param {UUID} entityId - The unique identifier of the entity to retrieve.
-   * @returns {Promise<Entity | null>} A Promise that resolves to the entity with its components if found, null otherwise.
+   * Asynchronously retrieves an entity and its components by entity IDs.
+   * @param {UUID[]} entityIds - The unique identifiers of the entities to retrieve.
+   * @returns {Promise<Entity[] | null>} A Promise that resolves to the entity with its components if found, null otherwise.
    */
-  async getEntityById(entityId) {
+  async getEntityByIds(entityIds) {
     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)));
+      }).from(entityTable).leftJoin(componentTable, eq(componentTable.entityId, entityTable.id)).where(inArray(entityTable.id, entityIds));
       if (result.length === 0) return null;
-      const entity = result[0].entity;
-      entity.components = result.filter((row) => row.components).map((row) => row.components);
-      return entity;
+      const entities = {};
+      const entityComponents = {};
+      for (const e of result) {
+        const key = e.entity.id;
+        entities[key] = e.entity;
+        if (entityComponents[key] === void 0) entityComponents[key] = [];
+        if (e.components) {
+          const componentsArray = Array.isArray(e.components) ? e.components : [e.components];
+          entityComponents[key] = [...entityComponents[key], ...componentsArray];
+        }
+      }
+      for (const k of Object.keys(entityComponents)) {
+        entities[k].components = entityComponents[k];
+      }
+      return Object.values(entities);
     });
   }
   /**
@@ -684,6 +916,9 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
         if (!entitiesByIdMap.has(entityId)) {
           const entity = {
             ...row.entity,
+            id: entityId,
+            agentId: row.entity.agentId,
+            metadata: row.entity.metadata,
             components: includeComponents ? [] : void 0
           };
           entitiesByIdMap.set(entityId, entity);
@@ -702,25 +937,23 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
     });
   }
   /**
-   * Asynchronously creates a new entity in the database.
-   * @param {Entity} entity - The entity object to be created.
+   * Asynchronously creates new entities in the database.
+   * @param {Entity[]} entities - The entity objects to be created.
    * @returns {Promise<boolean>} A Promise that resolves to a boolean indicating the success of the operation.
    */
-  async createEntity(entity) {
+  async createEntities(entities) {
     return this.withDatabase(async () => {
       try {
         return await this.db.transaction(async (tx) => {
-          await tx.insert(entityTable).values(entity);
-          logger.debug("Entity created successfully:", {
-            entity
-          });
+          await tx.insert(entityTable).values(entities);
+          logger.debug(entities.length, "Entities created successfully");
           return true;
         });
       } catch (error) {
         logger.error("Error creating entity:", {
           error: error instanceof Error ? error.message : String(error),
-          entityId: entity.id,
-          name: entity.metadata?.name
+          entityId: entities[0].id,
+          name: entities[0].metadata?.name
         });
         logger.trace(error);
         return false;
@@ -738,9 +971,9 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       return false;
     }
     try {
-      const existingEntity = await this.getEntityById(entity.id);
-      if (!existingEntity) {
-        return await this.createEntity(entity);
+      const existingEntities = await this.getEntityByIds([entity.id]);
+      if (!existingEntities || !existingEntities.length) {
+        return await this.createEntities([entity]);
       }
       return true;
     } catch (error) {
@@ -771,7 +1004,18 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
         conditions.push(eq(componentTable.sourceEntityId, sourceEntityId));
       }
       const result = await this.db.select().from(componentTable).where(and(...conditions));
-      return result.length > 0 ? result[0] : null;
+      if (result.length === 0) return null;
+      const component = result[0];
+      return {
+        ...component,
+        id: component.id,
+        entityId: component.entityId,
+        agentId: component.agentId,
+        roomId: component.roomId,
+        worldId: component.worldId ?? "",
+        sourceEntityId: component.sourceEntityId ?? "",
+        data: component.data
+      };
     });
   }
   /**
@@ -796,10 +1040,23 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
         type: componentTable.type,
         data: componentTable.data,
         worldId: componentTable.worldId,
+        agentId: componentTable.agentId,
+        roomId: componentTable.roomId,
         sourceEntityId: componentTable.sourceEntityId,
         createdAt: componentTable.createdAt
       }).from(componentTable).where(and(...conditions));
-      return result;
+      if (result.length === 0) return [];
+      const components = result.map((component) => ({
+        ...component,
+        id: component.id,
+        entityId: component.entityId,
+        agentId: component.agentId,
+        roomId: component.roomId,
+        worldId: component.worldId ?? "",
+        sourceEntityId: component.sourceEntityId ?? "",
+        data: component.data
+      }));
+      return components;
     });
   }
   /**
@@ -845,10 +1102,8 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
    * @returns {Promise<Memory[]>} A Promise that resolves to an array of memories.
    */
   async getMemories(params) {
-    const { entityId, agentId, roomId, tableName, count: count2, unique: unique7, start, end } = params;
+    const { entityId, agentId, roomId, worldId, tableName, count: count2, unique: unique7, start, end } = params;
     if (!tableName) throw new Error("tableName is required");
-    if (!roomId && !entityId && !agentId)
-      throw new Error("roomId, entityId, or agentId is required");
     return this.withDatabase(async () => {
       const conditions = [eq(memoryTable.type, tableName)];
       if (start) {
@@ -860,6 +1115,9 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       if (roomId) {
         conditions.push(eq(memoryTable.roomId, roomId));
       }
+      if (worldId) {
+        conditions.push(eq(memoryTable.worldId, worldId));
+      }
       if (end) {
         conditions.push(lte(memoryTable.createdAt, end));
       }
@@ -959,6 +1217,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
         agentId: row.memory.agentId,
         roomId: row.memory.roomId,
         unique: row.memory.unique,
+        metadata: row.memory.metadata,
         embedding: row.embedding ?? void 0
       };
     });
@@ -1008,7 +1267,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
   async getCachedEmbeddings(opts) {
     return this.withDatabase(async () => {
       try {
-        const results = await this.db.execute(sql12`
+        const results = await this.db.execute(sql13`
                     WITH content_text AS (
                         SELECT
                             m.id,
@@ -1021,7 +1280,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
                             AND m.content->>${opts.query_field_sub_name} IS NOT NULL
                     ),
                     embedded_text AS (
-                        SELECT 
+                        SELECT
                             ct.content_text,
                             COALESCE(
                                 e.dim_384,
@@ -1072,9 +1331,11 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
   async log(params) {
     return this.withDatabase(async () => {
       try {
+        const sanitizedBody = this.sanitizeJsonObject(params.body);
+        const jsonString = JSON.stringify(sanitizedBody);
         await this.db.transaction(async (tx) => {
           await tx.insert(logTable).values({
-            body: sql12`${params.body}::jsonb`,
+            body: sql13`${jsonString}::jsonb`,
             entityId: params.entityId,
             roomId: params.roomId,
             type: params.type
@@ -1091,6 +1352,34 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       }
     });
   }
+  /**
+   * Sanitizes a JSON object by replacing problematic Unicode escape sequences
+   * that could cause errors during JSON serialization/storage
+   *
+   * @param value - The value to sanitize
+   * @returns The sanitized value
+   */
+  sanitizeJsonObject(value) {
+    if (value === null || value === void 0) {
+      return value;
+    }
+    if (typeof value === "string") {
+      return value.replace(/\u0000/g, "").replace(/\\(?!["\\/bfnrtu])/g, "\\\\").replace(/\\u(?![0-9a-fA-F]{4})/g, "\\\\u");
+    }
+    if (typeof value === "object") {
+      if (Array.isArray(value)) {
+        return value.map((item) => this.sanitizeJsonObject(item));
+      } else {
+        const result = {};
+        for (const [key, val] of Object.entries(value)) {
+          const sanitizedKey = typeof key === "string" ? key.replace(/\u0000/g, "").replace(/\\u(?![0-9a-fA-F]{4})/g, "\\\\u") : key;
+          result[sanitizedKey] = this.sanitizeJsonObject(val);
+        }
+        return result;
+      }
+    }
+    return value;
+  }
   /**
    * Asynchronously retrieves logs from the database based on the provided parameters.
    * @param {Object} params - The parameters for retrieving logs.
@@ -1111,7 +1400,16 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
           type ? eq(logTable.type, type) : void 0
         )
       ).orderBy(desc(logTable.createdAt)).limit(count2 ?? 10).offset(offset ?? 0);
-      return result;
+      const logs = result.map((log) => ({
+        ...log,
+        id: log.id,
+        entityId: log.entityId,
+        roomId: log.roomId,
+        body: log.body,
+        createdAt: new Date(log.createdAt)
+      }));
+      if (logs.length === 0) return [];
+      return logs;
     });
   }
   /**
@@ -1128,18 +1426,24 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
    * Asynchronously searches for memories in the database based on the provided parameters.
    * @param {Object} params - The parameters for searching for memories.
    * @param {string} params.tableName - The name of the table to search for memories in.
-   * @param {UUID} params.roomId - The ID of the room to search for memories in.
    * @param {number[]} params.embedding - The embedding to search for.
    * @param {number} [params.match_threshold] - The threshold for the cosine distance.
    * @param {number} [params.count] - The maximum number of memories to retrieve.
    * @param {boolean} [params.unique] - Whether to retrieve unique memories only.
+   * @param {string} [params.query] - Optional query string for potential reranking.
+   * @param {UUID} [params.roomId] - Optional room ID to filter by.
+   * @param {UUID} [params.worldId] - Optional world ID to filter by.
+   * @param {UUID} [params.entityId] - Optional entity ID to filter by.
    * @returns {Promise<Memory[]>} A Promise that resolves to an array of memories.
    */
   async searchMemories(params) {
     return await this.searchMemoriesByEmbedding(params.embedding, {
       match_threshold: params.match_threshold,
       count: params.count,
+      // Pass direct scope fields down
       roomId: params.roomId,
+      worldId: params.worldId,
+      entityId: params.entityId,
       unique: params.unique,
       tableName: params.tableName
     });
@@ -1150,7 +1454,9 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
    * @param {Object} params - The parameters for searching for memories.
    * @param {number} [params.match_threshold] - The threshold for the cosine distance.
    * @param {number} [params.count] - The maximum number of memories to retrieve.
-   * @param {UUID} [params.roomId] - The ID of the room to search for memories in.
+   * @param {UUID} [params.roomId] - Optional room ID to filter by.
+   * @param {UUID} [params.worldId] - Optional world ID to filter by.
+   * @param {UUID} [params.entityId] - Optional entity ID to filter by.
    * @param {boolean} [params.unique] - Whether to retrieve unique memories only.
    * @param {string} [params.tableName] - The name of the table to search for memories in.
    * @returns {Promise<Memory[]>} A Promise that resolves to an array of memories.
@@ -1158,7 +1464,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
   async searchMemoriesByEmbedding(embedding, params) {
     return this.withDatabase(async () => {
       const cleanVector = embedding.map((n) => Number.isFinite(n) ? Number(n.toFixed(6)) : 0);
-      const similarity = sql12`1 - (${cosineDistance(
+      const similarity = sql13`1 - (${cosineDistance(
         embeddingTable[this.embeddingDimension],
         cleanVector
       )})`;
@@ -1170,6 +1476,12 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       if (params.roomId) {
         conditions.push(eq(memoryTable.roomId, params.roomId));
       }
+      if (params.worldId) {
+        conditions.push(eq(memoryTable.worldId, params.worldId));
+      }
+      if (params.entityId) {
+        conditions.push(eq(memoryTable.entityId, params.entityId));
+      }
       if (params.match_threshold) {
         conditions.push(gte(similarity, params.match_threshold));
       }
@@ -1186,6 +1498,8 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
         entityId: row.memory.entityId,
         agentId: row.memory.agentId,
         roomId: row.memory.roomId,
+        worldId: row.memory.worldId,
+        // Include worldId
         unique: row.memory.unique,
         metadata: row.memory.metadata,
         embedding: row.embedding ?? void 0,
@@ -1205,28 +1519,40 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       embeddingLength: memory.embedding?.length,
       contentLength: memory.content?.text?.length
     });
+    const memoryId = memory.id ?? v4();
+    const existing = await this.getMemoryById(memoryId);
+    if (existing) {
+      logger.debug("Memory already exists, skipping creation:", {
+        memoryId
+      });
+      return memoryId;
+    }
     let isUnique = true;
     if (memory.embedding && Array.isArray(memory.embedding)) {
       const similarMemories = await this.searchMemoriesByEmbedding(memory.embedding, {
         tableName,
+        // Use the scope fields from the memory object for similarity check
         roomId: memory.roomId,
+        worldId: memory.worldId,
+        entityId: memory.entityId,
         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: sql12`${contentToInsert}::jsonb`,
-          metadata: sql12`${memory.metadata || {}}::jsonb`,
+          content: sql13`${contentToInsert}::jsonb`,
+          metadata: sql13`${memory.metadata || {}}::jsonb`,
           entityId: memory.entityId,
           roomId: memory.roomId,
-          agentId: memory.agentId,
+          worldId: memory.worldId,
+          // Include worldId
+          agentId: this.agentId,
           unique: memory.unique ?? isUnique,
           createdAt: memory.createdAt
         }
@@ -1262,12 +1588,12 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
           if (memory.content) {
             const contentToUpdate = typeof memory.content === "string" ? JSON.parse(memory.content) : memory.content;
             await tx.update(memoryTable).set({
-              content: sql12`${contentToUpdate}::jsonb`,
-              ...memory.metadata && { metadata: sql12`${memory.metadata}::jsonb` }
+              content: sql13`${contentToUpdate}::jsonb`,
+              ...memory.metadata && { metadata: sql13`${memory.metadata}::jsonb` }
             }).where(eq(memoryTable.id, memory.id));
           } else if (memory.metadata) {
             await tx.update(memoryTable).set({
-              metadata: sql12`${memory.metadata}::jsonb`
+              metadata: sql13`${memory.metadata}::jsonb`
             }).where(eq(memoryTable.id, memory.id));
           }
           if (memory.embedding && Array.isArray(memory.embedding)) {
@@ -1349,10 +1675,10 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
     const fragments = await tx.select({ id: memoryTable.id }).from(memoryTable).where(
       and(
         eq(memoryTable.agentId, this.agentId),
-        sql12`${memoryTable.metadata}->>'documentId' = ${documentId}`
+        sql13`${memoryTable.metadata}->>'documentId' = ${documentId}`
       )
     );
-    return fragments;
+    return fragments.map((f) => ({ id: f.id }));
   }
   /**
    * Asynchronously deletes all memories from the database based on the provided parameters.
@@ -1363,21 +1689,21 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
   async deleteAllMemories(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)));
+        const rows = await tx.select({ id: memoryTable.id }).from(memoryTable).where(and(eq(memoryTable.roomId, roomId), eq(memoryTable.type, tableName)));
+        const ids = rows.map((r) => r.id);
+        logger.debug("[deleteAllMemories] memory IDs to delete:", { roomId, tableName, ids });
+        if (ids.length === 0) {
+          return;
         }
+        await Promise.all(
+          ids.map(async (memoryId) => {
+            await this.deleteMemoryFragments(tx, memoryId);
+            await tx.delete(embeddingTable).where(eq(embeddingTable.memoryId, memoryId));
+          })
+        );
+        await tx.delete(memoryTable).where(and(eq(memoryTable.roomId, roomId), eq(memoryTable.type, tableName)));
       });
-      logger.debug("All memories removed successfully:", {
-        roomId,
-        tableName
-      });
+      logger.debug("All memories removed successfully:", { roomId, tableName });
     });
   }
   /**
@@ -1394,28 +1720,42 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       if (unique7) {
         conditions.push(eq(memoryTable.unique, true));
       }
-      const result = await this.db.select({ count: sql12`count(*)` }).from(memoryTable).where(and(...conditions));
+      const result = await this.db.select({ count: sql13`count(*)` }).from(memoryTable).where(and(...conditions));
       return Number(result[0]?.count ?? 0);
     });
   }
   /**
-   * Asynchronously retrieves a room from the database based on the provided parameters.
-   * @param {UUID} roomId - The ID of the room to retrieve.
-   * @returns {Promise<Room | null>} A Promise that resolves to the room if found, null otherwise.
+   * Asynchronously retrieves rooms from the database based on the provided parameters.
+   * @param {UUID[]} roomIds - The IDs of the rooms to retrieve.
+   * @returns {Promise<Room[] | null>} A Promise that resolves to the rooms if found, null otherwise.
    */
-  async getRoom(roomId) {
+  async getRoomsByIds(roomIds) {
     return this.withDatabase(async () => {
       const result = await this.db.select({
         id: roomTable.id,
+        name: roomTable.name,
+        // Added name
         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];
+        source: roomTable.source,
+        metadata: roomTable.metadata
+        // Added metadata
+      }).from(roomTable).where(and(inArray(roomTable.id, roomIds), eq(roomTable.agentId, this.agentId)));
+      const rooms = result.map((room) => ({
+        ...room,
+        id: room.id,
+        name: room.name ?? void 0,
+        agentId: room.agentId,
+        serverId: room.serverId,
+        worldId: room.worldId,
+        channelId: room.channelId,
+        type: room.type,
+        metadata: room.metadata
+      }));
+      return rooms;
     });
   }
   /**
@@ -1423,10 +1763,21 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
    * @param {UUID} worldId - The ID of the world to retrieve rooms from.
    * @returns {Promise<Room[]>} A Promise that resolves to an array of rooms.
    */
-  async getRooms(worldId) {
+  async getRoomsByWorld(worldId) {
     return this.withDatabase(async () => {
       const result = await this.db.select().from(roomTable).where(eq(roomTable.worldId, worldId));
-      return result;
+      const rooms = result.map((room) => ({
+        ...room,
+        id: room.id,
+        name: room.name ?? void 0,
+        agentId: room.agentId,
+        serverId: room.serverId,
+        worldId: room.worldId,
+        channelId: room.channelId,
+        type: room.type,
+        metadata: room.metadata
+      }));
+      return rooms;
     });
   }
   /**
@@ -1444,30 +1795,16 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
    * @param {Room} room - The room object to create.
    * @returns {Promise<UUID>} A Promise that resolves to the ID of the created room.
    */
-  async createRoom({
-    id,
-    name,
-    source,
-    type,
-    channelId,
-    serverId,
-    worldId,
-    metadata
-  }) {
+  async createRooms(rooms) {
     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,
-        metadata
-      }).onConflictDoNothing({ target: roomTable.id });
-      return newRoomId;
+      const roomsWithIds = rooms.map((room) => ({
+        ...room,
+        id: room.id || v4()
+        // ensure each room has a unique ID
+      }));
+      const insertedRooms = await this.db.insert(roomTable).values(roomsWithIds).onConflictDoNothing().returning();
+      const insertedIds = insertedRooms.map((r) => r.id);
+      return insertedIds;
     });
   }
   /**
@@ -1533,6 +1870,28 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       }
     });
   }
+  async addParticipantsRoom(entityIds, roomId) {
+    return this.withDatabase(async () => {
+      try {
+        const values = entityIds.map((id) => ({
+          entityId: id,
+          roomId,
+          agentId: this.agentId
+        }));
+        await this.db.insert(participantTable).values(values).onConflictDoNothing().execute();
+        logger.debug(entityIds.length, "Entities linked successfully");
+        return true;
+      } catch (error) {
+        logger.error("Error adding participants", {
+          error: error instanceof Error ? error.message : String(error),
+          entityIdSample: entityIds[0],
+          roomId,
+          agentId: this.agentId
+        });
+        return false;
+      }
+    });
+  }
   /**
    * Asynchronously removes a participant from a room in the database based on the provided parameters.
    * @param {UUID} entityId - The ID of the entity to remove from the room.
@@ -1576,13 +1935,13 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
         entityId: participantTable.entityId,
         roomId: participantTable.roomId
       }).from(participantTable).where(eq(participantTable.entityId, entityId));
-      const entity = await this.getEntityById(entityId);
-      if (!entity) {
+      const entities = await this.getEntityByIds([entityId]);
+      if (!entities || !entities.length) {
         return [];
       }
       return result.map((row) => ({
         id: row.id,
-        entity
+        entity: entities[0]
       }));
     });
   }
@@ -1745,39 +2104,28 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
    */
   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(
-            sql12`${relationshipTable.tags} @> ARRAY[${sql12.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 [];
-      }
+      const conditions = [
+        or(
+          eq(relationshipTable.sourceEntityId, params.entityId),
+          eq(relationshipTable.targetEntityId, params.entityId)
+        ),
+        eq(relationshipTable.agentId, this.agentId),
+        ...params.tags && params.tags.length > 0 ? [
+          sql13`${relationshipTable.tags} @> ARRAY[${sql13.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()
+      }));
     });
   }
   /**
@@ -1864,7 +2212,8 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       const newWorldId = world.id || v4();
       await this.db.insert(worldTable).values({
         ...world,
-        id: newWorldId
+        id: newWorldId,
+        name: world.name || ""
       });
       return newWorldId;
     });
@@ -1916,6 +2265,9 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
    * @returns {Promise<UUID>} A Promise that resolves to the ID of the created task.
    */
   async createTask(task) {
+    if (!task.worldId) {
+      throw new Error("worldId is required");
+    }
     return this.withRetry(async () => {
       return this.withDatabase(async () => {
         const now = /* @__PURE__ */ new Date();
@@ -1932,35 +2284,37 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
           updatedAt: now,
           agentId: this.agentId
         };
-        const result = await this.db.insert(taskTable).values(values).returning({ id: taskTable.id });
+        const result = await this.db.insert(taskTable).values(values).returning();
         return result[0].id;
       });
     });
   }
   /**
    * Asynchronously retrieves tasks based on specified parameters.
-   * @param params Object containing optional roomId and tags to filter tasks
+   * @param params Object containing optional roomId, tags, and entityId to filter tasks
    * @returns Promise resolving to an array of Task objects
    */
   async getTasks(params) {
     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(sql12`${taskTable.tags} @> ARRAY[${sql12.raw(tagParams)}]::text[]`);
-        }
-        const result = await query;
+        const result = await this.db.select().from(taskTable).where(
+          and(
+            eq(taskTable.agentId, this.agentId),
+            ...params.roomId ? [eq(taskTable.roomId, params.roomId)] : [],
+            ...params.tags && params.tags.length > 0 ? [
+              sql13`${taskTable.tags} @> ARRAY[${sql13.raw(
+                params.tags.map((t) => `'${t.replace(/'/g, "''")}'`).join(", ")
+              )}]::text[]`
+            ] : []
+          )
+        );
         return result.map((row) => ({
           id: row.id,
           name: row.name,
-          description: row.description,
+          description: row.description ?? "",
           roomId: row.roomId,
           worldId: row.worldId,
-          tags: row.tags,
+          tags: row.tags || [],
           metadata: row.metadata
         }));
       });
@@ -1978,7 +2332,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
         return result.map((row) => ({
           id: row.id,
           name: row.name,
-          description: row.description,
+          description: row.description ?? "",
           roomId: row.roomId,
           worldId: row.worldId,
           tags: row.tags || [],
@@ -2003,7 +2357,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
         return {
           id: row.id,
           name: row.name,
-          description: row.description,
+          description: row.description ?? "",
           roomId: row.roomId,
           worldId: row.worldId,
           tags: row.tags || [],
@@ -2053,70 +2407,53 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
    * @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)));
-      });
+    return this.withDatabase(async () => {
+      await this.db.delete(taskTable).where(eq(taskTable.id, id));
     });
   }
-  /**
-   * Asynchronously retrieves group chat memories from all rooms under a given server.
-   * It fetches all room IDs associated with the `serverId`, then retrieves memories
-   * from those rooms in descending order (latest to oldest), with an optional count limit.
-   *
-   * @param {Object} params - Parameters for fetching memories.
-   * @param {UUID} params.serverId - The server ID to fetch memories for.
-   * @param {number} [params.count] - The maximum number of memories to retrieve.
-   * @returns {Promise<Memory[]>} - A promise that resolves to an array of memory objects.
-   */
-  async getMemoriesByServerId(params) {
+  async getMemoriesByWorldId(params) {
     return this.withDatabase(async () => {
-      const roomIdsResult = await this.db.select({ roomId: roomTable.id }).from(roomTable).where(eq(roomTable.serverId, params.serverId));
-      if (roomIdsResult.length === 0) return [];
-      const roomIds = roomIdsResult.map((row) => row.roomId);
-      const query = this.db.select({
-        memory: memoryTable,
-        embedding: embeddingTable[this.embeddingDimension]
-      }).from(memoryTable).leftJoin(embeddingTable, eq(embeddingTable.memoryId, memoryTable.id)).where(inArray(memoryTable.roomId, roomIds)).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 ?? void 0
-      }));
+      const rooms = await this.db.select({ id: roomTable.id }).from(roomTable).where(and(eq(roomTable.worldId, params.worldId), eq(roomTable.agentId, this.agentId)));
+      if (rooms.length === 0) {
+        return [];
+      }
+      const roomIds = rooms.map((room) => room.id);
+      const memories = await this.getMemoriesByRoomIds({
+        roomIds,
+        tableName: params.tableName || "messages",
+        limit: params.count
+      });
+      return memories;
     });
   }
-  /**
-   * Asynchronously deletes all rooms associated with a specific serverId.
-   * @param {UUID} serverId - The server ID to delete rooms for.
-   * @returns {Promise<void>} A Promise that resolves when the rooms are deleted.
-   */
-  async deleteRoomsByServerId(serverId) {
+  async deleteRoomsByWorldId(worldId) {
     return this.withDatabase(async () => {
-      await this.db.transaction(async (tx) => {
-        const roomIdsResult = await tx.select({ roomId: roomTable.id }).from(roomTable).where(eq(roomTable.serverId, serverId));
-        if (roomIdsResult.length === 0) return;
-        const roomIds = roomIdsResult.map((row) => row.roomId);
-        await tx.delete(embeddingTable).where(
-          inArray(
-            embeddingTable.memoryId,
-            tx.select({ id: memoryTable.id }).from(memoryTable).where(inArray(memoryTable.roomId, roomIds))
-          )
+      const rooms = await this.db.select({ id: roomTable.id }).from(roomTable).where(and(eq(roomTable.worldId, worldId), eq(roomTable.agentId, this.agentId)));
+      if (rooms.length === 0) {
+        logger.debug(
+          `No rooms found for worldId ${worldId} and agentId ${this.agentId} to delete.`
         );
-        await tx.delete(memoryTable).where(inArray(memoryTable.roomId, roomIds));
-        await tx.delete(participantTable).where(inArray(participantTable.roomId, roomIds));
-        await tx.delete(logTable).where(inArray(logTable.roomId, roomIds));
-        await tx.delete(roomTable).where(inArray(roomTable.id, roomIds));
-      });
-      logger.debug("Rooms and related logs deleted successfully for server:", {
-        serverId
-      });
+        return;
+      }
+      const roomIds = rooms.map((room) => room.id);
+      if (roomIds.length > 0) {
+        await this.db.delete(logTable).where(inArray(logTable.roomId, roomIds));
+        logger.debug(`Deleted logs for ${roomIds.length} rooms in world ${worldId}.`);
+        await this.db.delete(participantTable).where(inArray(participantTable.roomId, roomIds));
+        logger.debug(`Deleted participants for ${roomIds.length} rooms in world ${worldId}.`);
+        const memoriesInRooms = await this.db.select({ id: memoryTable.id }).from(memoryTable).where(inArray(memoryTable.roomId, roomIds));
+        const memoryIdsInRooms = memoriesInRooms.map((m) => m.id);
+        if (memoryIdsInRooms.length > 0) {
+          await this.db.delete(embeddingTable).where(inArray(embeddingTable.memoryId, memoryIdsInRooms));
+          logger.debug(
+            `Deleted embeddings for ${memoryIdsInRooms.length} memories in world ${worldId}.`
+          );
+          await this.db.delete(memoryTable).where(inArray(memoryTable.id, memoryIdsInRooms));
+          logger.debug(`Deleted ${memoryIdsInRooms.length} memories in world ${worldId}.`);
+        }
+        await this.db.delete(roomTable).where(inArray(roomTable.id, roomIds));
+        logger.debug(`Deleted ${roomIds.length} rooms for worldId ${worldId}.`);
+      }
     });
   }
 };
@@ -2171,6 +2508,14 @@ var PgliteDatabaseAdapter = class extends BaseDrizzleAdapter {
   async close() {
     await this.manager.close();
   }
+  /**
+   * Asynchronously retrieves the connection from the manager.
+   *
+   * @returns {Promise<PGlite>} A Promise that resolves with the connection.
+   */
+  async getConnection() {
+    return this.manager.getConnection();
+  }
 };
 
 // src/pg/adapter.ts
@@ -2233,6 +2578,14 @@ var PgDatabaseAdapter = class extends BaseDrizzleAdapter {
   async close() {
     await this.manager.close();
   }
+  /**
+   * Asynchronously retrieves the connection from the manager.
+   *
+   * @returns {Promise<PgPool>} A Promise that resolves with the connection.
+   */
+  async getConnection() {
+    return this.manager.getConnection();
+  }
 };
 
 // src/index.ts
@@ -2242,17 +2595,8 @@ if (!globalSymbols[GLOBAL_SINGLETONS]) {
   globalSymbols[GLOBAL_SINGLETONS] = {};
 }
 var globalSingletons = globalSymbols[GLOBAL_SINGLETONS];
-function expandTildePath(filepath) {
-  if (filepath && typeof filepath === "string" && filepath.startsWith("~")) {
-    return filepath.replace(/^~/, os.homedir());
-  }
-  return filepath;
-}
-__name(expandTildePath, "expandTildePath");
 function createDatabaseAdapter(config, agentId) {
-  if (config.dataDir) {
-    config.dataDir = expandTildePath(config.dataDir);
-  }
+  const dataDir = resolvePgliteDir(config.dataDir);
   if (config.postgresUrl) {
     if (!globalSingletons.postgresConnectionManager) {
       globalSingletons.postgresConnectionManager = new PostgresConnectionManager(
@@ -2261,7 +2605,6 @@ function createDatabaseAdapter(config, agentId) {
     }
     return new PgDatabaseAdapter(agentId, globalSingletons.postgresConnectionManager);
   }
-  const dataDir = config.dataDir ?? "./elizadb";
   if (!globalSingletons.pgLiteClientManager) {
     globalSingletons.pgLiteClientManager = new PGliteClientManager({ dataDir });
   }
@@ -2273,7 +2616,7 @@ var sqlPlugin = {
   description: "SQL database adapter plugin using Drizzle ORM",
   init: /* @__PURE__ */ __name(async (_, runtime) => {
     const config = {
-      dataDir: runtime.getSetting("PGLITE_DATA_DIR") ?? "./pglite",
+      dataDir: resolvePgliteDir(runtime.getSetting("PGLITE_DATA_DIR")),
       postgresUrl: runtime.getSetting("POSTGRES_URL")
     };
     try {