@elizaos/plugin-sql 1.0.0-beta.3 → 1.0.0-beta.33

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 Shaw Walters, aka Moon aka @lalalune
+Copyright (c) 2025 Shaw Walters and elizaOS Contributors
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/dist/index.js

@@ -34,6 +34,7 @@ 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 { VECTOR_DIMS } from "@elizaos/core";
 
 // src/schema/memory.ts
 import { relations, sql as sql5 } from "drizzle-orm";
@@ -232,14 +233,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",
@@ -484,9 +477,12 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
     const existingAgent = agents.find(
       (a) => a.name === agent.name
     );
-    if (!existingAgent) {
-      await this.createAgent(agent);
+    if (existingAgent) {
+      return existingAgent;
     }
+    agent.id = agent.id || v4();
+    await this.createAgent(agent);
+    return agent;
   }
   /**
    * Asynchronously ensures that the given embedding dimension is valid for the agent.
@@ -565,10 +561,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 +587,39 @@ 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);
+    if (currentAgent.length === 0 || !currentAgent[0].settings) {
+      return updatedSettings;
+    }
+    const currentSettings = currentAgent[0].settings;
+    if (updatedSettings.secrets) {
+      const currentSecrets = currentSettings.secrets || {};
+      const updatedSecrets = updatedSettings.secrets;
+      const mergedSecrets = { ...currentSecrets };
+      for (const [key, value] of Object.entries(updatedSecrets)) {
+        if (value === null) {
+          delete mergedSecrets[key];
+        } else {
+          mergedSecrets[key] = value;
+        }
+      }
+      updatedSettings.secrets = mergedSecrets;
+    }
+    return {
+      ...currentSettings,
+      ...updatedSettings
+    };
+  }
   /**
    * Asynchronously deletes an agent with the specified UUID and all related entries.
    *
@@ -595,11 +627,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;
+      }
     });
   }
   /**
@@ -651,7 +833,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(eq(entityTable.id, entityId));
       if (result.length === 0) return null;
       const entity = result[0].entity;
       entity.components = result.filter((row) => row.components).map((row) => row.components);
@@ -1205,6 +1387,14 @@ 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, {
@@ -1216,7 +1406,6 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       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([
         {
@@ -1447,6 +1636,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
   async createRoom({
     id,
     name,
+    agentId,
     source,
     type,
     channelId,
@@ -1459,7 +1649,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       await this.db.insert(roomTable).values({
         id: newRoomId,
         name,
-        agentId: this.agentId,
+        agentId,
         source,
         type,
         channelId,