@elizaos/plugin-sql 1.6.5 → 1.7.0

package/dist/browser/index.browser.js

@@ -73,6 +73,14 @@ var init_server = __esm(() => {
   });
 });
 
+// src/types.ts
+function getDb(adapter) {
+  return adapter.db;
+}
+function getRow(result, index5 = 0) {
+  return result.rows[index5];
+}
+
 // src/runtime-migrator/storage/migration-tracker.ts
 import { sql as sql17 } from "drizzle-orm";
 
@@ -114,12 +122,12 @@ class MigrationTracker {
     `);
   }
   async getLastMigration(pluginName) {
-    const result = await this.db.execute(sql17`SELECT id, hash, created_at 
-          FROM migrations._migrations 
-          WHERE plugin_name = ${pluginName} 
-          ORDER BY created_at DESC 
+    const result = await this.db.execute(sql17`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(sql17`INSERT INTO migrations._migrations (plugin_name, hash, created_at) 
@@ -143,7 +151,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,
@@ -19881,48 +19889,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://",
@@ -19934,12 +19909,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=",
@@ -19951,126 +19931,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;
-        }
-      }
-    }
     logger5.debug({ src: "plugin:sql", urlPreview: url.substring(0, 50) }, "Connection string did not match any PostgreSQL patterns");
     return false;
   }
@@ -20095,7 +20009,7 @@ class RuntimeMigrator {
           logger5.debug({ src: "plugin:sql", pluginName }, "Using PostgreSQL advisory locks");
           const lockIdStr = lockId.toString();
           const lockResult = await this.db.execute(sql22`SELECT pg_try_advisory_lock(CAST(${lockIdStr} AS bigint)) as acquired`);
-          lockAcquired = lockResult.rows[0]?.acquired === true;
+          lockAcquired = getRow(lockResult)?.acquired === true;
           if (!lockAcquired) {
             logger5.info({ src: "plugin:sql", pluginName }, "Migration already in progress, waiting for lock");
             await this.db.execute(sql22`SELECT pg_advisory_lock(CAST(${lockIdStr} AS bigint))`);
@@ -20136,13 +20050,33 @@ class RuntimeMigrator {
           logger5.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 {
+              logger5.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());
             logger5.info({ src: "plugin:sql", pluginName }, "Created initial snapshot from existing database");
-            previousSnapshot = introspectedSnapshot;
+            previousSnapshot = filteredSnapshot;
           }
         }
       }
