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

package/dist/index.js

@@ -28,7 +28,8 @@ import {
   inArray,
   lte,
   or,
-  sql as sql12
+  sql as sql12,
+  not
 } from "drizzle-orm";
 import { v4 } from "uuid";
 
@@ -133,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", {
@@ -180,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],
@@ -200,6 +205,11 @@ var memoryTable = pgTable5(
       columns: [table.agentId],
       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(
@@ -752,10 +762,15 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
               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`);
+                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`);
               }
@@ -1028,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) {
@@ -1043,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));
       }
@@ -1311,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
     });
@@ -1333,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.
@@ -1353,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));
       }
@@ -1369,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,
@@ -1400,7 +1432,10 @@ var BaseDrizzleAdapter = class extends DatabaseAdapter {
     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
       });
@@ -1416,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