@elizaos/plugin-sql 1.0.0-alpha.63 → 1.0.0-alpha.64

package/dist/index.js

@@ -2,13 +2,11 @@ import {
   PGliteClientManager,
   PostgresConnectionManager,
   __name
-} from "./chunk-JA2K6HCO.js";
+} from "./chunk-BB7AIHAE.js";
 
 // src/index.ts
 import * as os from "node:os";
-import {
-  logger as logger4
-} from "@elizaos/core";
+import { logger as logger4 } from "@elizaos/core";
 
 // src/pglite/adapter.ts
 import { logger as logger2 } from "@elizaos/core";
@@ -19,30 +17,12 @@ import {
   DatabaseAdapter,
   logger
 } 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 sql12 } 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 { check as check2, foreignKey as foreignKey2, index as index2, pgTable as pgTable6, uuid as uuid6, vector as vector2 } from "drizzle-orm/pg-core";
 
 // src/schema/memory.ts
 import { relations, sql as sql5 } from "drizzle-orm";
@@ -59,14 +39,7 @@ import {
 
 // src/schema/agent.ts
 import { sql } from "drizzle-orm";
-import {
-  boolean,
-  jsonb,
-  pgTable,
-  text,
-  unique,
-  uuid
-} from "drizzle-orm/pg-core";
+import { boolean, jsonb, pgTable, text, unique, uuid } from "drizzle-orm/pg-core";
 
 // src/schema/types.ts
 import { customType } from "drizzle-orm/pg-core";
@@ -81,19 +54,17 @@ var stringJsonb = customType({
     return JSON.stringify(value);
   }
 });