@@ -20326,14 +20260,63 @@ var init_runtime_migrator2 = __esm(() => {
 import { logger as logger6 } from "@elizaos/core";
 import { sql as sql23 } from "drizzle-orm";
 async function migrateToEntityRLS(adapter) {
-  const db = adapter.db;
+  const db = getDb(adapter);
   try {
     await db.execute(sql23`SELECT 1 FROM pg_tables LIMIT 1`);
   } catch {
     logger6.debug("[Migration] ⊘ Not PostgreSQL, skipping PostgreSQL-specific migrations");
     return;
   }
-  logger6.info("[Migration] Starting develop → feat/entity-rls migration...");
+  let schemaAlreadyMigrated = false;
+  try {
+    const migrationCheck = await db.execute(sql23`
+      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;
+      logger6.debug("[Migration] ⊘ Schema already migrated (snake_case columns exist)");
+    }
+  } catch {
+    logger6.debug("[Migration] → rooms table not found, will be created by RuntimeMigrator");
+    return;
+  }
+  if (schemaAlreadyMigrated) {
+    const dataIsolationEnabled = process.env.ENABLE_DATA_ISOLATION === "true";
+    if (dataIsolationEnabled) {
+      logger6.debug("[Migration] ⊘ Schema already migrated, RLS enabled - nothing to do");
+      return;
+    }
+    logger6.debug("[Migration] → Schema migrated but RLS disabled, cleaning up...");
+    try {
+      const tablesWithRls = await db.execute(sql23`
+        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 db.execute(sql23.raw(`ALTER TABLE "${tableName}" DISABLE ROW LEVEL SECURITY`));
+          } catch {}
+        }
+        logger6.debug(`[Migration] ✓ RLS cleanup completed (${tablesWithRls.rows.length} tables)`);
+      } else {
+        logger6.debug("[Migration] ⊘ No tables with RLS to clean up");
+      }
+    } catch {
+      logger6.debug("[Migration] ⊘ Could not perform RLS cleanup");
+    }
+    return;
+  }
+  logger6.info("[Migration] Starting pre-1.6.5 → 1.6.5+ schema migration...");
   try {
     logger6.debug("[Migration] → Clearing RuntimeMigrator snapshot cache...");
     try {
@@ -20342,27 +20325,34 @@ async function migrateToEntityRLS(adapter) {
     } catch (error) {
       logger6.debug("[Migration] ⊘ No snapshot cache to clear (migrations schema not yet created)");
     }
-    logger6.debug("[Migration] → Disabling Row Level Security on all tables...");
+    logger6.debug("[Migration] → Checking for Row Level Security to disable...");
     try {
-      const tablesResult = await db.execute(sql23`
-        SELECT tablename
-        FROM pg_tables
-        WHERE schemaname = 'public'
-        ORDER BY tablename
+      const tablesWithRls = await db.execute(sql23`
+        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 db.execute(sql23.raw(`ALTER TABLE "${tableName}" DISABLE ROW LEVEL SECURITY`));
-          logger6.debug(`[Migration] ✓ Disabled RLS on ${tableName}`);
-        } catch (error) {
-          logger6.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 db.execute(sql23.raw(`ALTER TABLE "${tableName}" DISABLE ROW LEVEL SECURITY`));
+            logger6.debug(`[Migration] ✓ Disabled RLS on ${tableName}`);
+          } catch (error) {
+            logger6.debug(`[Migration] ⊘ Could not disable RLS on ${tableName}`);
+          }
         }
+      } else {
+        logger6.debug("[Migration] ⊘ No tables with RLS enabled");
       }
     } catch (error) {
-      logger6.debug("[Migration] ⊘ Could not disable RLS (may not have permissions)");
+      logger6.debug("[Migration] ⊘ Could not check RLS (may not have permissions)");
     }
