@elizaos/plugin-sql 1.0.0-beta.4 → 1.0.0-beta.40

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

@@ -15,7 +15,8 @@ import { drizzle } from "drizzle-orm/pglite";
 // src/base.ts
 import {
   DatabaseAdapter,
-  logger
+  logger,
+  stringToUuid
 } from "@elizaos/core";
 import {
   and,
@@ -27,13 +28,15 @@ import {
   inArray,
   lte,
   or,
-  sql as sql12
+  sql as sql12,
+  not
 } 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 { VECTOR_DIMS } from "@elizaos/core";
 
 // src/schema/memory.ts
 import { relations, sql as sql5 } from "drizzle-orm";
@@ -131,7 +134,7 @@ var entityTable = pgTable2(
 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
+// src/schema/world.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", {
@@ -178,11 +181,15 @@ var memoryTable = pgTable5(
     roomId: uuid5("roomId").references(() => roomTable.id, {
       onDelete: "cascade"
     }),
+    worldId: uuid5("worldId").references(() => worldTable.id, {
+      onDelete: "set null"
+    }),
     unique: boolean2("unique").default(true).notNull(),
     metadata: jsonb5("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,8 +203,13 @@ var memoryTable = pgTable5(
     foreignKey({
       name: "fk_agent",
       columns: [table.agentId],
-      foreignColumns: [entityTable.id]
+      foreignColumns: [agentTable.id]
     }).onDelete("cascade"),
+    foreignKey({
+      name: "fk_world",
+      columns: [table.worldId],
+      foreignColumns: [worldTable.id]
+    }).onDelete("set null"),
     index("idx_memories_metadata_type").on(sql5`((metadata->>'type'))`),
     index("idx_memories_document_id").on(sql5`((metadata->>'documentId'))`),
     index("idx_fragments_order").on(
@@ -232,14 +244,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 +488,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 = stringToUuid(agent.name ?? v4());
+    await this.createAgent(agent);
+    return agent;
   }
   /**
    * Asynchronously ensures that the given embedding dimension is valid for the agent.
@@ -565,10 +572,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 +598,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 +638,166 @@ 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 newAgent = await tx.select({ newAgentId: agentTable.id }).from(agentTable).where(not(eq(agentTable.id, agentId))).limit(1);
+                if (newAgent.length > 0) {
+                  await tx.update(worldTable).set({ agentId: newAgent[0].newAgentId }).where(eq(worldTable.agentId, agentId));
+                } else {
+                  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 +849,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);
@@ -845,10 +1043,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 +1056,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));
       }
@@ -1128,18 +1327,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 +1355,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.
@@ -1170,6 +1377,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 +1399,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,18 +1420,28 @@ 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([
         {
@@ -1226,6 +1451,8 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
           metadata: sql12`${memory.metadata || {}}::jsonb`,
           entityId: memory.entityId,
           roomId: memory.roomId,
+          worldId: memory.worldId,
+          // Include worldId
           agentId: memory.agentId,
           unique: memory.unique ?? isUnique,
           createdAt: memory.createdAt
@@ -1447,6 +1674,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
   async createRoom({
     id,
     name,
+    agentId,
     source,
     type,
     channelId,
@@ -1459,7 +1687,7 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
       await this.db.insert(roomTable).values({
         id: newRoomId,
         name,
-        agentId: this.agentId,
+        agentId,
         source,
         type,
         channelId,