@elizaos/plugin-sql 1.6.5 → 1.7.0-beta.0

package/dist/node/index.node.js

@@ -5765,6 +5765,14 @@ var init_server = __esm(() => {
   });
 });
 
+// src/types.ts
+function getDb(adapter) {
+  return adapter.db;
+}
+function getRow(result, index2 = 0) {
+  return result.rows[index2];
+}
+
 // src/runtime-migrator/storage/migration-tracker.ts
 class MigrationTracker {
   db;
@@ -5804,12 +5812,12 @@ class MigrationTracker {
     `);
   }
   async getLastMigration(pluginName) {
-    const result = await this.db.execute(sql`SELECT id, hash, created_at 
-          FROM migrations._migrations 
-          WHERE plugin_name = ${pluginName} 
-          ORDER BY created_at DESC 
+    const result = await this.db.execute(sql`SELECT id, hash, created_at
+          FROM migrations._migrations
+          WHERE plugin_name = ${pluginName}
+          ORDER BY created_at DESC
           LIMIT 1`);
-    return result.rows[0] || null;
+    return getRow(result) || null;
   }
   async recordMigration(pluginName, hash, createdAt) {
     await this.db.execute(sql`INSERT INTO migrations._migrations (plugin_name, hash, created_at) 
@@ -5833,7 +5841,7 @@ class JournalStorage {
     if (result.rows.length === 0) {
       return null;
     }
-    const row = result.rows[0];
+    const row = getRow(result);
     return {
       version: row.version,
       dialect: row.dialect,
@@ -7488,48 +7496,15 @@ class RuntimeMigrator {
     return value >= MIN_BIGINT && value <= MAX_BIGINT;
   }
   isRealPostgresDatabase(connectionUrl) {
-    if (!connectionUrl || connectionUrl.trim() === "") {
+    if (!connectionUrl?.trim())
       return false;
-    }
-    const trimmedUrl = connectionUrl.trim();
-    const url = trimmedUrl.toLowerCase();
-    const originalUrl = trimmedUrl;
-    const nonPostgresSchemes = [
-      "mysql://",
-      "mysqli://",
-      "mariadb://",
-      "mongodb://",
-      "mongodb+srv://"
-    ];
-    for (const scheme of nonPostgresSchemes) {
-      if (url.startsWith(scheme)) {
-        return false;
-      }
-    }
-    const excludePatterns = [
-      ":memory:",
-      "pglite://",
-      "/pglite",
-      "sqlite://",
-      "sqlite3://",
-      ".sqlite",
-      ".sqlite3",
-      "file::memory:",
-      "file:"
-    ];
-    const urlWithoutQuery = url.split("?")[0];
-    if (urlWithoutQuery.endsWith(".db") || urlWithoutQuery.endsWith(".sqlite") || urlWithoutQuery.endsWith(".sqlite3")) {
+    const url = connectionUrl.trim().toLowerCase();
+    const nonPgSchemes = ["mysql://", "mysqli://", "mariadb://", "mongodb://", "mongodb+srv://"];
+    if (nonPgSchemes.some((s) => url.startsWith(s)))
       return false;
-    }
-    for (const pattern of excludePatterns) {
-      if (url.includes(pattern)) {
-        if (pattern === "file:" && url.includes("postgres")) {
-          continue;
-        }
-        return false;
-      }
-    }
-    const postgresSchemes = [
+    if (url.includes(":memory:"))
+      return false;
+    const pgSchemes = [
       "postgres://",
       "postgresql://",
       "postgis://",
@@ -7541,12 +7516,17 @@ class RuntimeMigrator {
       "timescaledb://",
       "yugabyte://"
     ];
-    for (const scheme of postgresSchemes) {
-      if (url.startsWith(scheme)) {
-        return true;
-      }
-    }
-    const connectionParams = [
+    if (pgSchemes.some((s) => url.startsWith(s)))
+      return true;
+    const excludePatterns = ["pglite", "sqlite"];
+    const urlBase = url.split("?")[0];
+    if (excludePatterns.some((p) => url.includes(p)))
+      return false;
+    if (/\.(db|sqlite|sqlite3)$/.test(urlBase))
+      return false;
+    if (url.includes("localhost") || url.includes("127.0.0.1"))
+      return true;
+    const connParams = [
       "host=",
       "dbname=",
       "sslmode=",
@@ -7558,126 +7538,60 @@ class RuntimeMigrator {
       "options=",
       "sslcert=",
       "sslkey=",
-      "sslrootcert="
+      "sslrootcert=",
+      "fallback_application_name=",
+      "keepalives=",
+      "target_session_attrs="
     ];
-    for (const param of connectionParams) {
-      if (url.includes(param)) {
-        return true;
-      }
-    }
-    if (url.includes("@") && (url.includes("postgres") || /:\d{4,5}/.test(url))) {
+    if (connParams.some((p) => url.includes(p)))
       return true;
-    }
-    const postgresPorts = [
-      ":5432",
-      ":5433",
-      ":5434",
-      ":25060",
-      ":26257",
-      ":6432",
-      ":9999",
-      ":8432"
-    ];
-    for (const port of postgresPorts) {
-      if (url.includes(port)) {
-        return true;
-      }
-    }
-    const cloudProviderPatterns = [
+    if (url.includes("@") && (url.includes("postgres") || /:\d{4,5}/.test(url)))
+      return true;
+    if (/:(5432|5433|5434|6432|8432|9999|25060|26257)\b/.test(url))
+      return true;
+    const cloudPatterns = [
       "amazonaws.com",
-      "rds.amazonaws.com",
       ".rds.",
-      "redshift.amazonaws.com",
       "azure.com",
       "database.azure.com",
-      "postgres.database.azure.com",
       "googleusercontent",
       "cloudsql",
-      "cloud.google.com",
       "supabase",
-      ".supabase.co",
-      ".supabase.com",
-      "pooler.supabase",
       "neon.tech",
-      ".neon.tech",
       "neon.build",
       "railway.app",
-      ".railway.app",
       "railway.internal",
       "render.com",
-      ".render.com",
       "onrender.com",
-      "heroku.com",
-      "herokuapp.com",
-      ".heroku.com",
+      "heroku",
       "timescale",
-      "timescaledb",
       ".tsdb.cloud",
       "cockroachlabs",
       "cockroachdb.cloud",
       ".crdb.io",
-      "digitalocean.com",
+      "digitalocean",
       "db.ondigitalocean",
       "do-user-",
-      ".db.ondigitalocean.com",
       "aiven",
-      "aivencloud",
-      ".aiven.io",
-      ".aivencloud.com",
       "crunchydata",
-      ".crunchydata.com",
       "elephantsql",
-      ".elephantsql.com",
       "yugabyte",
-      ".yugabyte.cloud",
       "scaleway",
       ".rdb.fr-par.scw.cloud",
       "vercel-storage",
-      ".postgres.vercel-storage.com",
       "psdb.cloud",
-      ".psdb.cloud",
       "xata.sh",
-      ".xata.sh",
       "fly.dev",
-      ".fly.dev",
       "fly.io"
     ];
-    for (const pattern of cloudProviderPatterns) {
-      if (url.includes(pattern)) {
-        return true;
-      }
-    }
-    const ipv4PortPattern = /\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}:\d{1,5}\b/;
-    if (ipv4PortPattern.test(originalUrl)) {
+    if (cloudPatterns.some((p) => url.includes(p)))
       return true;
-    }
-    const ipv6Pattern = /\[[0-9a-f:]+\](:\d{1,5})?/i;
-    if (ipv6Pattern.test(originalUrl)) {
+    if (/\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}:\d{1,5}/.test(url))
       return true;
-    }
-    const hostPortDbPattern = /^[a-z0-9.-]+:\d{1,5}\/[a-z0-9_-]+/i;
-    if (hostPortDbPattern.test(originalUrl)) {
+    if (/\[[0-9a-f:]+\](:\d{1,5})?/i.test(connectionUrl))
+      return true;
+    if (/^[a-z0-9_.-]+:\d{1,5}\/[a-z0-9_-]+/i.test(connectionUrl))
       return true;
-    }
-    if (url.includes("?") || url.includes("&")) {
-      const postgresQueryParams = [
-        "sslmode=",
-        "sslcert=",
-        "sslkey=",
-        "sslrootcert=",
-        "connect_timeout=",
-        "application_name=",
-        "options=",
-        "fallback_application_name=",
-        "keepalives=",
-        "target_session_attrs="
-      ];
-      for (const param of postgresQueryParams) {
-        if (url.includes(param)) {
-          return true;
-        }
-      }
-    }
     logger6.debug({ src: "plugin:sql", urlPreview: url.substring(0, 50) }, "Connection string did not match any PostgreSQL patterns");
     return false;
   }
@@ -7702,7 +7616,7 @@ class RuntimeMigrator {
           logger6.debug({ src: "plugin:sql", pluginName }, "Using PostgreSQL advisory locks");
           const lockIdStr = lockId.toString();
           const lockResult = await this.db.execute(sql`SELECT pg_try_advisory_lock(CAST(${lockIdStr} AS bigint)) as acquired`);
-          lockAcquired = lockResult.rows[0]?.acquired === true;
+          lockAcquired = getRow(lockResult)?.acquired === true;
           if (!lockAcquired) {
             logger6.info({ src: "plugin:sql", pluginName }, "Migration already in progress, waiting for lock");
             await this.db.execute(sql`SELECT pg_advisory_lock(CAST(${lockIdStr} AS bigint))`);
@@ -7743,13 +7657,33 @@ class RuntimeMigrator {
           logger6.info({ src: "plugin:sql", pluginName }, "No snapshot found but tables exist in database, introspecting");
           const schemaName = this.getExpectedSchemaName(pluginName);
           const introspectedSnapshot = await this.introspector.introspectSchema(schemaName);
-          if (Object.keys(introspectedSnapshot.tables).length > 0) {
-            await this.snapshotStorage.saveSnapshot(pluginName, 0, introspectedSnapshot);
+          const expectedTableNames = new Set;
+          for (const tableKey of Object.keys(currentSnapshot.tables)) {
+            const tableData = currentSnapshot.tables[tableKey];
+            const tableName = tableData.name || tableKey.split(".").pop();
+            expectedTableNames.add(tableName);
+          }
+          const filteredTables = {};
+          for (const tableKey of Object.keys(introspectedSnapshot.tables)) {
+            const tableData = introspectedSnapshot.tables[tableKey];
+            const tableName = tableData.name || tableKey.split(".").pop();
+            if (expectedTableNames.has(tableName)) {
+              filteredTables[tableKey] = tableData;
+            } else {
+              logger6.debug({ src: "plugin:sql", pluginName, tableName }, "Ignoring table from introspection (not in current schema)");
+            }
+          }
+          const filteredSnapshot = {
+            ...introspectedSnapshot,
+            tables: filteredTables
+          };
+          if (Object.keys(filteredSnapshot.tables).length > 0) {
+            await this.snapshotStorage.saveSnapshot(pluginName, 0, filteredSnapshot);
             await this.journalStorage.updateJournal(pluginName, 0, `introspected_${Date.now()}`, true);
-            const introspectedHash = hashSnapshot(introspectedSnapshot);
-            await this.migrationTracker.recordMigration(pluginName, introspectedHash, Date.now());
+            const filteredHash = hashSnapshot(filteredSnapshot);
+            await this.migrationTracker.recordMigration(pluginName, filteredHash, Date.now());
             logger6.info({ src: "plugin:sql", pluginName }, "Created initial snapshot from existing database");
-            previousSnapshot = introspectedSnapshot;
+            previousSnapshot = filteredSnapshot;
           }
         }
       }
@@ -7932,14 +7866,63 @@ var init_runtime_migrator2 = __esm(() => {
 // src/migrations.ts
 import { logger as logger7 } from "@elizaos/core";
 async function migrateToEntityRLS(adapter) {
-  const db2 = adapter.db;
+  const db2 = getDb(adapter);
   try {
     await db2.execute(sql`SELECT 1 FROM pg_tables LIMIT 1`);
   } catch {
     logger7.debug("[Migration] ⊘ Not PostgreSQL, skipping PostgreSQL-specific migrations");
     return;
   }
-  logger7.info("[Migration] Starting develop → feat/entity-rls migration...");
+  let schemaAlreadyMigrated = false;
+  try {
+    const migrationCheck = await db2.execute(sql`
+      SELECT column_name FROM information_schema.columns
+      WHERE table_schema = 'public'
+        AND table_name = 'rooms'
+        AND column_name = 'agent_id'
+    `);
+    if (migrationCheck.rows && migrationCheck.rows.length > 0) {
+      schemaAlreadyMigrated = true;
+      logger7.debug("[Migration] ⊘ Schema already migrated (snake_case columns exist)");
+    }
+  } catch {
+    logger7.debug("[Migration] → rooms table not found, will be created by RuntimeMigrator");
+    return;
+  }
+  if (schemaAlreadyMigrated) {
+    const dataIsolationEnabled = process.env.ENABLE_DATA_ISOLATION === "true";
+    if (dataIsolationEnabled) {
+      logger7.debug("[Migration] ⊘ Schema already migrated, RLS enabled - nothing to do");
+      return;
+    }
+    logger7.debug("[Migration] → Schema migrated but RLS disabled, cleaning up...");
+    try {
+      const tablesWithRls = await db2.execute(sql`
+        SELECT c.relname as tablename
+        FROM pg_class c
+        JOIN pg_namespace n ON n.oid = c.relnamespace
+        WHERE n.nspname = 'public'
+          AND c.relkind = 'r'
+          AND c.relrowsecurity = true
+        ORDER BY c.relname
+      `);
+      if (tablesWithRls.rows && tablesWithRls.rows.length > 0) {
+        for (const row of tablesWithRls.rows) {
+          const tableName = row.tablename;
+          try {
+            await db2.execute(sql.raw(`ALTER TABLE "${tableName}" DISABLE ROW LEVEL SECURITY`));
+          } catch {}
+        }
+        logger7.debug(`[Migration] ✓ RLS cleanup completed (${tablesWithRls.rows.length} tables)`);
+      } else {
+        logger7.debug("[Migration] ⊘ No tables with RLS to clean up");
+      }
+    } catch {
+      logger7.debug("[Migration] ⊘ Could not perform RLS cleanup");
+    }
+    return;
+  }
+  logger7.info("[Migration] Starting pre-1.6.5 → 1.6.5+ schema migration...");
   try {
     logger7.debug("[Migration] → Clearing RuntimeMigrator snapshot cache...");
     try {
@@ -7948,27 +7931,34 @@ async function migrateToEntityRLS(adapter) {
     } catch (error) {
       logger7.debug("[Migration] ⊘ No snapshot cache to clear (migrations schema not yet created)");
     }
-    logger7.debug("[Migration] → Disabling Row Level Security on all tables...");
+    logger7.debug("[Migration] → Checking for Row Level Security to disable...");
     try {
-      const tablesResult = await db2.execute(sql`
-        SELECT tablename
-        FROM pg_tables
-        WHERE schemaname = 'public'
-        ORDER BY tablename
+      const tablesWithRls = await db2.execute(sql`
+        SELECT c.relname as tablename
+        FROM pg_class c
+        JOIN pg_namespace n ON n.oid = c.relnamespace
+        WHERE n.nspname = 'public'
+          AND c.relkind = 'r'
+          AND c.relrowsecurity = true
+        ORDER BY c.relname
       `);
-      for (const row of tablesResult.rows || []) {
-        const tableName = row.tablename;
-        try {
-          await db2.execute(sql.raw(`ALTER TABLE "${tableName}" DISABLE ROW LEVEL SECURITY`));
-          logger7.debug(`[Migration] ✓ Disabled RLS on ${tableName}`);
-        } catch (error) {
-          logger7.debug(`[Migration] ⊘ Could not disable RLS on ${tableName}`);
+      if (tablesWithRls.rows && tablesWithRls.rows.length > 0) {
+        for (const row of tablesWithRls.rows) {
+          const tableName = row.tablename;
+          try {
+            await db2.execute(sql.raw(`ALTER TABLE "${tableName}" DISABLE ROW LEVEL SECURITY`));
+            logger7.debug(`[Migration] ✓ Disabled RLS on ${tableName}`);
+          } catch (error) {
+            logger7.debug(`[Migration] ⊘ Could not disable RLS on ${tableName}`);
+          }
         }
+      } else {
+        logger7.debug("[Migration] ⊘ No tables with RLS enabled");
       }
     } catch (error) {
-      logger7.debug("[Migration] ⊘ Could not disable RLS (may not have permissions)");
+      logger7.debug("[Migration] ⊘ Could not check RLS (may not have permissions)");
     }
-    logger7.debug("[Migration] → Handling server_id → message_server_id migrations...");
+    logger7.debug("[Migration] → Handling serverId/server_id → message_server_id migrations...");
     const tablesToMigrate = ["channels", "worlds", "rooms"];
     for (const tableName of tablesToMigrate) {
       try {
@@ -7977,34 +7967,49 @@ async function migrateToEntityRLS(adapter) {
           FROM information_schema.columns
           WHERE table_schema = 'public'
             AND table_name = ${tableName}
-            AND column_name IN ('server_id', 'message_server_id')
+            AND column_name IN ('server_id', 'serverId', 'message_server_id')
           ORDER BY column_name
         `);
         const columns2 = columnsResult.rows || [];
-        const serverId = columns2.find((c) => c.column_name === "server_id");
+        const serverIdSnake = columns2.find((c) => c.column_name === "server_id");
+        const serverIdCamel = columns2.find((c) => c.column_name === "serverId");
         const messageServerId = columns2.find((c) => c.column_name === "message_server_id");
+        const serverId = serverIdSnake || serverIdCamel;
+        const oldColumnName = serverIdSnake ? "server_id" : "serverId";
         if (serverId && !messageServerId) {
-          logger7.debug(`[Migration] → Renaming ${tableName}.server_id to message_server_id...`);
-          await db2.execute(sql.raw(`ALTER TABLE "${tableName}" RENAME COLUMN "server_id" TO "message_server_id"`));
-          logger7.debug(`[Migration] ✓ Renamed ${tableName}.server_id → message_server_id`);
+          logger7.debug(`[Migration] → Renaming ${tableName}.${oldColumnName} to message_server_id...`);
+          await db2.execute(sql.raw(`ALTER TABLE "${tableName}" RENAME COLUMN "${oldColumnName}" TO "message_server_id"`));
+          logger7.debug(`[Migration] ✓ Renamed ${tableName}.${oldColumnName} → message_server_id`);
           if (serverId.data_type === "text") {
             try {
               logger7.debug(`[Migration] → Dropping DEFAULT constraint on ${tableName}.message_server_id...`);
               await db2.execute(sql.raw(`ALTER TABLE "${tableName}" ALTER COLUMN "message_server_id" DROP DEFAULT`));
               logger7.debug(`[Migration] ✓ Dropped DEFAULT constraint`);
+            } catch {
+              logger7.debug(`[Migration] ⊘ No DEFAULT constraint to drop on ${tableName}.message_server_id`);
+            }
+            try {
               logger7.debug(`[Migration] → Converting ${tableName}.message_server_id from text to uuid...`);
-              await db2.execute(sql.raw(`ALTER TABLE "${tableName}" ALTER COLUMN "message_server_id" TYPE uuid USING "message_server_id"::uuid`));
+              await db2.execute(sql.raw(`
+                  ALTER TABLE "${tableName}"
+                  ALTER COLUMN "message_server_id" TYPE uuid
+                  USING CASE
+                    WHEN "message_server_id" IS NULL THEN NULL
+                    WHEN "message_server_id" = '' THEN NULL
+                    WHEN "message_server_id" ~ '^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$'
+                    THEN "message_server_id"::uuid
+                    ELSE md5("message_server_id")::uuid
+                  END
+                `));
               logger7.debug(`[Migration] ✓ Converted ${tableName}.message_server_id to uuid`);
             } catch (convertError) {
-              logger7.warn(`[Migration] ⚠️ Could not convert ${tableName}.message_server_id to uuid - data may not be valid UUIDs`);
-              logger7.debug(`[Migration] → Setting invalid UUIDs to NULL in ${tableName}.message_server_id...`);
-              await db2.execute(sql.raw(`ALTER TABLE "${tableName}" ALTER COLUMN "message_server_id" TYPE uuid USING CASE WHEN "message_server_id" ~ '^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$' THEN "message_server_id"::uuid ELSE NULL END`));
+              logger7.warn(`[Migration] ⚠️ Could not convert ${tableName}.message_server_id to uuid: ${convertError}`);
             }
           }
           if (tableName === "channels") {
             const nullCountResult = await db2.execute(sql.raw(`SELECT COUNT(*) as count FROM "${tableName}" WHERE "message_server_id" IS NULL`));
             const nullCount = nullCountResult.rows?.[0]?.count;
-            if (nullCount && parseInt(nullCount) > 0) {
+            if (nullCount && parseInt(nullCount, 10) > 0) {
               logger7.warn(`[Migration] ⚠️ ${tableName} has ${nullCount} rows with NULL message_server_id - these will be deleted`);
               await db2.execute(sql.raw(`DELETE FROM "${tableName}" WHERE "message_server_id" IS NULL`));
               logger7.debug(`[Migration] ✓ Deleted ${nullCount} rows with NULL message_server_id from ${tableName}`);
@@ -8014,9 +8019,9 @@ async function migrateToEntityRLS(adapter) {
             logger7.debug(`[Migration] ✓ Set ${tableName}.message_server_id NOT NULL`);
           }
         } else if (serverId && messageServerId) {
-          logger7.debug(`[Migration] → ${tableName} has both columns, dropping server_id...`);
-          await db2.execute(sql.raw(`ALTER TABLE "${tableName}" DROP COLUMN "server_id" CASCADE`));
-          logger7.debug(`[Migration] ✓ Dropped ${tableName}.server_id (will be re-added by RuntimeMigrator for RLS)`);
+          logger7.debug(`[Migration] → ${tableName} has both columns, dropping ${oldColumnName}...`);
+          await db2.execute(sql.raw(`ALTER TABLE "${tableName}" DROP COLUMN "${oldColumnName}" CASCADE`));
+          logger7.debug(`[Migration] ✓ Dropped ${tableName}.${oldColumnName}`);
         } else if (!serverId && messageServerId) {
           if (messageServerId.data_type === "text") {
             logger7.debug(`[Migration] → ${tableName}.message_server_id exists but is TEXT, needs UUID conversion...`);
@@ -8077,6 +8082,67 @@ async function migrateToEntityRLS(adapter) {
     } catch (error) {
       logger7.debug("[Migration] ⊘ Could not drop server_id columns (may not have permissions)");
     }
+    logger7.debug("[Migration] → Checking agents.owner_id → server_id rename...");
+    try {
+      const agentsColumnsResult = await db2.execute(sql`
+        SELECT column_name
+        FROM information_schema.columns
+        WHERE table_schema = 'public'
+          AND table_name = 'agents'
+          AND column_name IN ('owner_id', 'server_id')
+        ORDER BY column_name
+      `);
+      const agentsColumns = agentsColumnsResult.rows || [];
+      const hasOwnerId = agentsColumns.some((c) => c.column_name === "owner_id");
+      const hasServerId = agentsColumns.some((c) => c.column_name === "server_id");
+      if (hasOwnerId && !hasServerId) {
+        logger7.debug("[Migration] → Renaming agents.owner_id to server_id...");
+        await db2.execute(sql.raw(`ALTER TABLE "agents" RENAME COLUMN "owner_id" TO "server_id"`));
+        logger7.debug("[Migration] ✓ Renamed agents.owner_id → server_id");
+      } else if (hasOwnerId && hasServerId) {
+        logger7.debug("[Migration] → Both owner_id and server_id exist, dropping owner_id...");
+        await db2.execute(sql.raw(`ALTER TABLE "agents" DROP COLUMN "owner_id" CASCADE`));
+        logger7.debug("[Migration] ✓ Dropped agents.owner_id");
+      } else {
+        logger7.debug("[Migration] ⊘ agents table already has server_id (or no owner_id), skipping");
+      }
+    } catch (error) {
+      logger7.debug("[Migration] ⊘ Could not check/migrate agents.owner_id");
+    }
+    logger7.debug("[Migration] → Checking for owners → servers data migration...");
+    try {
+      const ownersTableResult = await db2.execute(sql`
+        SELECT table_name
+        FROM information_schema.tables
+        WHERE table_schema = 'public'
+          AND table_name = 'owners'
+      `);
+      if (ownersTableResult.rows && ownersTableResult.rows.length > 0) {
+        logger7.debug("[Migration] → Ensuring servers table exists...");
+        await db2.execute(sql.raw(`
+          CREATE TABLE IF NOT EXISTS "servers" (
+            "id" uuid PRIMARY KEY,
+            "created_at" timestamp with time zone DEFAULT now() NOT NULL,
+            "updated_at" timestamp with time zone DEFAULT now() NOT NULL
+          )
+        `));
+        logger7.debug("[Migration] → Migrating owners data to servers...");
+        await db2.execute(sql.raw(`
+          INSERT INTO "servers" ("id", "created_at", "updated_at")
+          SELECT "id", COALESCE("created_at", now()), COALESCE("updated_at", now())
+          FROM "owners"
+          ON CONFLICT ("id") DO NOTHING
+        `));
+        logger7.debug("[Migration] ✓ Migrated owners data to servers");
+        logger7.debug("[Migration] → Dropping obsolete owners table...");
+        await db2.execute(sql.raw(`DROP TABLE IF EXISTS "owners" CASCADE`));
+        logger7.debug("[Migration] ✓ Dropped obsolete owners table");
+      } else {
+        logger7.debug("[Migration] ⊘ owners table not found, skipping");
+      }
+    } catch (error) {
+      logger7.warn(`[Migration] ⚠️ Could not migrate owners → servers: ${error}`);
+    }
     logger7.debug("[Migration] → Checking server_agents table rename...");
     try {
       const tablesResult = await db2.execute(sql`
@@ -8181,7 +8247,87 @@ async function migrateToEntityRLS(adapter) {
     } catch (error) {
       logger7.debug("[Migration] ⊘ Could not drop indexes (may not have permissions)");
     }
-    logger7.info("[Migration] ✓ Migration complete - develop to feat/entity-rls migration finished");
+    logger7.debug("[Migration] → Starting camelCase → snake_case column renames...");
+    const columnRenames = [
+      { table: "rooms", from: "agentId", to: "agent_id" },
+      { table: "rooms", from: "worldId", to: "world_id" },
+      { table: "rooms", from: "channelId", to: "channel_id" },
+      { table: "rooms", from: "createdAt", to: "created_at" },
+      { table: "worlds", from: "agentId", to: "agent_id" },
+      { table: "worlds", from: "createdAt", to: "created_at" },
+      { table: "memories", from: "createdAt", to: "created_at" },
+      { table: "memories", from: "entityId", to: "entity_id" },
+      { table: "memories", from: "agentId", to: "agent_id" },
+      { table: "memories", from: "roomId", to: "room_id" },
+      { table: "memories", from: "worldId", to: "world_id" },
+      { table: "components", from: "entityId", to: "entity_id" },
+      { table: "components", from: "agentId", to: "agent_id" },
+      { table: "components", from: "roomId", to: "room_id" },
+      { table: "components", from: "worldId", to: "world_id" },
+      { table: "components", from: "sourceEntityId", to: "source_entity_id" },
+      { table: "components", from: "createdAt", to: "created_at" },
+      { table: "participants", from: "entityId", to: "entity_id" },
+      { table: "participants", from: "roomId", to: "room_id" },
+      { table: "participants", from: "agentId", to: "agent_id" },
+      { table: "participants", from: "roomState", to: "room_state" },
+      { table: "participants", from: "createdAt", to: "created_at" },
+      { table: "relationships", from: "sourceEntityId", to: "source_entity_id" },
+      { table: "relationships", from: "targetEntityId", to: "target_entity_id" },
+      { table: "relationships", from: "agentId", to: "agent_id" },
+      { table: "relationships", from: "createdAt", to: "created_at" },
+      { table: "logs", from: "entityId", to: "entity_id" },
+      { table: "logs", from: "roomId", to: "room_id" },
+      { table: "logs", from: "createdAt", to: "created_at" },
+      { table: "tasks", from: "roomId", to: "room_id" },
+      { table: "tasks", from: "worldId", to: "world_id" },
+      { table: "tasks", from: "entityId", to: "entity_id" },
+      { table: "tasks", from: "createdAt", to: "created_at" },
+      { table: "tasks", from: "updatedAt", to: "updated_at" },
+      { table: "agents", from: "createdAt", to: "created_at" },
+      { table: "agents", from: "updatedAt", to: "updated_at" },
+      { table: "entities", from: "agentId", to: "agent_id" },
+      { table: "entities", from: "createdAt", to: "created_at" },
+      { table: "embeddings", from: "memoryId", to: "memory_id" },
+      { table: "embeddings", from: "createdAt", to: "created_at" },
+      { table: "cache", from: "agentId", to: "agent_id" },
+      { table: "cache", from: "createdAt", to: "created_at" },
+      { table: "cache", from: "expiresAt", to: "expires_at" }
+    ];
+    for (const rename of columnRenames) {
+      try {
+        const tableExistsResult = await db2.execute(sql`
+          SELECT 1 FROM information_schema.tables
+          WHERE table_schema = 'public' AND table_name = ${rename.table}
+        `);
+        if (!tableExistsResult.rows || tableExistsResult.rows.length === 0) {
+          continue;
+        }
+        const columnsResult = await db2.execute(sql`
+          SELECT column_name
+          FROM information_schema.columns
+          WHERE table_schema = 'public'
+            AND table_name = ${rename.table}
+            AND column_name IN (${rename.from}, ${rename.to})
+          ORDER BY column_name
+        `);
+        const columns2 = columnsResult.rows || [];
+        const hasOldColumn = columns2.some((c) => c.column_name === rename.from);
+        const hasNewColumn = columns2.some((c) => c.column_name === rename.to);
+        if (hasOldColumn && !hasNewColumn) {
+          logger7.debug(`[Migration] → Renaming ${rename.table}.${rename.from} to ${rename.to}...`);
+          await db2.execute(sql.raw(`ALTER TABLE "${rename.table}" RENAME COLUMN "${rename.from}" TO "${rename.to}"`));
+          logger7.debug(`[Migration] ✓ Renamed ${rename.table}.${rename.from} → ${rename.to}`);
+        } else if (hasOldColumn && hasNewColumn) {
+          logger7.debug(`[Migration] → Both columns exist, dropping ${rename.table}.${rename.from}...`);
+          await db2.execute(sql.raw(`ALTER TABLE "${rename.table}" DROP COLUMN "${rename.from}" CASCADE`));
+          logger7.debug(`[Migration] ✓ Dropped ${rename.table}.${rename.from}`);
+        }
+      } catch (error) {
+        logger7.debug(`[Migration] ⊘ Could not process ${rename.table}.${rename.from}: ${error}`);
+      }
+    }
+    logger7.debug("[Migration] ✓ Completed camelCase → snake_case column renames");
+    logger7.info("[Migration] ✓ Migration complete - pre-1.6.5 → 1.6.5+ schema migration finished");
   } catch (error) {
     logger7.error("[Migration] Migration failed:", String(error));
     throw error;
@@ -8194,7 +8340,7 @@ var init_migrations = __esm(() => {
 // src/rls.ts
 import { logger as logger8, validateUuid } from "@elizaos/core";
 async function installRLSFunctions(adapter) {
-  const db2 = adapter.db;
+  const db2 = getDb(adapter);
   await db2.execute(sql`
     CREATE TABLE IF NOT EXISTS servers (
       id UUID PRIMARY KEY,
@@ -8310,7 +8456,7 @@ async function installRLSFunctions(adapter) {
   await installEntityRLS(adapter);
 }
 async function getOrCreateRlsServer(adapter, serverId) {
-  const db2 = adapter.db;
+  const db2 = getDb(adapter);
   await db2.insert(serverTable).values({
     id: serverId
   }).onConflictDoNothing();
@@ -8321,7 +8467,7 @@ async function setServerContext(adapter, serverId) {
   if (!validateUuid(serverId)) {
     throw new Error(`Invalid server ID format: ${serverId}. Must be a valid UUID.`);
   }
-  const db2 = adapter.db;
+  const db2 = getDb(adapter);
   const servers = await db2.select().from(serverTable).where(eq(serverTable.id, serverId));
   if (servers.length === 0) {
     throw new Error(`Server ${serverId} does not exist`);
@@ -8333,7 +8479,7 @@ async function assignAgentToServer(adapter, agentId, serverId) {
     logger8.warn(`[Data Isolation] Cannot assign agent to server: invalid agentId (${agentId}) or serverId (${serverId})`);
     return;
   }
-  const db2 = adapter.db;
+  const db2 = getDb(adapter);
   const agents = await db2.select().from(agentTable).where(eq(agentTable.id, agentId));
   if (agents.length > 0) {
     const agent = agents[0];
@@ -8353,7 +8499,7 @@ async function assignAgentToServer(adapter, agentId, serverId) {
   }
 }
 async function applyRLSToNewTables(adapter) {
-  const db2 = adapter.db;
+  const db2 = getDb(adapter);
   try {
     await db2.execute(sql`SELECT apply_rls_to_all_tables()`);
     logger8.info({ src: "plugin:sql" }, "RLS applied to all tables");
@@ -8362,7 +8508,7 @@ async function applyRLSToNewTables(adapter) {
   }
 }
 async function uninstallRLS(adapter) {
-  const db2 = adapter.db;
+  const db2 = getDb(adapter);
   try {
     const checkResult = await db2.execute(sql`
       SELECT EXISTS (
@@ -8436,7 +8582,7 @@ async function uninstallRLS(adapter) {
   }
 }
 async function installEntityRLS(adapter) {
-  const db2 = adapter.db;
+  const db2 = getDb(adapter);
   logger8.info("[Entity RLS] Installing entity RLS functions and policies...");
   await db2.execute(sql`
     CREATE OR REPLACE FUNCTION current_entity_id()
@@ -8477,26 +8623,26 @@ async function installEntityRLS(adapter) {
     BEGIN
       full_table_name := schema_name || '.' || table_name;
 
-      -- Check which columns exist (using camelCase as per schema definition)
+      -- Check which columns exist
       SELECT EXISTS (
         SELECT 1 FROM information_schema.columns
         WHERE information_schema.columns.table_schema = schema_name
           AND information_schema.columns.table_name = add_entity_isolation.table_name
-          AND information_schema.columns.column_name = 'entityId'
+          AND information_schema.columns.column_name = 'entity_id'
       ) INTO has_entity_id;
 
       SELECT EXISTS (
         SELECT 1 FROM information_schema.columns
         WHERE information_schema.columns.table_schema = schema_name
           AND information_schema.columns.table_name = add_entity_isolation.table_name
-          AND information_schema.columns.column_name = 'authorId'
+          AND information_schema.columns.column_name = 'author_id'
       ) INTO has_author_id;
 
       SELECT EXISTS (
         SELECT 1 FROM information_schema.columns
         WHERE information_schema.columns.table_schema = schema_name
           AND information_schema.columns.table_name = add_entity_isolation.table_name
-          AND information_schema.columns.column_name = 'roomId'
+          AND information_schema.columns.column_name = 'room_id'
       ) INTO has_room_id;
 
       -- Skip if no entity-related columns
@@ -8506,20 +8652,20 @@ async function installEntityRLS(adapter) {
       END IF;
 
       -- Determine which column to use for entity filtering
-      -- Priority: roomId (shared access via participants) > entityId/authorId (direct access)
+      -- Priority: room_id (shared access via participants) > entity_id/author_id (direct access)
       --
-      -- SPECIAL CASE: participants table must use direct entityId to avoid infinite recursion
+      -- SPECIAL CASE: participants table must use direct entity_id to avoid infinite recursion
       IF table_name = 'participants' AND has_entity_id THEN
-        entity_column_name := 'entityId';
+        entity_column_name := 'entity_id';
         room_column_name := NULL;
       ELSIF has_room_id THEN
-        room_column_name := 'roomId';
+        room_column_name := 'room_id';
         entity_column_name := NULL;
       ELSIF has_entity_id THEN
-        entity_column_name := 'entityId';
+        entity_column_name := 'entity_id';
         room_column_name := NULL;
       ELSIF has_author_id THEN
-        entity_column_name := 'authorId';
+        entity_column_name := 'author_id';
         room_column_name := NULL;
       ELSE
         entity_column_name := NULL;
@@ -8533,11 +8679,11 @@ async function installEntityRLS(adapter) {
       -- Drop existing entity policies if present
       EXECUTE format('DROP POLICY IF EXISTS entity_isolation_policy ON %I.%I', schema_name, table_name);
 
-      -- CASE 1: Table has roomId or channelId (shared access via participants)
+      -- CASE 1: Table has room_id (shared access via participants)
       IF room_column_name IS NOT NULL THEN
         -- Determine the corresponding column name in participants table
-        -- If the table has roomId, look for roomId in participants.roomId
-        -- participants table uses: entityId (for participant), roomId (for room)
+        -- If the table has room_id, look for room_id in participants.room_id
+        -- participants table uses: entity_id (for participant), room_id (for room)
         -- RESTRICTIVE: Must pass BOTH server RLS AND entity RLS (combined with AND)
 
         -- Build policy with or without NULL check based on require_entity parameter
@@ -8549,21 +8695,21 @@ async function installEntityRLS(adapter) {
             USING (
               current_entity_id() IS NOT NULL
               AND %I IN (
-                SELECT "roomId"
+                SELECT room_id
                 FROM participants
-                WHERE "entityId" = current_entity_id()
+                WHERE entity_id = current_entity_id()
               )
             )
             WITH CHECK (
               current_entity_id() IS NOT NULL
               AND %I IN (
-                SELECT "roomId"
+                SELECT room_id
                 FROM participants
-                WHERE "entityId" = current_entity_id()
+                WHERE entity_id = current_entity_id()
               )
             )
           ', schema_name, table_name, room_column_name, room_column_name);
-          RAISE NOTICE '[Entity RLS] Applied STRICT RESTRICTIVE to %.% (via % → participants.roomId, entity REQUIRED)', schema_name, table_name, room_column_name;
+          RAISE NOTICE '[Entity RLS] Applied STRICT RESTRICTIVE to %.% (via % → participants.room_id, entity REQUIRED)', schema_name, table_name, room_column_name;
         ELSE
           -- PERMISSIVE MODE: NULL entity_id allows system/admin access
           EXECUTE format('
@@ -8572,21 +8718,21 @@ async function installEntityRLS(adapter) {
             USING (
               current_entity_id() IS NULL
               OR %I IN (
-                SELECT "roomId"
+                SELECT room_id
                 FROM participants
-                WHERE "entityId" = current_entity_id()
+                WHERE entity_id = current_entity_id()
               )
             )
             WITH CHECK (
               current_entity_id() IS NULL
               OR %I IN (
-                SELECT "roomId"
+                SELECT room_id
                 FROM participants
-                WHERE "entityId" = current_entity_id()
+                WHERE entity_id = current_entity_id()
               )
             )
           ', schema_name, table_name, room_column_name, room_column_name);
-          RAISE NOTICE '[Entity RLS] Applied PERMISSIVE RESTRICTIVE to %.% (via % → participants.roomId, NULL allowed)', schema_name, table_name, room_column_name;
+          RAISE NOTICE '[Entity RLS] Applied PERMISSIVE RESTRICTIVE to %.% (via % → participants.room_id, NULL allowed)', schema_name, table_name, room_column_name;
         END IF;
 
       -- CASE 2: Table has direct entity_id or author_id column
@@ -8684,7 +8830,7 @@ async function installEntityRLS(adapter) {
   logger8.info("[Entity RLS] Entity RLS functions installed successfully");
 }
 async function applyEntityRLSToAllTables(adapter) {
-  const db2 = adapter.db;
+  const db2 = getDb(adapter);
   try {
     await db2.execute(sql`SELECT apply_entity_rls_to_all_tables()`);
     logger8.info("[Entity RLS] Applied entity RLS to all eligible tables");
@@ -8693,7 +8839,7 @@ async function applyEntityRLSToAllTables(adapter) {
   }
 }
 async function uninstallEntityRLS(adapter) {
-  const db2 = adapter.db;
+  const db2 = getDb(adapter);
   logger8.info("[Entity RLS] Removing entity RLS policies and functions...");
   try {
     const tablesResult = await db2.execute(sql`
@@ -8706,7 +8852,7 @@ async function uninstallEntityRLS(adapter) {
       const schemaName = row.schemaname;
       const tableName = row.tablename;
       try {
-        await db2.execute(sql.raw(`DROP POLICY IF EXISTS entity_isolation_policy ON ${schemaName}.${tableName}`));
+        await db2.execute(sql.raw(`DROP POLICY IF EXISTS entity_isolation_policy ON "${schemaName}"."${tableName}"`));
         logger8.debug(`[Entity RLS] Dropped entity_isolation_policy from ${schemaName}.${tableName}`);
       } catch (error) {
         logger8.debug(`[Entity RLS] No entity policy on ${schemaName}.${tableName}`);
@@ -8741,15 +8887,17 @@ class DatabaseMigrationService {
   constructor() {}
   async initializeWithDatabase(db2) {
     this.db = db2;
-    await migrateToEntityRLS({ db: db2 });
+    const adapterWrapper = { db: db2 };
+    await migrateToEntityRLS(adapterWrapper);
     this.migrator = new RuntimeMigrator(db2);
     await this.migrator.initialize();
     logger9.info({ src: "plugin:sql" }, "DatabaseMigrationService initialized");
   }
   discoverAndRegisterPluginSchemas(plugins) {
     for (const plugin of plugins) {
-      if (plugin.schema) {
-        this.registeredSchemas.set(plugin.name, plugin.schema);
+      const pluginWithSchema = plugin;
+      if (pluginWithSchema.schema) {
+        this.registeredSchemas.set(plugin.name, pluginWithSchema.schema);
       }
     }
     logger9.info({
@@ -8803,9 +8951,10 @@ class DatabaseMigrationService {
       if (dataIsolationEnabled) {
         try {
           logger9.info({ src: "plugin:sql" }, "Re-applying Row Level Security...");
-          await installRLSFunctions({ db: this.db });
-          await applyRLSToNewTables({ db: this.db });
-          await applyEntityRLSToAllTables({ db: this.db });
+          const adapterWrapper = { db: this.db };
+          await installRLSFunctions(adapterWrapper);
+          await applyRLSToNewTables(adapterWrapper);
+          await applyEntityRLSToAllTables(adapterWrapper);
           logger9.info({ src: "plugin:sql" }, "RLS re-applied successfully");
         } catch (rlsError) {
           const errorMsg = rlsError instanceof Error ? rlsError.message : String(rlsError);
@@ -9089,13 +9238,13 @@ init_pg_core();
 init_agent();
 var roomTable = pgTable("rooms", {
   id: uuid("id").notNull().primaryKey().default(sql`gen_random_uuid()`),
-  agentId: uuid("agentId").references(() => agentTable.id, {
+  agentId: uuid("agent_id").references(() => agentTable.id, {
     onDelete: "cascade"
   }),
   source: text("source").notNull(),
   type: text("type").notNull(),
   messageServerId: uuid("message_server_id"),
-  worldId: uuid("worldId"),
+  worldId: uuid("world_id"),
   name: text("name"),
   metadata: jsonb("metadata"),
   channelId: text("channel_id"),
@@ -9106,18 +9255,18 @@ var roomTable = pgTable("rooms", {
 var memoryTable = pgTable("memories", {
   id: uuid("id").primaryKey().notNull(),
   type: text("type").notNull(),
-  createdAt: timestamp("createdAt").default(sql`now()`).notNull(),
+  createdAt: timestamp("created_at").default(sql`now()`).notNull(),
   content: jsonb("content").notNull(),
-  entityId: uuid("entityId").references(() => entityTable.id, {
+  entityId: uuid("entity_id").references(() => entityTable.id, {
     onDelete: "cascade"
   }),
-  agentId: uuid("agentId").references(() => agentTable.id, {
+  agentId: uuid("agent_id").references(() => agentTable.id, {
     onDelete: "cascade"
   }).notNull(),
-  roomId: uuid("roomId").references(() => roomTable.id, {
+  roomId: uuid("room_id").references(() => roomTable.id, {
     onDelete: "cascade"
   }),
-  worldId: uuid("worldId"),
+  worldId: uuid("world_id"),
   unique: boolean("unique").default(true).notNull(),
   metadata: jsonb("metadata").default({}).notNull()
 }, (table3) => [
@@ -9236,7 +9385,7 @@ init_pg_core();
 init_agent();
 var worldTable = pgTable("worlds", {
   id: uuid("id").notNull().primaryKey().default(sql`gen_random_uuid()`),
-  agentId: uuid("agentId").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
+  agentId: uuid("agent_id").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
   name: text("name").notNull(),
   metadata: jsonb("metadata"),
   messageServerId: uuid("message_server_id"),
@@ -9246,14 +9395,16 @@ var worldTable = pgTable("worlds", {
 // src/schema/component.ts
 var componentTable = pgTable("components", {
   id: uuid("id").primaryKey().default(sql`gen_random_uuid()`).notNull(),
-  entityId: uuid("entityId").references(() => entityTable.id, { onDelete: "cascade" }).notNull(),
-  agentId: uuid("agentId").references(() => agentTable.id, { onDelete: "cascade" }).notNull(),
-  roomId: uuid("roomId").references(() => roomTable.id, { onDelete: "cascade" }).notNull(),
-  worldId: uuid("worldId").references(() => worldTable.id, { onDelete: "cascade" }),
-  sourceEntityId: uuid("sourceEntityId").references(() => entityTable.id, { onDelete: "cascade" }),
+  entityId: uuid("entity_id").references(() => entityTable.id, { onDelete: "cascade" }).notNull(),
+  agentId: uuid("agent_id").references(() => agentTable.id, { onDelete: "cascade" }).notNull(),
+  roomId: uuid("room_id").references(() => roomTable.id, { onDelete: "cascade" }).notNull(),
+  worldId: uuid("world_id").references(() => worldTable.id, { onDelete: "cascade" }),
+  sourceEntityId: uuid("source_entity_id").references(() => entityTable.id, {
+    onDelete: "cascade"
+  }),
   type: text("type").notNull(),
   data: jsonb("data").default(sql`'{}'::jsonb`),
-  createdAt: timestamp("createdAt").default(sql`now()`).notNull()
+  createdAt: timestamp("created_at").default(sql`now()`).notNull()
 });
 // src/schema/log.ts
 init_drizzle_orm();
@@ -9261,10 +9412,10 @@ init_pg_core();
 var logTable = pgTable("logs", {
   id: uuid("id").defaultRandom().notNull(),
   createdAt: timestamp("created_at", { withTimezone: true }).default(sql`now()`).notNull(),
-  entityId: uuid("entityId").notNull().references(() => entityTable.id, { onDelete: "cascade" }),
+  entityId: uuid("entity_id").notNull().references(() => entityTable.id, { onDelete: "cascade" }),
   body: jsonb("body").notNull(),
   type: text("type").notNull(),
-  roomId: uuid("roomId").notNull().references(() => roomTable.id, { onDelete: "cascade" })
+  roomId: uuid("room_id").notNull().references(() => roomTable.id, { onDelete: "cascade" })
 }, (table3) => [
   foreignKey({
     name: "fk_room",
@@ -9288,16 +9439,16 @@ init_agent();
 var participantTable = pgTable("participants", {
   id: uuid("id").notNull().primaryKey().default(sql`gen_random_uuid()`),
   createdAt: timestamp("created_at", { withTimezone: true }).default(sql`now()`).notNull(),
-  entityId: uuid("entityId").references(() => entityTable.id, {
+  entityId: uuid("entity_id").references(() => entityTable.id, {
     onDelete: "cascade"
   }),
-  roomId: uuid("roomId").references(() => roomTable.id, {
+  roomId: uuid("room_id").references(() => roomTable.id, {
     onDelete: "cascade"
   }),
-  agentId: uuid("agentId").references(() => agentTable.id, {
+  agentId: uuid("agent_id").references(() => agentTable.id, {
     onDelete: "cascade"
   }),
-  roomState: text("roomState")
+  roomState: text("room_state")
 }, (table3) => [
   index("idx_participants_user").on(table3.entityId),
   index("idx_participants_room").on(table3.roomId),
@@ -9319,9 +9470,9 @@ init_agent();
 var relationshipTable = pgTable("relationships", {
   id: uuid("id").notNull().primaryKey().default(sql`gen_random_uuid()`),
   createdAt: timestamp("created_at", { withTimezone: true }).default(sql`now()`).notNull(),
-  sourceEntityId: uuid("sourceEntityId").notNull().references(() => entityTable.id, { onDelete: "cascade" }),
-  targetEntityId: uuid("targetEntityId").notNull().references(() => entityTable.id, { onDelete: "cascade" }),
-  agentId: uuid("agentId").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
+  sourceEntityId: uuid("source_entity_id").notNull().references(() => entityTable.id, { onDelete: "cascade" }),
+  targetEntityId: uuid("target_entity_id").notNull().references(() => entityTable.id, { onDelete: "cascade" }),
+  agentId: uuid("agent_id").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
   tags: text("tags").array(),
   metadata: jsonb("metadata")
 }, (table3) => [
@@ -9346,10 +9497,10 @@ var taskTable = pgTable("tasks", {
   id: uuid("id").primaryKey().defaultRandom(),
   name: text("name").notNull(),
   description: text("description"),
-  roomId: uuid("roomId"),
-  worldId: uuid("worldId"),
-  entityId: uuid("entityId"),
-  agentId: uuid("agentId").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
+  roomId: uuid("room_id"),
+  worldId: uuid("world_id"),
+  entityId: uuid("entity_id"),
+  agentId: uuid("agent_id").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
   tags: text("tags").array().default(sql`'{}'::text[]`),
   metadata: jsonb("metadata").default(sql`'{}'::jsonb`),
   createdAt: timestamp("created_at", { withTimezone: true }).defaultNow(),
@@ -9497,7 +9648,11 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
     return this.withDatabase(async () => {
       const existingMemory = await this.db.select().from(memoryTable).innerJoin(embeddingTable, eq(embeddingTable.memoryId, memoryTable.id)).where(eq(memoryTable.agentId, this.agentId)).limit(1);
       if (existingMemory.length > 0) {
-        Object.entries(DIMENSION_MAP).find(([_, colName]) => existingMemory[0].embeddings[colName] !== null);
+        const joinedResult = existingMemory[0];
+        Object.entries(DIMENSION_MAP).find(([_, colName]) => {
+          const embeddingCol = colName;
+          return joinedResult.embeddings[embeddingCol] !== null;
+        });
       }
       this.embeddingDimension = DIMENSION_MAP[dimension];
     });
@@ -9636,7 +9791,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
       return output;
     };
     const finalSettings = deepMerge(currentSettings, updatedSettings);
-    return finalSettings === undefined ? {} : finalSettings;
+    return finalSettings ?? {};
   }
   async deleteAgent(agentId) {
     return this.withDatabase(async () => {
@@ -10203,6 +10358,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
         id: log.id,
         entityId: log.entityId,
         roomId: log.roomId,
+        type: log.type,
         body: log.body,
         createdAt: new Date(log.createdAt)
       }));
@@ -11015,7 +11171,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
     return this.withRetry(async () => {
       return this.withDatabase(async () => {
         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 ? [
-          sql`${taskTable.tags} @> ARRAY[${sql.raw(params.tags.map((t) => `'${t.replace(/'/g, "''")}'`).join(", "))}]::text[]`
+          sql`${taskTable.tags} @> ARRAY[${sql.join(params.tags.map((t) => sql`${t}`), sql`, `)}]::text[]`
         ] : []));
         return result.map((row) => ({
           id: row.id,
@@ -11079,11 +11235,14 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
           updateValues.worldId = task.worldId;
         if (task.tags !== undefined)
           updateValues.tags = task.tags;
-        updateValues.updatedAt = new Date;
+        const dbUpdateValues = {
+          ...updateValues,
+          updatedAt: new Date
+        };
         if (task.metadata !== undefined) {
-          updateValues.metadata = task.metadata;
+          dbUpdateValues.metadata = task.metadata;
         }
-        await this.db.update(taskTable).set(updateValues).where(and(eq(taskTable.id, id), eq(taskTable.agentId, this.agentId)));
+        await this.db.update(taskTable).set(dbUpdateValues).where(and(eq(taskTable.id, id), eq(taskTable.agentId, this.agentId)));
       });
     });
   }
@@ -11548,6 +11707,11 @@ class PGliteClientManager {
   async initialize() {}
   async close() {
     this.shuttingDown = true;
+    if (this.client) {
+      try {
+        await this.client.close();
+      } catch {}
+    }
   }
   setupShutdownHandlers() {}
 }
@@ -11935,9 +12099,6 @@ class PgDatabaseAdapter extends BaseDrizzleAdapter {
   getMemoryById(memoryId) {
     return super.getMemoryById(memoryId);
   }
-  searchMemories(params) {
-    return super.searchMemories(params);
-  }
   updateMemory(memory) {
     return super.updateMemory(memory);
   }
@@ -12000,21 +12161,18 @@ class PostgresConnectionManager {
     }
   }
   async withEntityContext(entityId, callback) {
+    const dataIsolationEnabled = process.env.ENABLE_DATA_ISOLATION === "true";
     return await this.db.transaction(async (tx) => {
-      if (entityId) {
+      if (dataIsolationEnabled && entityId) {
         try {
-          await tx.execute(sql.raw(`SET LOCAL app.entity_id = '${entityId}'`));
+          await tx.execute(sql`SET LOCAL app.entity_id = ${entityId}`);
           logger13.debug(`[Entity Context] Set app.entity_id = ${entityId}`);
         } catch (error) {
           const errorMessage = error instanceof Error ? error.message : String(error);
-          if (errorMessage.includes("unrecognized configuration parameter") || errorMessage.includes("app.entity_id")) {
-            logger13.debug("[Entity Context] Entity RLS not enabled, executing without entity context");
-          } else {
-            logger13.error({ error, entityId }, "[Entity Context] Critical error setting entity context - this may indicate a configuration issue");
-            logger13.warn("[Entity Context] Continuing without entity context due to error - data isolation may be compromised");
-          }
+          logger13.error({ error, entityId }, `[Entity Context] Failed to set entity context: ${errorMessage}`);
+          throw error;
         }
-      } else {
+      } else if (!dataIsolationEnabled) {} else {
         logger13.debug("[Entity Context] No entity context set (server operation)");
       }
       return await callback(tx);
@@ -12143,10 +12301,10 @@ var plugin = {
       return;
     }
     const postgresUrl = runtime.getSetting("POSTGRES_URL");
-    const dataDir = runtime.getSetting("PGLITE_DATA_DIR") || undefined;
+    const dataDir = runtime.getSetting("PGLITE_DATA_DIR");
     const dbAdapter = createDatabaseAdapter({
-      dataDir,
-      postgresUrl
+      dataDir: typeof dataDir === "string" ? dataDir : undefined,
+      postgresUrl: typeof postgresUrl === "string" ? postgresUrl : undefined
     }, runtime.agentId);
     runtime.registerDatabaseAdapter(dbAdapter);
     runtime.logger.info({ src: "plugin:sql", agentId: runtime.agentId }, "Database adapter created and registered");
@@ -12166,5 +12324,5 @@ export {
   DatabaseMigrationService
 };
 
-//# debugId=EA546D2333E8154064756E2164756E21
+//# debugId=D2C87E4D9A59EC5564756E2164756E21
 //# sourceMappingURL=index.node.js.map