-    logger6.debug("[Migration] → Handling server_id → message_server_id migrations...");
+    logger6.debug("[Migration] → Handling serverId/server_id → message_server_id migrations...");
     const tablesToMigrate = ["channels", "worlds", "rooms"];
     for (const tableName of tablesToMigrate) {
       try {
@@ -20371,34 +20361,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 columns = columnsResult.rows || [];
-        const serverId = columns.find((c) => c.column_name === "server_id");
+        const serverIdSnake = columns.find((c) => c.column_name === "server_id");
+        const serverIdCamel = columns.find((c) => c.column_name === "serverId");
         const messageServerId = columns.find((c) => c.column_name === "message_server_id");
+        const serverId = serverIdSnake || serverIdCamel;
+        const oldColumnName = serverIdSnake ? "server_id" : "serverId";
         if (serverId && !messageServerId) {
-          logger6.debug(`[Migration] → Renaming ${tableName}.server_id to message_server_id...`);
-          await db.execute(sql23.raw(`ALTER TABLE "${tableName}" RENAME COLUMN "server_id" TO "message_server_id"`));
-          logger6.debug(`[Migration] ✓ Renamed ${tableName}.server_id → message_server_id`);
+          logger6.debug(`[Migration] → Renaming ${tableName}.${oldColumnName} to message_server_id...`);
+          await db.execute(sql23.raw(`ALTER TABLE "${tableName}" RENAME COLUMN "${oldColumnName}" TO "message_server_id"`));
+          logger6.debug(`[Migration] ✓ Renamed ${tableName}.${oldColumnName} → message_server_id`);
           if (serverId.data_type === "text") {
             try {
               logger6.debug(`[Migration] → Dropping DEFAULT constraint on ${tableName}.message_server_id...`);
               await db.execute(sql23.raw(`ALTER TABLE "${tableName}" ALTER COLUMN "message_server_id" DROP DEFAULT`));
               logger6.debug(`[Migration] ✓ Dropped DEFAULT constraint`);
+            } catch {
+              logger6.debug(`[Migration] ⊘ No DEFAULT constraint to drop on ${tableName}.message_server_id`);
+            }
+            try {
               logger6.debug(`[Migration] → Converting ${tableName}.message_server_id from text to uuid...`);
-              await db.execute(sql23.raw(`ALTER TABLE "${tableName}" ALTER COLUMN "message_server_id" TYPE uuid USING "message_server_id"::uuid`));
+              await db.execute(sql23.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
+                `));
               logger6.debug(`[Migration] ✓ Converted ${tableName}.message_server_id to uuid`);
             } catch (convertError) {
-              logger6.warn(`[Migration] ⚠️ Could not convert ${tableName}.message_server_id to uuid - data may not be valid UUIDs`);
-              logger6.debug(`[Migration] → Setting invalid UUIDs to NULL in ${tableName}.message_server_id...`);
-              await db.execute(sql23.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`));
+              logger6.warn(`[Migration] ⚠️ Could not convert ${tableName}.message_server_id to uuid: ${convertError}`);
             }
           }
           if (tableName === "channels") {
             const nullCountResult = await db.execute(sql23.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) {
               logger6.warn(`[Migration] ⚠️ ${tableName} has ${nullCount} rows with NULL message_server_id - these will be deleted`);
               await db.execute(sql23.raw(`DELETE FROM "${tableName}" WHERE "message_server_id" IS NULL`));
               logger6.debug(`[Migration] ✓ Deleted ${nullCount} rows with NULL message_server_id from ${tableName}`);
@@ -20408,9 +20413,9 @@ async function migrateToEntityRLS(adapter) {
             logger6.debug(`[Migration] ✓ Set ${tableName}.message_server_id NOT NULL`);
           }
         } else if (serverId && messageServerId) {
-          logger6.debug(`[Migration] → ${tableName} has both columns, dropping server_id...`);
-          await db.execute(sql23.raw(`ALTER TABLE "${tableName}" DROP COLUMN "server_id" CASCADE`));
-          logger6.debug(`[Migration] ✓ Dropped ${tableName}.server_id (will be re-added by RuntimeMigrator for RLS)`);
+          logger6.debug(`[Migration] → ${tableName} has both columns, dropping ${oldColumnName}...`);
+          await db.execute(sql23.raw(`ALTER TABLE "${tableName}" DROP COLUMN "${oldColumnName}" CASCADE`));
+          logger6.debug(`[Migration] ✓ Dropped ${tableName}.${oldColumnName}`);
         } else if (!serverId && messageServerId) {
           if (messageServerId.data_type === "text") {
             logger6.debug(`[Migration] → ${tableName}.message_server_id exists but is TEXT, needs UUID conversion...`);
@@ -20471,6 +20476,67 @@ async function migrateToEntityRLS(adapter) {
     } catch (error) {
       logger6.debug("[Migration] ⊘ Could not drop server_id columns (may not have permissions)");
     }
+    logger6.debug("[Migration] → Checking agents.owner_id → server_id rename...");
+    try {
+      const agentsColumnsResult = await db.execute(sql23`
+        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) {
+        logger6.debug("[Migration] → Renaming agents.owner_id to server_id...");
+        await db.execute(sql23.raw(`ALTER TABLE "agents" RENAME COLUMN "owner_id" TO "server_id"`));
+        logger6.debug("[Migration] ✓ Renamed agents.owner_id → server_id");
+      } else if (hasOwnerId && hasServerId) {
+        logger6.debug("[Migration] → Both owner_id and server_id exist, dropping owner_id...");
+        await db.execute(sql23.raw(`ALTER TABLE "agents" DROP COLUMN "owner_id" CASCADE`));
+        logger6.debug("[Migration] ✓ Dropped agents.owner_id");
+      } else {
+        logger6.debug("[Migration] ⊘ agents table already has server_id (or no owner_id), skipping");
+      }
+    } catch (error) {
+      logger6.debug("[Migration] ⊘ Could not check/migrate agents.owner_id");
+    }
+    logger6.debug("[Migration] → Checking for owners → servers data migration...");
+    try {
+      const ownersTableResult = await db.execute(sql23`
+        SELECT table_name
+        FROM information_schema.tables
+        WHERE table_schema = 'public'
+          AND table_name = 'owners'
+      `);
+      if (ownersTableResult.rows && ownersTableResult.rows.length > 0) {
+        logger6.debug("[Migration] → Ensuring servers table exists...");
+        await db.execute(sql23.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
+          )
+        `));
+        logger6.debug("[Migration] → Migrating owners data to servers...");
+        await db.execute(sql23.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
+        `));
+        logger6.debug("[Migration] ✓ Migrated owners data to servers");
+        logger6.debug("[Migration] → Dropping obsolete owners table...");
+        await db.execute(sql23.raw(`DROP TABLE IF EXISTS "owners" CASCADE`));
+        logger6.debug("[Migration] ✓ Dropped obsolete owners table");
+      } else {
+        logger6.debug("[Migration] ⊘ owners table not found, skipping");
+      }
+    } catch (error) {
+      logger6.warn(`[Migration] ⚠️ Could not migrate owners → servers: ${error}`);
+    }
     logger6.debug("[Migration] → Checking server_agents table rename...");
     try {
       const tablesResult = await db.execute(sql23`
@@ -20575,7 +20641,87 @@ async function migrateToEntityRLS(adapter) {
     } catch (error) {
       logger6.debug("[Migration] ⊘ Could not drop indexes (may not have permissions)");
     }
-    logger6.info("[Migration] ✓ Migration complete - develop to feat/entity-rls migration finished");
+    logger6.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 db.execute(sql23`
+          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 db.execute(sql23`
+          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 columns = columnsResult.rows || [];
+        const hasOldColumn = columns.some((c) => c.column_name === rename.from);
+        const hasNewColumn = columns.some((c) => c.column_name === rename.to);
+        if (hasOldColumn && !hasNewColumn) {
+          logger6.debug(`[Migration] → Renaming ${rename.table}.${rename.from} to ${rename.to}...`);
+          await db.execute(sql23.raw(`ALTER TABLE "${rename.table}" RENAME COLUMN "${rename.from}" TO "${rename.to}"`));
+          logger6.debug(`[Migration] ✓ Renamed ${rename.table}.${rename.from} → ${rename.to}`);
+        } else if (hasOldColumn && hasNewColumn) {
+          logger6.debug(`[Migration] → Both columns exist, dropping ${rename.table}.${rename.from}...`);
+          await db.execute(sql23.raw(`ALTER TABLE "${rename.table}" DROP COLUMN "${rename.from}" CASCADE`));
+          logger6.debug(`[Migration] ✓ Dropped ${rename.table}.${rename.from}`);
+        }
+      } catch (error) {
+        logger6.debug(`[Migration] ⊘ Could not process ${rename.table}.${rename.from}: ${error}`);
+      }
+    }
+    logger6.debug("[Migration] ✓ Completed camelCase → snake_case column renames");
+    logger6.info("[Migration] ✓ Migration complete - pre-1.6.5 → 1.6.5+ schema migration finished");
   } catch (error) {
     logger6.error("[Migration] Migration failed:", String(error));
     throw error;
@@ -20587,7 +20733,7 @@ var init_migrations = () => {};
 import { logger as logger7, validateUuid } from "@elizaos/core";
 import { sql as sql24, eq } from "drizzle-orm";
 async function installRLSFunctions(adapter) {
-  const db = adapter.db;
+  const db = getDb(adapter);
   await db.execute(sql24`
     CREATE TABLE IF NOT EXISTS servers (
       id UUID PRIMARY KEY,
@@ -20703,7 +20849,7 @@ async function installRLSFunctions(adapter) {
   await installEntityRLS(adapter);
 }
 async function applyRLSToNewTables(adapter) {
-  const db = adapter.db;
+  const db = getDb(adapter);
   try {
     await db.execute(sql24`SELECT apply_rls_to_all_tables()`);
     logger7.info({ src: "plugin:sql" }, "RLS applied to all tables");
@@ -20712,7 +20858,7 @@ async function applyRLSToNewTables(adapter) {
   }
 }
 async function installEntityRLS(adapter) {
-  const db = adapter.db;
+  const db = getDb(adapter);
   logger7.info("[Entity RLS] Installing entity RLS functions and policies...");
   await db.execute(sql24`
     CREATE OR REPLACE FUNCTION current_entity_id()
@@ -20753,26 +20899,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
@@ -20782,20 +20928,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;
@@ -20809,11 +20955,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
@@ -20825,21 +20971,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('
@@ -20848,21 +20994,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
@@ -20960,7 +21106,7 @@ async function installEntityRLS(adapter) {
   logger7.info("[Entity RLS] Entity RLS functions installed successfully");
 }
 async function applyEntityRLSToAllTables(adapter) {
-  const db = adapter.db;
+  const db = getDb(adapter);
   try {
     await db.execute(sql24`SELECT apply_entity_rls_to_all_tables()`);
     logger7.info("[Entity RLS] Applied entity RLS to all eligible tables");
@@ -20984,15 +21130,17 @@ class DatabaseMigrationService {
   constructor() {}
   async initializeWithDatabase(db) {
     this.db = db;
-    await migrateToEntityRLS({ db });
+    const adapterWrapper = { db };
+    await migrateToEntityRLS(adapterWrapper);
     this.migrator = new RuntimeMigrator(db);
     await this.migrator.initialize();
     logger8.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);
       }
     }
     logger8.info({
@@ -21046,9 +21194,10 @@ class DatabaseMigrationService {
       if (dataIsolationEnabled) {
         try {
           logger8.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);
           logger8.info({ src: "plugin:sql" }, "RLS re-applied successfully");
         } catch (rlsError) {
           const errorMsg = rlsError instanceof Error ? rlsError.message : String(rlsError);
@@ -21202,13 +21351,13 @@ import { sql as sql3 } from "drizzle-orm";
 import { jsonb as jsonb3, pgTable as pgTable3, text as text3, timestamp as timestamp3, uuid as uuid3 } from "drizzle-orm/pg-core";
 var roomTable = pgTable3("rooms", {
   id: uuid3("id").notNull().primaryKey().default(sql3`gen_random_uuid()`),
-  agentId: uuid3("agentId").references(() => agentTable.id, {
+  agentId: uuid3("agent_id").references(() => agentTable.id, {
     onDelete: "cascade"
   }),
   source: text3("source").notNull(),
   type: text3("type").notNull(),
   messageServerId: uuid3("message_server_id"),
-  worldId: uuid3("worldId"),
+  worldId: uuid3("world_id"),
   name: text3("name"),
   metadata: jsonb3("metadata"),
   channelId: text3("channel_id"),
@@ -21219,18 +21368,18 @@ var roomTable = pgTable3("rooms", {
 var memoryTable = pgTable4("memories", {
   id: uuid4("id").primaryKey().notNull(),
   type: text4("type").notNull(),
-  createdAt: timestamp4("createdAt").default(sql4`now()`).notNull(),
+  createdAt: timestamp4("created_at").default(sql4`now()`).notNull(),
   content: jsonb4("content").notNull(),
-  entityId: uuid4("entityId").references(() => entityTable.id, {
+  entityId: uuid4("entity_id").references(() => entityTable.id, {
     onDelete: "cascade"
   }),
-  agentId: uuid4("agentId").references(() => agentTable.id, {
+  agentId: uuid4("agent_id").references(() => agentTable.id, {
     onDelete: "cascade"
   }).notNull(),
-  roomId: uuid4("roomId").references(() => roomTable.id, {
+  roomId: uuid4("room_id").references(() => roomTable.id, {
     onDelete: "cascade"
   }),
-  worldId: uuid4("worldId"),
+  worldId: uuid4("world_id"),
   unique: boolean2("unique").default(true).notNull(),
   metadata: jsonb4("metadata").default({}).notNull()
 }, (table) => [
@@ -21349,7 +21498,7 @@ import { sql as sql7 } from "drizzle-orm";
 import { jsonb as jsonb6, pgTable as pgTable7, text as text6, timestamp as timestamp7, uuid as uuid7 } from "drizzle-orm/pg-core";
 var worldTable = pgTable7("worlds", {
   id: uuid7("id").notNull().primaryKey().default(sql7`gen_random_uuid()`),
-  agentId: uuid7("agentId").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
+  agentId: uuid7("agent_id").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
   name: text6("name").notNull(),
   metadata: jsonb6("metadata"),
   messageServerId: uuid7("message_server_id"),
@@ -21359,14 +21508,16 @@ var worldTable = pgTable7("worlds", {
 // src/schema/component.ts
 var componentTable = pgTable8("components", {
   id: uuid8("id").primaryKey().default(sql8`gen_random_uuid()`).notNull(),
-  entityId: uuid8("entityId").references(() => entityTable.id, { onDelete: "cascade" }).notNull(),
-  agentId: uuid8("agentId").references(() => agentTable.id, { onDelete: "cascade" }).notNull(),
-  roomId: uuid8("roomId").references(() => roomTable.id, { onDelete: "cascade" }).notNull(),
-  worldId: uuid8("worldId").references(() => worldTable.id, { onDelete: "cascade" }),
-  sourceEntityId: uuid8("sourceEntityId").references(() => entityTable.id, { onDelete: "cascade" }),
+  entityId: uuid8("entity_id").references(() => entityTable.id, { onDelete: "cascade" }).notNull(),
+  agentId: uuid8("agent_id").references(() => agentTable.id, { onDelete: "cascade" }).notNull(),
+  roomId: uuid8("room_id").references(() => roomTable.id, { onDelete: "cascade" }).notNull(),
+  worldId: uuid8("world_id").references(() => worldTable.id, { onDelete: "cascade" }),
+  sourceEntityId: uuid8("source_entity_id").references(() => entityTable.id, {
+    onDelete: "cascade"
+  }),
   type: text7("type").notNull(),
   data: jsonb7("data").default(sql8`'{}'::jsonb`),
-  createdAt: timestamp8("createdAt").default(sql8`now()`).notNull()
+  createdAt: timestamp8("created_at").default(sql8`now()`).notNull()
 });
 // src/schema/log.ts
 import { sql as sql9 } from "drizzle-orm";
@@ -21374,10 +21525,10 @@ import { foreignKey as foreignKey3, jsonb as jsonb8, pgTable as pgTable9, text a
 var logTable = pgTable9("logs", {
   id: uuid9("id").defaultRandom().notNull(),
   createdAt: timestamp9("created_at", { withTimezone: true }).default(sql9`now()`).notNull(),
-  entityId: uuid9("entityId").notNull().references(() => entityTable.id, { onDelete: "cascade" }),
+  entityId: uuid9("entity_id").notNull().references(() => entityTable.id, { onDelete: "cascade" }),
   body: jsonb8("body").notNull(),
   type: text8("type").notNull(),
-  roomId: uuid9("roomId").notNull().references(() => roomTable.id, { onDelete: "cascade" })
+  roomId: uuid9("room_id").notNull().references(() => roomTable.id, { onDelete: "cascade" })
 }, (table) => [
   foreignKey3({
     name: "fk_room",
@@ -21401,16 +21552,16 @@ import { foreignKey as foreignKey4, index as index3, pgTable as pgTable11, text
 var participantTable = pgTable11("participants", {
   id: uuid11("id").notNull().primaryKey().default(sql11`gen_random_uuid()`),
   createdAt: timestamp11("created_at", { withTimezone: true }).default(sql11`now()`).notNull(),
-  entityId: uuid11("entityId").references(() => entityTable.id, {
+  entityId: uuid11("entity_id").references(() => entityTable.id, {
     onDelete: "cascade"
   }),
-  roomId: uuid11("roomId").references(() => roomTable.id, {
+  roomId: uuid11("room_id").references(() => roomTable.id, {
     onDelete: "cascade"
   }),
-  agentId: uuid11("agentId").references(() => agentTable.id, {
+  agentId: uuid11("agent_id").references(() => agentTable.id, {
     onDelete: "cascade"
   }),
-  roomState: text9("roomState")
+  roomState: text9("room_state")
 }, (table) => [
   index3("idx_participants_user").on(table.entityId),
   index3("idx_participants_room").on(table.roomId),
@@ -21441,9 +21592,9 @@ import {
 var relationshipTable = pgTable12("relationships", {
   id: uuid12("id").notNull().primaryKey().default(sql12`gen_random_uuid()`),
   createdAt: timestamp12("created_at", { withTimezone: true }).default(sql12`now()`).notNull(),
-  sourceEntityId: uuid12("sourceEntityId").notNull().references(() => entityTable.id, { onDelete: "cascade" }),
-  targetEntityId: uuid12("targetEntityId").notNull().references(() => entityTable.id, { onDelete: "cascade" }),
-  agentId: uuid12("agentId").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
+  sourceEntityId: uuid12("source_entity_id").notNull().references(() => entityTable.id, { onDelete: "cascade" }),
+  targetEntityId: uuid12("target_entity_id").notNull().references(() => entityTable.id, { onDelete: "cascade" }),
+  agentId: uuid12("agent_id").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
   tags: text10("tags").array(),
   metadata: jsonb9("metadata")
 }, (table) => [
@@ -21468,10 +21619,10 @@ var taskTable = pgTable13("tasks", {
   id: uuid13("id").primaryKey().defaultRandom(),
   name: text11("name").notNull(),
   description: text11("description"),
-  roomId: uuid13("roomId"),
-  worldId: uuid13("worldId"),
-  entityId: uuid13("entityId"),
-  agentId: uuid13("agentId").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
+  roomId: uuid13("room_id"),
+  worldId: uuid13("world_id"),
+  entityId: uuid13("entity_id"),
+  agentId: uuid13("agent_id").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
   tags: text11("tags").array().default(sql13`'{}'::text[]`),
   metadata: jsonb10("metadata").default(sql13`'{}'::jsonb`),
   createdAt: timestamp13("created_at", { withTimezone: true }).defaultNow(),
@@ -21619,7 +21770,11 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
     return this.withDatabase(async () => {
       const existingMemory = await this.db.select().from(memoryTable).innerJoin(embeddingTable, eq2(embeddingTable.memoryId, memoryTable.id)).where(eq2(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];
     });
@@ -21758,7 +21913,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 () => {
@@ -22325,6 +22480,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
         id: log2.id,
         entityId: log2.entityId,
         roomId: log2.roomId,
+        type: log2.type,
         body: log2.body,
         createdAt: new Date(log2.createdAt)
       }));
@@ -23137,7 +23293,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
     return this.withRetry(async () => {
       return this.withDatabase(async () => {
         const result = await this.db.select().from(taskTable).where(and(eq2(taskTable.agentId, this.agentId), ...params.roomId ? [eq2(taskTable.roomId, params.roomId)] : [], ...params.tags && params.tags.length > 0 ? [
-          sql25`${taskTable.tags} @> ARRAY[${sql25.raw(params.tags.map((t) => `'${t.replace(/'/g, "''")}'`).join(", "))}]::text[]`
+          sql25`${taskTable.tags} @> ARRAY[${sql25.join(params.tags.map((t) => sql25`${t}`), sql25`, `)}]::text[]`
         ] : []));
         return result.map((row) => ({
           id: row.id,
@@ -23201,11 +23357,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(eq2(taskTable.id, id), eq2(taskTable.agentId, this.agentId)));
+        await this.db.update(taskTable).set(dbUpdateValues).where(and(eq2(taskTable.id, id), eq2(taskTable.agentId, this.agentId)));
       });
     });
   }
@@ -23670,6 +23829,11 @@ class PGliteClientManager {
   async initialize() {}
   async close() {
     this.shuttingDown = true;
+    if (this.client) {
+      try {
+        await this.client.close();
+      } catch {}
+    }
   }
   setupShutdownHandlers() {}
 }
@@ -23715,5 +23879,5 @@ export {
   DatabaseMigrationService
 };
 
-//# debugId=A4CD118ECB5E333164756E2164756E21
+//# debugId=F233539768A25C6F64756E2164756E21
 //# sourceMappingURL=index.browser.js.map