-var numberTimestamp = customType(
-  {
-    dataType() {
-      return "timestamptz";
-    },
-    toDriver(value) {
-      return new Date(value).toISOString();
-    },
-    fromDriver(value) {
-      return new Date(value).getTime();
-    }
+var numberTimestamp = customType({
+  dataType() {
+    return "timestamptz";
+  },
+  toDriver(value) {
+    return new Date(value).toISOString();
+  },
+  fromDriver(value) {
+    return new Date(value).getTime();
   }
-);
+});
 
 // src/schema/agent.ts
 var agentTable = pgTable(
@@ -354,13 +325,7 @@ var logTable = pgTable9(
 
 // src/schema/participant.ts
 import { sql as sql10 } from "drizzle-orm";
-import {
-  foreignKey as foreignKey4,
-  index as index3,
-  pgTable as pgTable10,
-  text as text9,
-  uuid as uuid10
-} from "drizzle-orm/pg-core";
+import { foreignKey as foreignKey4, index as index3, pgTable as pgTable10, text as text9, uuid as uuid10 } from "drizzle-orm/pg-core";
 var participantTable = pgTable10(
   "participants",
   {
@@ -396,15 +361,7 @@ var participantTable = pgTable10(
 
 // src/schema/relationship.ts
 import { sql as sql11 } from "drizzle-orm";
-import {
-  foreignKey as foreignKey5,
-  index as index4,
-  jsonb as jsonb9,
-  pgTable as pgTable11,
-  text as text10,
-  unique as unique6,
-  uuid as uuid11
-} from "drizzle-orm/pg-core";
+import { foreignKey as foreignKey5, index as index4, jsonb as jsonb9, pgTable as pgTable11, text as text10, unique as unique6, uuid as uuid11 } from "drizzle-orm/pg-core";
 var relationshipTable = pgTable11(
   "relationships",
   {
@@ -417,15 +374,8 @@ var relationshipTable = pgTable11(
     metadata: jsonb9("metadata")
   },
   (table) => [
-    index4("idx_relationships_users").on(
-      table.sourceEntityId,
-      table.targetEntityId
-    ),
-    unique6("unique_relationship").on(
-      table.sourceEntityId,
-      table.targetEntityId,
-      table.agentId
-    ),
+    index4("idx_relationships_users").on(table.sourceEntityId, table.targetEntityId),
+    unique6("unique_relationship").on(table.sourceEntityId, table.targetEntityId, table.agentId),
     foreignKey5({
       name: "fk_user_a",
       columns: [table.sourceEntityId],
@@ -488,19 +438,13 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       } catch (error) {
         lastError = error;
         if (attempt < this.maxRetries) {
-          const backoffDelay = Math.min(
-            this.baseDelay * 2 ** (attempt - 1),
-            this.maxDelay
-          );
+          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`
-            }
-          );
+          logger.warn(`Database operation failed (attempt ${attempt}/${this.maxRetries}):`, {
+            error: error instanceof Error ? error.message : String(error),
+            nextRetryIn: `${(delay / 1e3).toFixed(1)}s`
+          });
           await new Promise((resolve) => setTimeout(resolve, delay));
         } else {
           logger.error("Max retry attempts reached:", {
@@ -696,12 +640,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       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(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);
@@ -721,16 +660,10 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
         ...includeComponents && { components: componentTable }
       }).from(participantTable).leftJoin(
         entityTable,
-        and(
-          eq(participantTable.entityId, entityTable.id),
-          eq(entityTable.agentId, this.agentId)
-        )
+        and(eq(participantTable.entityId, entityTable.id), eq(entityTable.agentId, this.agentId))
       );
       if (includeComponents) {
-        query.leftJoin(
-          componentTable,
-          eq(componentTable.entityId, entityTable.id)
-        );
+        query.leftJoin(componentTable, eq(componentTable.entityId, entityTable.id));
       }
       const result = await query.where(eq(participantTable.roomId, roomId));
       const entitiesByIdMap = /* @__PURE__ */ new Map();
@@ -778,7 +711,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
           entityId: entity.id,
           name: entity.metadata?.name
         });
-        console.trace(error);
+        logger.trace(error);
         return false;
       }
     });
@@ -814,20 +747,12 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
    */
   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)
-        )
-      );
+      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)
-      ];
+      const conditions = [eq(componentTable.entityId, entityId), eq(componentTable.type, type)];
       if (worldId) {
         conditions.push(eq(componentTable.worldId, worldId));
       }
@@ -909,23 +834,30 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
    * @returns {Promise<Memory[]>} A Promise that resolves to an array of memories.
    */
   async getMemories(params) {
-    if (!params.tableName) throw new Error("tableName is required");
-    if (!params.roomId) throw new Error("roomId is required");
+    const { entityId, agentId, roomId, 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, params.tableName),
-        eq(memoryTable.roomId, params.roomId)
-      ];
-      if (params.start) {
-        conditions.push(gte(memoryTable.createdAt, params.start));
+      const conditions = [eq(memoryTable.type, tableName)];
+      if (start) {
+        conditions.push(gte(memoryTable.createdAt, start));
       }
-      if (params.end) {
-        conditions.push(lte(memoryTable.createdAt, params.end));
+      if (entityId) {
+        conditions.push(eq(memoryTable.entityId, entityId));
       }
-      if (params.unique) {
+      if (roomId) {
+        conditions.push(eq(memoryTable.roomId, roomId));
+      }
+      if (end) {
+        conditions.push(lte(memoryTable.createdAt, end));
+      }
+      if (unique7) {
         conditions.push(eq(memoryTable.unique, true));
       }
-      conditions.push(eq(memoryTable.agentId, this.agentId));
+      if (agentId) {
+        conditions.push(eq(memoryTable.agentId, agentId));
+      }
       const query = this.db.select({
         memory: {
           id: memoryTable.id,
@@ -935,7 +867,8 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
           entityId: memoryTable.entityId,
           agentId: memoryTable.agentId,
           roomId: memoryTable.roomId,
-          unique: memoryTable.unique
+          unique: memoryTable.unique,
+          metadata: memoryTable.metadata
         },
         embedding: embeddingTable[this.embeddingDimension]
       }).from(memoryTable).leftJoin(embeddingTable, eq(embeddingTable.memoryId, memoryTable.id)).where(and(...conditions)).orderBy(desc(memoryTable.createdAt));
@@ -949,6 +882,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 ? Array.from(row.embedding) : void 0
       }));
     });
@@ -1021,7 +955,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
    * @param {Object} params - The parameters for retrieving memories.
    * @param {UUID[]} params.memoryIds - The IDs of the memories to retrieve.
    * @param {string} [params.tableName] - The name of the table to retrieve memories from.
-   * @returns {Promise<Memory[]>} A Promise that resolves to an array of memories.	
+   * @returns {Promise<Memory[]>} A Promise that resolves to an array of memories.
    */
   async getMemoriesByIds(memoryIds, tableName) {
     return this.withDatabase(async () => {
@@ -1209,9 +1143,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 cleanVector = embedding.map((n) => Number.isFinite(n) ? Number(n.toFixed(6)) : 0);
       const similarity = sql12`1 - (${cosineDistance(
         embeddingTable[this.embeddingDimension],
         cleanVector
@@ -1253,7 +1185,6 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
    * @returns {Promise<UUID>} A Promise that resolves to the ID of the created memory.
    */
   async createMemory(memory, tableName) {
-    console.log("memory.id is", memory.id);
     logger.debug("DrizzleAdapter createMemory:", {
       memoryId: memory.id,
       embeddingLength: memory.embedding?.length,
@@ -1261,15 +1192,12 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
     });
     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
-        }
-      );
+      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;
@@ -1303,6 +1231,63 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
     });
     return memoryId;
   }
+  /**
+   * Updates an existing memory in the database.
+   * @param memory The memory object with updated content and optional embedding
+   * @returns Promise resolving to boolean indicating success
+   */
+  async updateMemory(memory) {
+    return this.withDatabase(async () => {
+      try {
+        logger.debug("Updating memory:", {
+          memoryId: memory.id,
+          hasEmbedding: !!memory.embedding
+        });
+        await this.db.transaction(async (tx) => {
+          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` }
+            }).where(eq(memoryTable.id, memory.id));
+          } else if (memory.metadata) {
+            await tx.update(memoryTable).set({
+              metadata: sql12`${memory.metadata}::jsonb`
+            }).where(eq(memoryTable.id, memory.id));
+          }
+          if (memory.embedding && Array.isArray(memory.embedding)) {
+            const cleanVector = memory.embedding.map(
+              (n) => Number.isFinite(n) ? Number(n.toFixed(6)) : 0
+            );
+            const existingEmbedding = await tx.select({ id: embeddingTable.id }).from(embeddingTable).where(eq(embeddingTable.memoryId, memory.id)).limit(1);
+            if (existingEmbedding.length > 0) {
+              const updateValues = {};
+              updateValues[this.embeddingDimension] = cleanVector;
+              await tx.update(embeddingTable).set(updateValues).where(eq(embeddingTable.memoryId, memory.id));
+            } else {
+              const embeddingValues = {
+                id: v4(),
+                memoryId: memory.id,
+                createdAt: Date.now()
+              };
+              embeddingValues[this.embeddingDimension] = cleanVector;
+              await tx.insert(embeddingTable).values([embeddingValues]);
+            }
+          }
+        });
+        logger.debug("Memory updated successfully:", {
+          memoryId: memory.id
+        });
+        return true;
+      } catch (error) {
+        logger.error("Error updating memory:", {
+          error: error instanceof Error ? error.message : String(error),
+          memoryId: memory.id
+        });
+        return false;
+      }
+    });
+  }
   /**
    * Asynchronously deletes a memory from the database based on the provided parameters.
    * @param {UUID} memoryId - The ID of the memory to delete.
@@ -1312,9 +1297,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
     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))
-        );
+        await tx.delete(memoryTable).where(and(eq(memoryTable.id, memoryId)));
       });
       logger.debug("Memory removed successfully:", {
         memoryId
@@ -1330,12 +1313,7 @@ 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)
-          )
-        );
+        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(
@@ -1343,12 +1321,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
               memoryIds.map((m) => m.id)
             )
           );
-          await tx.delete(memoryTable).where(
-            and(
-              eq(memoryTable.roomId, roomId),
-              eq(memoryTable.type, tableName)
-            )
-          );
+          await tx.delete(memoryTable).where(and(eq(memoryTable.roomId, roomId), eq(memoryTable.type, tableName)));
         }
       });
       logger.debug("All memories removed successfully:", {
@@ -1367,10 +1340,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
   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)
-      ];
+      const conditions = [eq(memoryTable.roomId, roomId), eq(memoryTable.type, tableName)];
       if (unique7) {
         conditions.push(eq(memoryTable.unique, true));
       }
@@ -1393,9 +1363,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
         worldId: roomTable.worldId,
         type: roomTable.type,
         source: roomTable.source
-      }).from(roomTable).where(
-        and(eq(roomTable.id, roomId), eq(roomTable.agentId, this.agentId))
-      ).limit(1);
+      }).from(roomTable).where(and(eq(roomTable.id, roomId), eq(roomTable.agentId, this.agentId))).limit(1);
       if (result.length === 0) return null;
       return result[0];
     });
@@ -1426,15 +1394,7 @@ 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
-  }) {
+  async createRoom({ id, name, source, type, channelId, serverId, worldId }) {
     return this.withDatabase(async () => {
       const newRoomId = id || v4();
       await this.db.insert(roomTable).values({
@@ -1470,12 +1430,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
    */
   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)
-        )
-      );
+      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);
     });
   }
@@ -1487,10 +1442,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
   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)
-        )
+        and(inArray(participantTable.entityId, entityIds), eq(roomTable.agentId, this.agentId))
       );
       return result.map((row) => row.roomId);
     });
@@ -1532,10 +1484,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       try {
         const result = await this.db.transaction(async (tx) => {
           return await tx.delete(participantTable).where(
-            and(
-              eq(participantTable.entityId, entityId),
-              eq(participantTable.roomId, roomId)
-            )
+            and(eq(participantTable.entityId, entityId), eq(participantTable.roomId, roomId))
           ).returning();
         });
         const removed = result.length > 0;
@@ -1585,10 +1534,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
   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)
-        )
+        and(eq(participantTable.roomId, roomId), eq(participantTable.agentId, this.agentId))
       );
       return result.map((row) => row.entityId);
     });
@@ -1754,9 +1700,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
         if (params.tags && params.tags.length > 0) {
           const tagParams = params.tags.map((tag) => `'${tag.replace(/'/g, "''")}'`).join(", ");
           query = query.where(
-            sql12`${relationshipTable.tags} @> ARRAY[${sql12.raw(
-              tagParams
-            )}]::text[]`
+            sql12`${relationshipTable.tags} @> ARRAY[${sql12.raw(tagParams)}]::text[]`
           );
         }
         const results = await query;
@@ -1786,9 +1730,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
   async getCache(key) {
     return this.withDatabase(async () => {
       try {
-        const result = await this.db.select().from(cacheTable).where(
-          and(eq(cacheTable.agentId, this.agentId), eq(cacheTable.key, key))
-        );
+        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", {
@@ -1841,12 +1783,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
     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)
-            )
-          );
+          await tx.delete(cacheTable).where(and(eq(cacheTable.agentId, this.agentId), eq(cacheTable.key, key)));
         });
         return true;
       } catch (error) {
@@ -1865,7 +1802,6 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
    * @returns {Promise<UUID>} A Promise that resolves to the ID of the created world.
    */
   async createWorld(world) {
-    console.trace("*** creating world", world, "with id", world.id);
     return this.withDatabase(async () => {
       const newWorldId = world.id || v4();
       await this.db.insert(worldTable).values({
@@ -1902,7 +1838,6 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
    * @returns {Promise<void>} A Promise that resolves when the world is updated.
    */
   async updateWorld(world) {
-    console.trace("*** updating world", world, "with id", world.id);
     return this.withDatabase(async () => {
       await this.db.update(worldTable).set(world).where(eq(worldTable.id, world.id));
     });
@@ -1958,9 +1893,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
         }
         if (params.tags && params.tags.length > 0) {
           const tagParams = params.tags.map((tag) => `'${tag.replace(/'/g, "''")}'`).join(", ");
-          query = query.where(
-            sql12`${taskTable.tags} @> ARRAY[${sql12.raw(tagParams)}]::text[]`
-          );
+          query = query.where(sql12`${taskTable.tags} @> ARRAY[${sql12.raw(tagParams)}]::text[]`);
         }
         const result = await query;
         return result.map((row) => ({
@@ -1983,9 +1916,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
   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))
-        );
+        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,
@@ -2034,8 +1965,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       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.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;
@@ -2055,9 +1985,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
             };
           }
         }
-        await this.db.update(taskTable).set(updateValues).where(
-          and(eq(taskTable.id, id), eq(taskTable.agentId, this.agentId))
-        );
+        await this.db.update(taskTable).set(updateValues).where(and(eq(taskTable.id, id), eq(taskTable.agentId, this.agentId)));
       });
     });
   }
@@ -2069,9 +1997,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
   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))
-        );
+        await this.db.delete(taskTable).where(and(eq(taskTable.id, id), eq(taskTable.agentId, this.agentId)));
       });
     });
   }
@@ -2175,7 +2101,7 @@ var PgDatabaseAdapter = class extends BaseDrizzleAdapter {
   async init() {
     try {
       await this.manager.runMigrations();
-      logger3.info("PgDatabaseAdapter initialized successfully");
+      logger3.debug("PgDatabaseAdapter initialized successfully");
     } catch (error) {
       logger3.error("Failed to initialize PgDatabaseAdapter:", error);
       throw error;
@@ -2224,9 +2150,9 @@ function createDatabaseAdapter(config, agentId) {
   return new PgliteDatabaseAdapter(agentId, globalSingletons.pgLiteClientManager);
 }
 __name(createDatabaseAdapter, "createDatabaseAdapter");
-var drizzlePlugin = {
-  name: "drizzle",
-  description: "Database adapter plugin using Drizzle ORM",
+var sqlPlugin = {
+  name: "sql",
+  description: "SQL database adapter plugin using Drizzle ORM",
   init: /* @__PURE__ */ __name(async (_, runtime) => {
     const config = {
       dataDir: runtime.getSetting("PGLITE_DATA_DIR") ?? "./pglite",
@@ -2242,7 +2168,7 @@ var drizzlePlugin = {
     }
   }, "init")
 };
-var index_default = drizzlePlugin;
+var index_default = sqlPlugin;
 export {
   createDatabaseAdapter,
   index_default as default