@elizaos/plugin-sql 2.0.0-alpha.14 → 2.0.0-alpha.16

package/dist/node/index.node.js

@@ -1,11 +1,15 @@
 var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
@@ -1032,169 +1036,532 @@ var init_rls = __esm(() => {
   init_server();
 });
 
-// runtime-migrator/drizzle-adapters/diff-calculator.ts
-var exports_diff_calculator = {};
-__export(exports_diff_calculator, {
-  hasDiffChanges: () => hasDiffChanges,
-  calculateDiff: () => calculateDiff
-});
-function normalizeType(type) {
-  if (!type)
-    return "";
-  const normalized = type.toLowerCase().trim();
-  if (normalized === "timestamp without time zone" || normalized === "timestamp with time zone") {
-    return "timestamp";
-  }
-  if (normalized === "serial") {
-    return "integer";
-  }
-  if (normalized === "bigserial") {
-    return "bigint";
-  }
-  if (normalized === "smallserial") {
-    return "smallint";
-  }
-  if (normalized.startsWith("numeric") || normalized.startsWith("decimal")) {
-    const match = normalized.match(/\((\d+)(?:,\s*(\d+))?\)/);
-    if (match) {
-      return `numeric(${match[1]}${match[2] ? `,${match[2]}` : ""})`;
-    }
-    return "numeric";
-  }
-  if (normalized.startsWith("character varying")) {
-    return normalized.replace("character varying", "varchar");
-  }
-  if (normalized === "text[]" || normalized === "_text") {
-    return "text[]";
+// runtime-migrator/crypto-utils.ts
+function extendedHash(str) {
+  const h1 = hashWithSeed(str, 5381);
+  const h2 = hashWithSeed(str, 7919);
+  const h3 = hashWithSeed(str, 104729);
+  const h4 = hashWithSeed(str, 224737);
+  return h1 + h2 + h3 + h4;
+}
+function hashWithSeed(str, seed) {
+  let hash = seed;
+  for (let i = 0;i < str.length; i++) {
+    hash = hash * 33 ^ str.charCodeAt(i);
   }
-  return normalized;
+  return (hash >>> 0).toString(16).padStart(8, "0");
 }
-function isIndexChanged(prevIndex, currIndex) {
-  if (prevIndex.isUnique !== currIndex.isUnique)
-    return true;
-  if (prevIndex.method !== currIndex.method)
-    return true;
-  if (prevIndex.where !== currIndex.where)
-    return true;
-  if (prevIndex.concurrently !== currIndex.concurrently)
-    return true;
-  const prevColumns = prevIndex.columns || [];
-  const currColumns = currIndex.columns || [];
-  if (prevColumns.length !== currColumns.length)
-    return true;
-  for (let i = 0;i < prevColumns.length; i++) {
-    const prevCol = prevColumns[i];
-    const currCol = currColumns[i];
-    if (typeof prevCol === "string" && typeof currCol === "string") {
-      if (prevCol !== currCol)
-        return true;
-    } else if (typeof prevCol === "object" && typeof currCol === "object") {
-      if (prevCol.expression !== currCol.expression)
-        return true;
-      if (prevCol.isExpression !== currCol.isExpression)
-        return true;
-      if (prevCol.asc !== currCol.asc)
-        return true;
-      if (prevCol.nulls !== currCol.nulls)
-        return true;
-    } else {
-      return true;
-    }
+function stringToBigInt(str) {
+  const hash = extendedHash(str);
+  let lockId = BigInt(`0x${hash.slice(0, 16)}`);
+  const mask63Bits = 0x7fffffffffffffffn;
+  lockId = lockId & mask63Bits;
+  if (lockId === 0n) {
+    lockId = 1n;
   }
-  return false;
+  return lockId;
 }
-async function calculateDiff(previousSnapshot, currentSnapshot) {
-  const diff = {
-    tables: {
-      created: [],
-      deleted: [],
-      modified: []
-    },
-    columns: {
-      added: [],
-      deleted: [],
-      modified: []
-    },
-    indexes: {
-      created: [],
-      deleted: [],
-      altered: []
-    },
-    foreignKeys: {
-      created: [],
-      deleted: [],
-      altered: []
-    },
-    uniqueConstraints: {
-      created: [],
-      deleted: []
-    },
-    checkConstraints: {
-      created: [],
-      deleted: []
-    }
-  };
-  if (!previousSnapshot) {
-    diff.tables.created = Object.keys(currentSnapshot.tables);
-    for (const tableName in currentSnapshot.tables) {
-      const table = currentSnapshot.tables[tableName];
-      if (table.indexes) {
-        for (const indexName in table.indexes) {
-          diff.indexes.created.push({
-            ...table.indexes[indexName],
-            table: tableName
-          });
-        }
+
+// runtime-migrator/drizzle-adapters/database-introspector.ts
+import { logger as logger3 } from "@elizaos/core";
+import { sql as sql21 } from "drizzle-orm";
+function getRows2(result) {
+  return result.rows;
+}
+
+class DatabaseIntrospector {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  async introspectSchema(schemaName = "public") {
+    logger3.info({ src: "plugin:sql", schemaName }, "Starting database introspection");
+    const tables = {};
+    const schemas = {};
+    const enums = {};
+    const allTables = await this.getTables(schemaName);
+    for (const tableInfo of allTables) {
+      const tableName = tableInfo.table_name;
+      const tableSchema = tableInfo.table_schema || "public";
+      logger3.debug({ src: "plugin:sql", tableSchema, tableName }, "Introspecting table");
+      const columns = await this.getColumns(tableSchema, tableName);
+      const columnsObject = {};
+      const uniqueConstraintObject = {};
+      for (const col of columns) {
+        columnsObject[col.column_name] = {
+          name: col.column_name,
+          type: col.data_type,
+          primaryKey: col.is_primary || false,
+          notNull: col.is_nullable === "NO",
+          default: col.column_default ? this.parseDefault(col.column_default, col.data_type) : undefined
+        };
       }
-      if (table.foreignKeys) {
-        for (const fkName in table.foreignKeys) {
-          diff.foreignKeys.created.push(table.foreignKeys[fkName]);
+      const indexes = await this.getIndexes(tableSchema, tableName);
+      const indexesObject = {};
+      for (const idx of indexes) {
+        if (!idx.is_primary && !idx.is_unique_constraint) {
+          if (idx.columns && Array.isArray(idx.columns) && idx.columns.length > 0) {
+            indexesObject[idx.name] = {
+              name: idx.name,
+              columns: idx.columns.map((col) => ({
+                expression: col,
+                isExpression: false
+              })),
+              isUnique: idx.is_unique,
+              method: idx.method || "btree"
+            };
+          }
         }
       }
-    }
-    return diff;
-  }
-  const prevTables = previousSnapshot.tables || {};
-  const currTables = currentSnapshot.tables || {};
-  for (const tableName in currTables) {
-    if (!(tableName in prevTables)) {
-      diff.tables.created.push(tableName);
-      const table = currTables[tableName];
-      if (table.indexes) {
-        for (const indexName in table.indexes) {
-          diff.indexes.created.push({
-            ...table.indexes[indexName],
-            table: tableName
-          });
-        }
+      const foreignKeys = await this.getForeignKeys(tableSchema, tableName);
+      const foreignKeysObject = {};
+      for (const fk of foreignKeys) {
+        foreignKeysObject[fk.name] = {
+          name: fk.name,
+          tableFrom: tableName,
+          schemaFrom: tableSchema,
+          tableTo: fk.foreign_table_name,
+          schemaTo: fk.foreign_table_schema || "public",
+          columnsFrom: [fk.column_name],
+          columnsTo: [fk.foreign_column_name],
+          onDelete: fk.delete_rule?.toLowerCase() || "no action",
+          onUpdate: fk.update_rule?.toLowerCase() || "no action"
+        };
       }
-      if (table.uniqueConstraints) {
-        for (const uqName in table.uniqueConstraints) {
-          diff.uniqueConstraints.created.push({
-            ...table.uniqueConstraints[uqName],
-            table: tableName
-          });
-        }
+      const primaryKeys = await this.getPrimaryKeys(tableSchema, tableName);
+      const primaryKeysObject = {};
+      for (const pk of primaryKeys) {
+        primaryKeysObject[pk.name] = {
+          name: pk.name,
+          columns: pk.columns
+        };
       }
-      if (table.checkConstraints) {
-        for (const checkName in table.checkConstraints) {
-          diff.checkConstraints.created.push({
-            ...table.checkConstraints[checkName],
-            table: tableName
-          });
-        }
+      const uniqueConstraints = await this.getUniqueConstraints(tableSchema, tableName);
+      for (const unq of uniqueConstraints) {
+        uniqueConstraintObject[unq.name] = {
+          name: unq.name,
+          columns: unq.columns,
+          nullsNotDistinct: false
+        };
       }
-      if (table.foreignKeys) {
-        for (const fkName in table.foreignKeys) {
-          diff.foreignKeys.created.push(table.foreignKeys[fkName]);
-        }
+      const checkConstraints = await this.getCheckConstraints(tableSchema, tableName);
+      const checksObject = {};
+      for (const check3 of checkConstraints) {
+        checksObject[check3.name] = {
+          name: check3.name,
+          value: check3.definition
+        };
       }
-    }
-  }
-  for (const tableName in prevTables) {
-    if (!(tableName in currTables)) {
-      diff.tables.deleted.push(tableName);
-    }
+      tables[`${tableSchema}.${tableName}`] = {
+        name: tableName,
+        schema: tableSchema,
+        columns: columnsObject,
+        indexes: indexesObject,
+        foreignKeys: foreignKeysObject,
+        compositePrimaryKeys: primaryKeysObject,
+        uniqueConstraints: uniqueConstraintObject,
+        checkConstraints: checksObject
+      };
+      if (tableSchema && tableSchema !== "public") {
+        schemas[tableSchema] = tableSchema;
+      }
+    }
+    const enumsResult = await this.getEnums(schemaName);
+    for (const enumInfo of enumsResult) {
+      const key = `${enumInfo.schema}.${enumInfo.name}`;
+      if (!enums[key]) {
+        enums[key] = {
+          name: enumInfo.name,
+          schema: enumInfo.schema,
+          values: []
+        };
+      }
+      enums[key].values.push(enumInfo.value);
+    }
+    logger3.info({ src: "plugin:sql", tableCount: Object.keys(tables).length }, "Database introspection complete");
+    return {
+      version: "7",
+      dialect: "postgresql",
+      tables,
+      schemas,
+      enums,
+      _meta: {
+        schemas: {},
+        tables: {},
+        columns: {}
+      }
+    };
+  }
+  async getTables(schemaName) {
+    const result = await this.db.execute(sql21`SELECT 
+            table_schema,
+            table_name
+          FROM information_schema.tables
+          WHERE table_schema = ${schemaName}
+            AND table_type = 'BASE TABLE'
+          ORDER BY table_name`);
+    return getRows2(result);
+  }
+  async getColumns(schemaName, tableName) {
+    const result = await this.db.execute(sql21`SELECT 
+            a.attname AS column_name,
+            CASE 
+              WHEN a.attnotnull THEN 'NO'
+              ELSE 'YES'
+            END AS is_nullable,
+            CASE 
+              WHEN a.atttypid = ANY ('{int,int8,int2}'::regtype[]) 
+              AND EXISTS (
+                SELECT FROM pg_attrdef ad
+                WHERE ad.adrelid = a.attrelid 
+                AND ad.adnum = a.attnum 
+                AND pg_get_expr(ad.adbin, ad.adrelid) = 'nextval(''' 
+                    || pg_get_serial_sequence(a.attrelid::regclass::text, a.attname)::regclass || '''::regclass)'
+              )
+              THEN CASE a.atttypid
+                WHEN 'int'::regtype THEN 'serial'
+                WHEN 'int8'::regtype THEN 'bigserial'
+                WHEN 'int2'::regtype THEN 'smallserial'
+              END
+              ELSE format_type(a.atttypid, a.atttypmod)
+            END AS data_type,
+            pg_get_expr(ad.adbin, ad.adrelid) AS column_default,
+            CASE 
+              WHEN con.contype = 'p' THEN true
+              ELSE false
+            END AS is_primary
+          FROM pg_attribute a
+          JOIN pg_class cls ON cls.oid = a.attrelid
+          JOIN pg_namespace ns ON ns.oid = cls.relnamespace
+          LEFT JOIN pg_attrdef ad ON ad.adrelid = a.attrelid AND ad.adnum = a.attnum
+          LEFT JOIN pg_constraint con ON con.conrelid = a.attrelid 
+            AND a.attnum = ANY(con.conkey) 
+            AND con.contype = 'p'
+          WHERE 
+            a.attnum > 0
+            AND NOT a.attisdropped
+            AND ns.nspname = ${schemaName}
+            AND cls.relname = ${tableName}
+          ORDER BY a.attnum`);
+    return getRows2(result);
+  }
+  async getIndexes(schemaName, tableName) {
+    const result = await this.db.execute(sql21`SELECT 
+            i.relname AS name,
+            idx.indisunique AS is_unique,
+            idx.indisprimary AS is_primary,
+            con.contype = 'u' AS is_unique_constraint,
+            ARRAY(
+              SELECT a.attname
+              FROM pg_attribute a
+              WHERE a.attrelid = idx.indrelid
+                AND a.attnum = ANY(idx.indkey::int[])
+              ORDER BY a.attnum
+            ) AS columns,
+            am.amname AS method
+          FROM pg_index idx
+          JOIN pg_class i ON i.oid = idx.indexrelid
+          JOIN pg_class c ON c.oid = idx.indrelid
+          JOIN pg_namespace n ON n.oid = c.relnamespace
+          JOIN pg_am am ON am.oid = i.relam
+          LEFT JOIN pg_constraint con ON con.conindid = idx.indexrelid
+          WHERE n.nspname = ${schemaName}
+            AND c.relname = ${tableName}`);
+    return getRows2(result);
+  }
+  async getForeignKeys(schemaName, tableName) {
+    const result = await this.db.execute(sql21`SELECT
+            con.conname AS name,
+            att.attname AS column_name,
+            fnsp.nspname AS foreign_table_schema,
+            frel.relname AS foreign_table_name,
+            fatt.attname AS foreign_column_name,
+            CASE con.confupdtype
+              WHEN 'a' THEN 'NO ACTION'
+              WHEN 'r' THEN 'RESTRICT'
+              WHEN 'n' THEN 'SET NULL'
+              WHEN 'c' THEN 'CASCADE'
+              WHEN 'd' THEN 'SET DEFAULT'
+            END AS update_rule,
+            CASE con.confdeltype
+              WHEN 'a' THEN 'NO ACTION'
+              WHEN 'r' THEN 'RESTRICT'
+              WHEN 'n' THEN 'SET NULL'
+              WHEN 'c' THEN 'CASCADE'
+              WHEN 'd' THEN 'SET DEFAULT'
+            END AS delete_rule
+          FROM pg_catalog.pg_constraint con
+          JOIN pg_catalog.pg_class rel ON rel.oid = con.conrelid
+          JOIN pg_catalog.pg_namespace nsp ON nsp.oid = con.connamespace
+          LEFT JOIN pg_catalog.pg_attribute att ON att.attnum = ANY (con.conkey)
+            AND att.attrelid = con.conrelid
+          LEFT JOIN pg_catalog.pg_class frel ON frel.oid = con.confrelid
+          LEFT JOIN pg_catalog.pg_namespace fnsp ON fnsp.oid = frel.relnamespace
+          LEFT JOIN pg_catalog.pg_attribute fatt ON fatt.attnum = ANY (con.confkey)
+            AND fatt.attrelid = con.confrelid
+          WHERE con.contype = 'f'
+            AND nsp.nspname = ${schemaName}
+            AND rel.relname = ${tableName}`);
+    return getRows2(result);
+  }
+  async getPrimaryKeys(schemaName, tableName) {
+    const result = await this.db.execute(sql21`SELECT 
+            con.conname AS name,
+            ARRAY(
+              SELECT a.attname
+              FROM pg_attribute a
+              WHERE a.attrelid = con.conrelid
+                AND a.attnum = ANY(con.conkey)
+              ORDER BY a.attnum
+            ) AS columns
+          FROM pg_constraint con
+          JOIN pg_class rel ON rel.oid = con.conrelid
+          JOIN pg_namespace nsp ON nsp.oid = con.connamespace
+          WHERE con.contype = 'p'
+            AND nsp.nspname = ${schemaName}
+            AND rel.relname = ${tableName}`);
+    return getRows2(result);
+  }
+  async getUniqueConstraints(schemaName, tableName) {
+    const result = await this.db.execute(sql21`SELECT 
+            con.conname AS name,
+            ARRAY(
+              SELECT a.attname
+              FROM pg_attribute a
+              WHERE a.attrelid = con.conrelid
+                AND a.attnum = ANY(con.conkey)
+              ORDER BY a.attnum
+            ) AS columns
+          FROM pg_constraint con
+          JOIN pg_class rel ON rel.oid = con.conrelid
+          JOIN pg_namespace nsp ON nsp.oid = con.connamespace
+          WHERE con.contype = 'u'
+            AND nsp.nspname = ${schemaName}
+            AND rel.relname = ${tableName}`);
+    return getRows2(result);
+  }
+  async getCheckConstraints(schemaName, tableName) {
+    const result = await this.db.execute(sql21`SELECT 
+            con.conname AS name,
+            pg_get_constraintdef(con.oid) AS definition
+          FROM pg_constraint con
+          JOIN pg_class rel ON rel.oid = con.conrelid
+          JOIN pg_namespace nsp ON nsp.oid = con.connamespace
+          WHERE con.contype = 'c'
+            AND nsp.nspname = ${schemaName}
+            AND rel.relname = ${tableName}`);
+    return getRows2(result);
+  }
+  async getEnums(schemaName) {
+    const result = await this.db.execute(sql21`SELECT 
+            n.nspname AS schema,
+            t.typname AS name,
+            e.enumlabel AS value,
+            e.enumsortorder AS sort_order
+          FROM pg_type t
+          JOIN pg_enum e ON t.oid = e.enumtypid
+          JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
+          WHERE n.nspname = ${schemaName}
+          ORDER BY schema, name, sort_order`);
+    return getRows2(result);
+  }
+  parseDefault(defaultValue, dataType) {
+    if (!defaultValue)
+      return;
+    const match = defaultValue.match(/^'(.*)'::/);
+    if (match) {
+      return `'${match[1]}'`;
+    }
+    if (defaultValue.includes("nextval(")) {
+      return;
+    }
+    if (dataType === "boolean") {
+      if (defaultValue === "true")
+        return "true";
+      if (defaultValue === "false")
+        return "false";
+    }
+    return defaultValue;
+  }
+  async hasExistingTables(pluginName) {
+    const schemaName = pluginName === "@elizaos/plugin-sql" ? "public" : this.deriveSchemaName(pluginName);
+    const result = await this.db.execute(sql21`SELECT COUNT(*) AS count
+          FROM information_schema.tables
+          WHERE table_schema = ${schemaName}
+            AND table_type = 'BASE TABLE'`);
+    const firstRow = result.rows?.[0];
+    const count = parseInt(firstRow && firstRow.count || "0", 10);
+    return count > 0;
+  }
+  deriveSchemaName(pluginName) {
+    return pluginName.replace("@", "").replace("/", "_").replace(/-/g, "_").toLowerCase();
+  }
+}
+var init_database_introspector = () => {};
+
+// runtime-migrator/drizzle-adapters/diff-calculator.ts
+var exports_diff_calculator = {};
+__export(exports_diff_calculator, {
+  hasDiffChanges: () => hasDiffChanges,
+  calculateDiff: () => calculateDiff
+});
+function normalizeType(type) {
+  if (!type)
+    return "";
+  const normalized = type.toLowerCase().trim();
+  if (normalized === "timestamp without time zone" || normalized === "timestamp with time zone") {
+    return "timestamp";
+  }
+  if (normalized === "serial") {
+    return "integer";
+  }
+  if (normalized === "bigserial") {
+    return "bigint";
+  }
+  if (normalized === "smallserial") {
+    return "smallint";
+  }
+  if (normalized.startsWith("numeric") || normalized.startsWith("decimal")) {
+    const match = normalized.match(/\((\d+)(?:,\s*(\d+))?\)/);
+    if (match) {
+      return `numeric(${match[1]}${match[2] ? `,${match[2]}` : ""})`;
+    }
+    return "numeric";
+  }
+  if (normalized.startsWith("character varying")) {
+    return normalized.replace("character varying", "varchar");
+  }
+  if (normalized === "text[]" || normalized === "_text") {
+    return "text[]";
+  }
+  return normalized;
+}
+function isIndexChanged(prevIndex, currIndex) {
+  if (prevIndex.isUnique !== currIndex.isUnique)
+    return true;
+  if (prevIndex.method !== currIndex.method)
+    return true;
+  if (prevIndex.where !== currIndex.where)
+    return true;
+  if (prevIndex.concurrently !== currIndex.concurrently)
+    return true;
+  const prevColumns = prevIndex.columns || [];
+  const currColumns = currIndex.columns || [];
+  if (prevColumns.length !== currColumns.length)
+    return true;
+  for (let i = 0;i < prevColumns.length; i++) {
+    const prevCol = prevColumns[i];
+    const currCol = currColumns[i];
+    if (typeof prevCol === "string" && typeof currCol === "string") {
+      if (prevCol !== currCol)
+        return true;
+    } else if (typeof prevCol === "object" && typeof currCol === "object") {
+      if (prevCol.expression !== currCol.expression)
+        return true;
+      if (prevCol.isExpression !== currCol.isExpression)
+        return true;
+      if (prevCol.asc !== currCol.asc)
+        return true;
+      if (prevCol.nulls !== currCol.nulls)
+        return true;
+    } else {
+      return true;
+    }
+  }
+  return false;
+}
+async function calculateDiff(previousSnapshot, currentSnapshot) {
+  const diff = {
+    tables: {
+      created: [],
+      deleted: [],
+      modified: []
+    },
+    columns: {
+      added: [],
+      deleted: [],
+      modified: []
+    },
+    indexes: {
+      created: [],
+      deleted: [],
+      altered: []
+    },
+    foreignKeys: {
+      created: [],
+      deleted: [],
+      altered: []
+    },
+    uniqueConstraints: {
+      created: [],
+      deleted: []
+    },
+    checkConstraints: {
+      created: [],
+      deleted: []
+    }
+  };
+  if (!previousSnapshot) {
+    diff.tables.created = Object.keys(currentSnapshot.tables);
+    for (const tableName in currentSnapshot.tables) {
+      const table = currentSnapshot.tables[tableName];
+      if (table.indexes) {
+        for (const indexName in table.indexes) {
+          diff.indexes.created.push({
+            ...table.indexes[indexName],
+            table: tableName
+          });
+        }
+      }
+      if (table.foreignKeys) {
+        for (const fkName in table.foreignKeys) {
+          diff.foreignKeys.created.push(table.foreignKeys[fkName]);
+        }
+      }
+    }
+    return diff;
+  }
+  const prevTables = previousSnapshot.tables || {};
+  const currTables = currentSnapshot.tables || {};
+  for (const tableName in currTables) {
+    if (!(tableName in prevTables)) {
+      diff.tables.created.push(tableName);
+      const table = currTables[tableName];
+      if (table.indexes) {
+        for (const indexName in table.indexes) {
+          diff.indexes.created.push({
+            ...table.indexes[indexName],
+            table: tableName
+          });
+        }
+      }
+      if (table.uniqueConstraints) {
+        for (const uqName in table.uniqueConstraints) {
+          diff.uniqueConstraints.created.push({
+            ...table.uniqueConstraints[uqName],
+            table: tableName
+          });
+        }
+      }
+      if (table.checkConstraints) {
+        for (const checkName in table.checkConstraints) {
+          diff.checkConstraints.created.push({
+            ...table.checkConstraints[checkName],
+            table: tableName
+          });
+        }
+      }
+      if (table.foreignKeys) {
+        for (const fkName in table.foreignKeys) {
+          diff.foreignKeys.created.push(table.foreignKeys[fkName]);
+        }
+      }
+    }
+  }
+  for (const tableName in prevTables) {
+    if (!(tableName in currTables)) {
+      diff.tables.deleted.push(tableName);
+    }
   }
   for (const tableName in currTables) {
     if (tableName in prevTables) {
@@ -1363,32 +1730,6 @@ function hasDiffChanges(diff) {
   return diff.tables.created.length > 0 || diff.tables.deleted.length > 0 || diff.tables.modified.length > 0 || diff.columns.added.length > 0 || diff.columns.deleted.length > 0 || diff.columns.modified.length > 0 || diff.indexes.created.length > 0 || diff.indexes.deleted.length > 0 || diff.indexes.altered.length > 0 || diff.foreignKeys.created.length > 0 || diff.foreignKeys.deleted.length > 0 || diff.foreignKeys.altered.length > 0 || diff.uniqueConstraints.created.length > 0 || diff.uniqueConstraints.deleted.length > 0 || diff.checkConstraints.created.length > 0 || diff.checkConstraints.deleted.length > 0;
 }
 
-// runtime-migrator/crypto-utils.ts
-function extendedHash(str) {
-  const h1 = hashWithSeed(str, 5381);
-  const h2 = hashWithSeed(str, 7919);
-  const h3 = hashWithSeed(str, 104729);
-  const h4 = hashWithSeed(str, 224737);
-  return h1 + h2 + h3 + h4;
-}
-function hashWithSeed(str, seed) {
-  let hash = seed;
-  for (let i = 0;i < str.length; i++) {
-    hash = hash * 33 ^ str.charCodeAt(i);
-  }
-  return (hash >>> 0).toString(16).padStart(8, "0");
-}
-function stringToBigInt(str) {
-  const hash = extendedHash(str);
-  let lockId = BigInt(`0x${hash.slice(0, 16)}`);
-  const mask63Bits = 0x7fffffffffffffffn;
-  lockId = lockId & mask63Bits;
-  if (lockId === 0n) {
-    lockId = 1n;
-  }
-  return lockId;
-}
-
 // runtime-migrator/drizzle-adapters/snapshot-generator.ts
 import { is, SQL } from "drizzle-orm";
 import { getTableConfig, PgDialect, PgTable } from "drizzle-orm/pg-core";
@@ -1617,7 +1958,7 @@ function hasChanges(previousSnapshot, currentSnapshot) {
   const currHash = hashSnapshot(currentSnapshot);
   return prevHash !== currHash;
 }
-var sqlToStr = (sql21, _casing) => {
+var sqlToStr = (sql22, _casing) => {
   const config = {
     escapeName: () => {
       throw new Error("we don't support params for `sql` default values");
@@ -1630,12 +1971,12 @@ var sqlToStr = (sql21, _casing) => {
     },
     casing: undefined
   };
-  return sql21.toQuery(config).sql;
+  return sql22.toQuery(config).sql;
 };
 var init_snapshot_generator = () => {};
 
 // runtime-migrator/drizzle-adapters/sql-generator.ts
-import { logger as logger3 } from "@elizaos/core";
+import { logger as logger4 } from "@elizaos/core";
 function checkForDataLoss(diff) {
   const result = {
     hasDataLoss: false,
@@ -1765,7 +2106,7 @@ async function generateMigrationSQL(previousSnapshot, currentSnapshot, diff) {
   }
   const dataLossCheck = checkForDataLoss(diff);
   if (dataLossCheck.warnings.length > 0) {
-    logger3.warn({ src: "plugin:sql", warnings: dataLossCheck.warnings }, "Schema changes may cause data loss");
+    logger4.warn({ src: "plugin:sql", warnings: dataLossCheck.warnings }, "Schema changes may cause data loss");
   }
   const schemasToCreate = new Set;
   for (const tableName of diff.tables.created) {
@@ -1924,564 +2265,227 @@ function generateCreateTableSQL(fullTableName, table) {
   return { tableSQL, fkSQLs };
 }
 function generateColumnDefinition(name, def) {
-  let sql21 = `"${name}" ${def.type}`;
+  let sql22 = `"${name}" ${def.type}`;
   if (def.primaryKey && !def.type.includes("SERIAL")) {
-    sql21 += " PRIMARY KEY";
+    sql22 += " PRIMARY KEY";
   }
   if (def.notNull) {
-    sql21 += " NOT NULL";
+    sql22 += " NOT NULL";
   }
   if (def.default !== undefined) {
-    const defaultValue = formatDefaultValue(def.default, def.type);
-    sql21 += ` DEFAULT ${defaultValue}`;
-  }
-  return sql21;
-}
-function generateAddColumnSQL(table, column, definition) {
-  const [schema, tableName] = table.includes(".") ? table.split(".") : ["public", table];
-  const tableNameWithSchema = `"${schema}"."${tableName}"`;
-  const parts = [`"${column}"`];
-  parts.push(definition.type);
-  if (definition.primaryKey) {
-    parts.push("PRIMARY KEY");
-  }
-  if (definition.default !== undefined) {
-    const defaultValue = formatDefaultValue(definition.default, definition.type);
-    if (defaultValue) {
-      parts.push(`DEFAULT ${defaultValue}`);
-    }
-  }
-  const definitionWithGenerated = definition;
-  if (definitionWithGenerated.generated) {
-    parts.push(`GENERATED ALWAYS AS (${definitionWithGenerated.generated}) STORED`);
-  }
-  if (definition.notNull) {
-    parts.push("NOT NULL");
-  }
-  return `ALTER TABLE ${tableNameWithSchema} ADD COLUMN ${parts.join(" ")};`;
-}
-function generateDropColumnSQL(table, column) {
-  const [schema, tableName] = table.includes(".") ? table.split(".") : ["public", table];
-  const tableNameWithSchema = `"${schema}"."${tableName}"`;
-  return `ALTER TABLE ${tableNameWithSchema} DROP COLUMN "${column}" CASCADE;`;
-}
-function generateAlterColumnSQL(table, column, changes) {
-  const [schema, tableName] = table.includes(".") ? table.split(".") : ["public", table];
-  const tableNameWithSchema = `"${schema}"."${tableName}"`;
-  const statements = [];
-  const changesTo = changes.to;
-  const changesFrom = changes.from;
-  const changesToType = changesTo?.type;
-  const changesFromType = changesFrom?.type;
-  if (changesToType !== changesFromType) {
-    const newType = changesToType || "TEXT";
-    const needsUsing = checkIfNeedsUsingClause(changesFromType || "", newType);
-    if (needsUsing) {
-      statements.push(`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${column}" TYPE ${newType} USING "${column}"::text::${newType};`);
-    } else {
-      statements.push(`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${column}" SET DATA TYPE ${newType};`);
-    }
-  }
-  const changesToNotNull = changesTo?.notNull;
-  const changesFromNotNull = changesFrom?.notNull;
-  if (changesToNotNull !== changesFromNotNull) {
-    if (changesToNotNull) {
-      statements.push(`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${column}" SET NOT NULL;`);
-    } else {
-      statements.push(`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${column}" DROP NOT NULL;`);
-    }
-  }
-  const changesToDefault = changesTo?.default;
-  const changesFromDefault = changesFrom?.default;
-  if (changesToDefault !== changesFromDefault) {
-    if (changesToDefault !== undefined) {
-      const defaultValue = formatDefaultValue(changesToDefault, changesToType || "");
-      statements.push(`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${column}" SET DEFAULT ${defaultValue};`);
-    } else {
-      statements.push(`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${column}" DROP DEFAULT;`);
-    }
-  }
-  return statements;
-}
-function checkIfNeedsUsingClause(fromType, toType) {
-  if (!fromType || !toType)
-    return false;
-  if (fromType.includes("enum") || toType.includes("enum")) {
-    return true;
-  }
-  const fromBase = fromType.split("(")[0].toLowerCase();
-  const toBase = toType.split("(")[0].toLowerCase();
-  if ((fromBase === "text" || fromBase === "varchar" || fromBase === "character varying") && (toBase === "jsonb" || toBase === "json")) {
-    return true;
-  }
-  const needsUsingPairs = [
-    ["integer", "boolean"],
-    ["boolean", "integer"],
-    ["text", "integer"],
-    ["text", "numeric"],
-    ["text", "boolean"],
-    ["text", "uuid"],
-    ["text", "jsonb"],
-    ["text", "json"],
-    ["varchar", "integer"],
-    ["varchar", "numeric"],
-    ["varchar", "boolean"],
-    ["varchar", "uuid"],
-    ["varchar", "jsonb"],
-    ["varchar", "json"],
-    ["character varying", "jsonb"],
-    ["character varying", "json"]
-  ];
-  for (const [from, to] of needsUsingPairs) {
-    if (fromBase === from && toBase === to || fromBase === to && toBase === from) {
-      return true;
-    }
-  }
-  return false;
-}
-function formatDefaultValue(value, type) {
-  if (value === null || value === "NULL") {
-    return "NULL";
-  }
-  if (type && (type.toLowerCase().includes("boolean") || type.toLowerCase() === "bool")) {
-    if (value === true || value === "true" || value === "t" || value === 1) {
-      return "true";
-    }
-    if (value === false || value === "false" || value === "f" || value === 0) {
-      return "false";
-    }
-  }
-  if (type?.match(/^(integer|bigint|smallint|numeric|decimal|real|double)/i)) {
-    return String(value);
-  }
-  if (typeof value === "string") {
-    if (value.includes("::")) {
-      return value;
-    }
-    if (value.startsWith("'") && value.endsWith("'")) {
-      return value;
-    }
-    if (value.match(/^\w+\(\)/i) || value.includes("(") && value.includes(")")) {
-      return value;
-    }
-    if (value.toUpperCase().startsWith("CURRENT_")) {
-      return value;
-    }
-    return `'${value.replace(/'/g, "''")}'`;
-  }
-  return String(value);
-}
-function generateCreateIndexSQL(index7) {
-  const unique3 = index7.isUnique ? "UNIQUE " : "";
-  const method = index7.method || "btree";
-  const columns = index7.columns.map((c) => {
-    if (c.isExpression) {
-      return c.expression;
-    }
-    return `"${c.expression}"${c.asc === false ? " DESC" : ""}`;
-  }).join(", ");
-  const indexName = index7.name.includes(".") ? index7.name.split(".")[1] : index7.name;
-  let tableRef;
-  const indexTable = index7.table;
-  if (indexTable?.includes(".")) {
-    const [schema, table] = indexTable.split(".");
-    tableRef = `"${schema}"."${table}"`;
-  } else {
-    tableRef = `"${indexTable || ""}"`;
-  }
-  return `CREATE ${unique3}INDEX "${indexName}" ON ${tableRef} USING ${method} (${columns});`;
-}
-function generateDropIndexSQL(index7) {
-  const indexNameFull = typeof index7 === "string" ? index7 : index7.name;
-  const indexName = indexNameFull.includes(".") ? indexNameFull.split(".")[1] : indexNameFull;
-  return `DROP INDEX IF EXISTS "${indexName}";`;
-}
-function generateCreateForeignKeySQL(fk) {
-  const schemaFrom = fk.schemaFrom || "public";
-  const schemaTo = fk.schemaTo || "public";
-  const tableFrom = fk.tableFrom;
-  const columnsFrom = fk.columnsFrom.map((c) => `"${c}"`).join(", ");
-  const columnsTo = fk.columnsTo.map((c) => `"${c}"`).join(", ");
-  let sql21 = `ALTER TABLE "${schemaFrom}"."${tableFrom}" ADD CONSTRAINT "${fk.name}" FOREIGN KEY (${columnsFrom}) REFERENCES "${schemaTo}"."${fk.tableTo}" (${columnsTo})`;
-  if (fk.onDelete) {
-    sql21 += ` ON DELETE ${fk.onDelete}`;
-  }
-  if (fk.onUpdate) {
-    sql21 += ` ON UPDATE ${fk.onUpdate}`;
+    const defaultValue = formatDefaultValue(def.default, def.type);
+    sql22 += ` DEFAULT ${defaultValue}`;
   }
-  return `${sql21};`;
-}
-function generateDropForeignKeySQL(fk) {
-  const [schema, tableName] = fk.tableFrom ? fk.tableFrom.includes(".") ? fk.tableFrom.split(".") : ["public", fk.tableFrom] : ["public", ""];
-  return `ALTER TABLE "${schema}"."${tableName}" DROP CONSTRAINT "${fk.name}";`;
+  return sql22;
 }
-function generateCreateUniqueConstraintSQL(constraint) {
-  const table = constraint.table || "";
+function generateAddColumnSQL(table, column, definition) {
   const [schema, tableName] = table.includes(".") ? table.split(".") : ["public", table];
-  const name = constraint.name;
-  const columns = constraint.columns.map((c) => `"${c}"`).join(", ");
-  let sql21 = `ALTER TABLE "${schema}"."${tableName}" ADD CONSTRAINT "${name}" UNIQUE`;
-  if (constraint.nullsNotDistinct) {
-    sql21 += ` NULLS NOT DISTINCT`;
+  const tableNameWithSchema = `"${schema}"."${tableName}"`;
+  const parts = [`"${column}"`];
+  parts.push(definition.type);
+  if (definition.primaryKey) {
+    parts.push("PRIMARY KEY");
   }
-  sql21 += ` (${columns});`;
-  return sql21;
-}
-function generateDropUniqueConstraintSQL(constraint) {
-  const table = constraint.table || "";
-  const [schema, tableName] = table.includes(".") ? table.split(".") : ["public", table];
-  return `ALTER TABLE "${schema}"."${tableName}" DROP CONSTRAINT "${constraint.name}";`;
+  if (definition.default !== undefined) {
+    const defaultValue = formatDefaultValue(definition.default, definition.type);
+    if (defaultValue) {
+      parts.push(`DEFAULT ${defaultValue}`);
+    }
+  }
+  const definitionWithGenerated = definition;
+  if (definitionWithGenerated.generated) {
+    parts.push(`GENERATED ALWAYS AS (${definitionWithGenerated.generated}) STORED`);
+  }
+  if (definition.notNull) {
+    parts.push("NOT NULL");
+  }
+  return `ALTER TABLE ${tableNameWithSchema} ADD COLUMN ${parts.join(" ")};`;
 }
-function generateCreateCheckConstraintSQL(constraint) {
-  const table = constraint.table || "";
+function generateDropColumnSQL(table, column) {
   const [schema, tableName] = table.includes(".") ? table.split(".") : ["public", table];
-  const name = constraint.name;
-  const value = constraint.value;
-  return `ALTER TABLE "${schema}"."${tableName}" ADD CONSTRAINT "${name}" CHECK (${value});`;
+  const tableNameWithSchema = `"${schema}"."${tableName}"`;
+  return `ALTER TABLE ${tableNameWithSchema} DROP COLUMN "${column}" CASCADE;`;
 }
-function generateDropCheckConstraintSQL(constraint) {
-  const table = constraint.table || "";
+function generateAlterColumnSQL(table, column, changes) {
   const [schema, tableName] = table.includes(".") ? table.split(".") : ["public", table];
-  return `ALTER TABLE "${schema}"."${tableName}" DROP CONSTRAINT "${constraint.name}";`;
-}
-var init_sql_generator = () => {};
-
-// runtime-migrator/drizzle-adapters/database-introspector.ts
-import { logger as logger4 } from "@elizaos/core";
-import { sql as sql21 } from "drizzle-orm";
-function getRows2(result) {
-  return result.rows;
-}
-
-class DatabaseIntrospector {
-  db;
-  constructor(db) {
-    this.db = db;
-  }
-  async introspectSchema(schemaName = "public") {
-    logger4.info({ src: "plugin:sql", schemaName }, "Starting database introspection");
-    const tables = {};
-    const schemas = {};
-    const enums = {};
-    const allTables = await this.getTables(schemaName);
-    for (const tableInfo of allTables) {
-      const tableName = tableInfo.table_name;
-      const tableSchema = tableInfo.table_schema || "public";
-      logger4.debug({ src: "plugin:sql", tableSchema, tableName }, "Introspecting table");
-      const columns = await this.getColumns(tableSchema, tableName);
-      const columnsObject = {};
-      const uniqueConstraintObject = {};
-      for (const col of columns) {
-        columnsObject[col.column_name] = {
-          name: col.column_name,
-          type: col.data_type,
-          primaryKey: col.is_primary || false,
-          notNull: col.is_nullable === "NO",
-          default: col.column_default ? this.parseDefault(col.column_default, col.data_type) : undefined
-        };
-      }
-      const indexes = await this.getIndexes(tableSchema, tableName);
-      const indexesObject = {};
-      for (const idx of indexes) {
-        if (!idx.is_primary && !idx.is_unique_constraint) {
-          if (idx.columns && Array.isArray(idx.columns) && idx.columns.length > 0) {
-            indexesObject[idx.name] = {
-              name: idx.name,
-              columns: idx.columns.map((col) => ({
-                expression: col,
-                isExpression: false
-              })),
-              isUnique: idx.is_unique,
-              method: idx.method || "btree"
-            };
-          }
-        }
-      }
-      const foreignKeys = await this.getForeignKeys(tableSchema, tableName);
-      const foreignKeysObject = {};
-      for (const fk of foreignKeys) {
-        foreignKeysObject[fk.name] = {
-          name: fk.name,
-          tableFrom: tableName,
-          schemaFrom: tableSchema,
-          tableTo: fk.foreign_table_name,
-          schemaTo: fk.foreign_table_schema || "public",
-          columnsFrom: [fk.column_name],
-          columnsTo: [fk.foreign_column_name],
-          onDelete: fk.delete_rule?.toLowerCase() || "no action",
-          onUpdate: fk.update_rule?.toLowerCase() || "no action"
-        };
-      }
-      const primaryKeys = await this.getPrimaryKeys(tableSchema, tableName);
-      const primaryKeysObject = {};
-      for (const pk of primaryKeys) {
-        primaryKeysObject[pk.name] = {
-          name: pk.name,
-          columns: pk.columns
-        };
-      }
-      const uniqueConstraints = await this.getUniqueConstraints(tableSchema, tableName);
-      for (const unq of uniqueConstraints) {
-        uniqueConstraintObject[unq.name] = {
-          name: unq.name,
-          columns: unq.columns,
-          nullsNotDistinct: false
-        };
-      }
-      const checkConstraints = await this.getCheckConstraints(tableSchema, tableName);
-      const checksObject = {};
-      for (const check3 of checkConstraints) {
-        checksObject[check3.name] = {
-          name: check3.name,
-          value: check3.definition
-        };
-      }
-      tables[`${tableSchema}.${tableName}`] = {
-        name: tableName,
-        schema: tableSchema,
-        columns: columnsObject,
-        indexes: indexesObject,
-        foreignKeys: foreignKeysObject,
-        compositePrimaryKeys: primaryKeysObject,
-        uniqueConstraints: uniqueConstraintObject,
-        checkConstraints: checksObject
-      };
-      if (tableSchema && tableSchema !== "public") {
-        schemas[tableSchema] = tableSchema;
-      }
-    }
-    const enumsResult = await this.getEnums(schemaName);
-    for (const enumInfo of enumsResult) {
-      const key = `${enumInfo.schema}.${enumInfo.name}`;
-      if (!enums[key]) {
-        enums[key] = {
-          name: enumInfo.name,
-          schema: enumInfo.schema,
-          values: []
-        };
-      }
-      enums[key].values.push(enumInfo.value);
+  const tableNameWithSchema = `"${schema}"."${tableName}"`;
+  const statements = [];
+  const changesTo = changes.to;
+  const changesFrom = changes.from;
+  const changesToType = changesTo?.type;
+  const changesFromType = changesFrom?.type;
+  if (changesToType !== changesFromType) {
+    const newType = changesToType || "TEXT";
+    const needsUsing = checkIfNeedsUsingClause(changesFromType || "", newType);
+    if (needsUsing) {
+      statements.push(`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${column}" TYPE ${newType} USING "${column}"::text::${newType};`);
+    } else {
+      statements.push(`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${column}" SET DATA TYPE ${newType};`);
     }
-    logger4.info({ src: "plugin:sql", tableCount: Object.keys(tables).length }, "Database introspection complete");
-    return {
-      version: "7",
-      dialect: "postgresql",
-      tables,
-      schemas,
-      enums,
-      _meta: {
-        schemas: {},
-        tables: {},
-        columns: {}
-      }
-    };
   }
-  async getTables(schemaName) {
-    const result = await this.db.execute(sql21`SELECT 
-            table_schema,
-            table_name
-          FROM information_schema.tables
-          WHERE table_schema = ${schemaName}
-            AND table_type = 'BASE TABLE'
-          ORDER BY table_name`);
-    return getRows2(result);
+  const changesToNotNull = changesTo?.notNull;
+  const changesFromNotNull = changesFrom?.notNull;
+  if (changesToNotNull !== changesFromNotNull) {
+    if (changesToNotNull) {
+      statements.push(`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${column}" SET NOT NULL;`);
+    } else {
+      statements.push(`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${column}" DROP NOT NULL;`);
+    }
   }
-  async getColumns(schemaName, tableName) {
-    const result = await this.db.execute(sql21`SELECT 
-            a.attname AS column_name,
-            CASE 
-              WHEN a.attnotnull THEN 'NO'
-              ELSE 'YES'
-            END AS is_nullable,
-            CASE 
-              WHEN a.atttypid = ANY ('{int,int8,int2}'::regtype[]) 
-              AND EXISTS (
-                SELECT FROM pg_attrdef ad
-                WHERE ad.adrelid = a.attrelid 
-                AND ad.adnum = a.attnum 
-                AND pg_get_expr(ad.adbin, ad.adrelid) = 'nextval(''' 
-                    || pg_get_serial_sequence(a.attrelid::regclass::text, a.attname)::regclass || '''::regclass)'
-              )
-              THEN CASE a.atttypid
-                WHEN 'int'::regtype THEN 'serial'
-                WHEN 'int8'::regtype THEN 'bigserial'
-                WHEN 'int2'::regtype THEN 'smallserial'
-              END
-              ELSE format_type(a.atttypid, a.atttypmod)
-            END AS data_type,
-            pg_get_expr(ad.adbin, ad.adrelid) AS column_default,
-            CASE 
-              WHEN con.contype = 'p' THEN true
-              ELSE false
-            END AS is_primary
-          FROM pg_attribute a
-          JOIN pg_class cls ON cls.oid = a.attrelid
-          JOIN pg_namespace ns ON ns.oid = cls.relnamespace
-          LEFT JOIN pg_attrdef ad ON ad.adrelid = a.attrelid AND ad.adnum = a.attnum
-          LEFT JOIN pg_constraint con ON con.conrelid = a.attrelid 
-            AND a.attnum = ANY(con.conkey) 
-            AND con.contype = 'p'
-          WHERE 
-            a.attnum > 0
-            AND NOT a.attisdropped
-            AND ns.nspname = ${schemaName}
-            AND cls.relname = ${tableName}
-          ORDER BY a.attnum`);
-    return getRows2(result);
+  const changesToDefault = changesTo?.default;
+  const changesFromDefault = changesFrom?.default;
+  if (changesToDefault !== changesFromDefault) {
+    if (changesToDefault !== undefined) {
+      const defaultValue = formatDefaultValue(changesToDefault, changesToType || "");
+      statements.push(`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${column}" SET DEFAULT ${defaultValue};`);
+    } else {
+      statements.push(`ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${column}" DROP DEFAULT;`);
+    }
   }
-  async getIndexes(schemaName, tableName) {
-    const result = await this.db.execute(sql21`SELECT 
-            i.relname AS name,
-            idx.indisunique AS is_unique,
-            idx.indisprimary AS is_primary,
-            con.contype = 'u' AS is_unique_constraint,
-            ARRAY(
-              SELECT a.attname
-              FROM pg_attribute a
-              WHERE a.attrelid = idx.indrelid
-                AND a.attnum = ANY(idx.indkey::int[])
-              ORDER BY a.attnum
-            ) AS columns,
-            am.amname AS method
-          FROM pg_index idx
-          JOIN pg_class i ON i.oid = idx.indexrelid
-          JOIN pg_class c ON c.oid = idx.indrelid
-          JOIN pg_namespace n ON n.oid = c.relnamespace
-          JOIN pg_am am ON am.oid = i.relam
-          LEFT JOIN pg_constraint con ON con.conindid = idx.indexrelid
-          WHERE n.nspname = ${schemaName}
-            AND c.relname = ${tableName}`);
-    return getRows2(result);
+  return statements;
+}
+function checkIfNeedsUsingClause(fromType, toType) {
+  if (!fromType || !toType)
+    return false;
+  if (fromType.includes("enum") || toType.includes("enum")) {
+    return true;
   }
-  async getForeignKeys(schemaName, tableName) {
-    const result = await this.db.execute(sql21`SELECT
-            con.conname AS name,
-            att.attname AS column_name,
-            fnsp.nspname AS foreign_table_schema,
-            frel.relname AS foreign_table_name,
-            fatt.attname AS foreign_column_name,
-            CASE con.confupdtype
-              WHEN 'a' THEN 'NO ACTION'
-              WHEN 'r' THEN 'RESTRICT'
-              WHEN 'n' THEN 'SET NULL'
-              WHEN 'c' THEN 'CASCADE'
-              WHEN 'd' THEN 'SET DEFAULT'
-            END AS update_rule,
-            CASE con.confdeltype
-              WHEN 'a' THEN 'NO ACTION'
-              WHEN 'r' THEN 'RESTRICT'
-              WHEN 'n' THEN 'SET NULL'
-              WHEN 'c' THEN 'CASCADE'
-              WHEN 'd' THEN 'SET DEFAULT'
-            END AS delete_rule
-          FROM pg_catalog.pg_constraint con
-          JOIN pg_catalog.pg_class rel ON rel.oid = con.conrelid
-          JOIN pg_catalog.pg_namespace nsp ON nsp.oid = con.connamespace
-          LEFT JOIN pg_catalog.pg_attribute att ON att.attnum = ANY (con.conkey)
-            AND att.attrelid = con.conrelid
-          LEFT JOIN pg_catalog.pg_class frel ON frel.oid = con.confrelid
-          LEFT JOIN pg_catalog.pg_namespace fnsp ON fnsp.oid = frel.relnamespace
-          LEFT JOIN pg_catalog.pg_attribute fatt ON fatt.attnum = ANY (con.confkey)
-            AND fatt.attrelid = con.confrelid
-          WHERE con.contype = 'f'
-            AND nsp.nspname = ${schemaName}
-            AND rel.relname = ${tableName}`);
-    return getRows2(result);
+  const fromBase = fromType.split("(")[0].toLowerCase();
+  const toBase = toType.split("(")[0].toLowerCase();
+  if ((fromBase === "text" || fromBase === "varchar" || fromBase === "character varying") && (toBase === "jsonb" || toBase === "json")) {
+    return true;
   }
-  async getPrimaryKeys(schemaName, tableName) {
-    const result = await this.db.execute(sql21`SELECT 
-            con.conname AS name,
-            ARRAY(
-              SELECT a.attname
-              FROM pg_attribute a
-              WHERE a.attrelid = con.conrelid
-                AND a.attnum = ANY(con.conkey)
-              ORDER BY a.attnum
-            ) AS columns
-          FROM pg_constraint con
-          JOIN pg_class rel ON rel.oid = con.conrelid
-          JOIN pg_namespace nsp ON nsp.oid = con.connamespace
-          WHERE con.contype = 'p'
-            AND nsp.nspname = ${schemaName}
-            AND rel.relname = ${tableName}`);
-    return getRows2(result);
+  const needsUsingPairs = [
+    ["integer", "boolean"],
+    ["boolean", "integer"],
+    ["text", "integer"],
+    ["text", "numeric"],
+    ["text", "boolean"],
+    ["text", "uuid"],
+    ["text", "jsonb"],
+    ["text", "json"],
+    ["varchar", "integer"],
+    ["varchar", "numeric"],
+    ["varchar", "boolean"],
+    ["varchar", "uuid"],
+    ["varchar", "jsonb"],
+    ["varchar", "json"],
+    ["character varying", "jsonb"],
+    ["character varying", "json"]
+  ];
+  for (const [from, to] of needsUsingPairs) {
+    if (fromBase === from && toBase === to || fromBase === to && toBase === from) {
+      return true;
+    }
   }
-  async getUniqueConstraints(schemaName, tableName) {
-    const result = await this.db.execute(sql21`SELECT 
-            con.conname AS name,
-            ARRAY(
-              SELECT a.attname
-              FROM pg_attribute a
-              WHERE a.attrelid = con.conrelid
-                AND a.attnum = ANY(con.conkey)
-              ORDER BY a.attnum
-            ) AS columns
-          FROM pg_constraint con
-          JOIN pg_class rel ON rel.oid = con.conrelid
-          JOIN pg_namespace nsp ON nsp.oid = con.connamespace
-          WHERE con.contype = 'u'
-            AND nsp.nspname = ${schemaName}
-            AND rel.relname = ${tableName}`);
-    return getRows2(result);
+  return false;
+}
+function formatDefaultValue(value, type) {
+  if (value === null || value === "NULL") {
+    return "NULL";
   }
-  async getCheckConstraints(schemaName, tableName) {
-    const result = await this.db.execute(sql21`SELECT 
-            con.conname AS name,
-            pg_get_constraintdef(con.oid) AS definition
-          FROM pg_constraint con
-          JOIN pg_class rel ON rel.oid = con.conrelid
-          JOIN pg_namespace nsp ON nsp.oid = con.connamespace
-          WHERE con.contype = 'c'
-            AND nsp.nspname = ${schemaName}
-            AND rel.relname = ${tableName}`);
-    return getRows2(result);
+  if (type && (type.toLowerCase().includes("boolean") || type.toLowerCase() === "bool")) {
+    if (value === true || value === "true" || value === "t" || value === 1) {
+      return "true";
+    }
+    if (value === false || value === "false" || value === "f" || value === 0) {
+      return "false";
+    }
   }
-  async getEnums(schemaName) {
-    const result = await this.db.execute(sql21`SELECT 
-            n.nspname AS schema,
-            t.typname AS name,
-            e.enumlabel AS value,
-            e.enumsortorder AS sort_order
-          FROM pg_type t
-          JOIN pg_enum e ON t.oid = e.enumtypid
-          JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
-          WHERE n.nspname = ${schemaName}
-          ORDER BY schema, name, sort_order`);
-    return getRows2(result);
+  if (type?.match(/^(integer|bigint|smallint|numeric|decimal|real|double)/i)) {
+    return String(value);
   }
-  parseDefault(defaultValue, dataType) {
-    if (!defaultValue)
-      return;
-    const match = defaultValue.match(/^'(.*)'::/);
-    if (match) {
-      return `'${match[1]}'`;
+  if (typeof value === "string") {
+    if (value.includes("::")) {
+      return value;
     }
-    if (defaultValue.includes("nextval(")) {
-      return;
+    if (value.startsWith("'") && value.endsWith("'")) {
+      return value;
     }
-    if (dataType === "boolean") {
-      if (defaultValue === "true")
-        return "true";
-      if (defaultValue === "false")
-        return "false";
+    if (value.match(/^\w+\(\)/i) || value.includes("(") && value.includes(")")) {
+      return value;
     }
-    return defaultValue;
+    if (value.toUpperCase().startsWith("CURRENT_")) {
+      return value;
+    }
+    return `'${value.replace(/'/g, "''")}'`;
   }
-  async hasExistingTables(pluginName) {
-    const schemaName = pluginName === "@elizaos/plugin-sql" ? "public" : this.deriveSchemaName(pluginName);
-    const result = await this.db.execute(sql21`SELECT COUNT(*) AS count
-          FROM information_schema.tables
-          WHERE table_schema = ${schemaName}
-            AND table_type = 'BASE TABLE'`);
-    const firstRow = result.rows?.[0];
-    const count = parseInt(firstRow && firstRow.count || "0", 10);
-    return count > 0;
+  return String(value);
+}
+function generateCreateIndexSQL(index7) {
+  const unique3 = index7.isUnique ? "UNIQUE " : "";
+  const method = index7.method || "btree";
+  const columns = index7.columns.map((c) => {
+    if (c.isExpression) {
+      return c.expression;
+    }
+    return `"${c.expression}"${c.asc === false ? " DESC" : ""}`;
+  }).join(", ");
+  const indexName = index7.name.includes(".") ? index7.name.split(".")[1] : index7.name;
+  let tableRef;
+  const indexTable = index7.table;
+  if (indexTable?.includes(".")) {
+    const [schema, table] = indexTable.split(".");
+    tableRef = `"${schema}"."${table}"`;
+  } else {
+    tableRef = `"${indexTable || ""}"`;
   }
-  deriveSchemaName(pluginName) {
-    return pluginName.replace("@", "").replace("/", "_").replace(/-/g, "_").toLowerCase();
+  return `CREATE ${unique3}INDEX "${indexName}" ON ${tableRef} USING ${method} (${columns});`;
+}
+function generateDropIndexSQL(index7) {
+  const indexNameFull = typeof index7 === "string" ? index7 : index7.name;
+  const indexName = indexNameFull.includes(".") ? indexNameFull.split(".")[1] : indexNameFull;
+  return `DROP INDEX IF EXISTS "${indexName}";`;
+}
+function generateCreateForeignKeySQL(fk) {
+  const schemaFrom = fk.schemaFrom || "public";
+  const schemaTo = fk.schemaTo || "public";
+  const tableFrom = fk.tableFrom;
+  const columnsFrom = fk.columnsFrom.map((c) => `"${c}"`).join(", ");
+  const columnsTo = fk.columnsTo.map((c) => `"${c}"`).join(", ");
+  let sql22 = `ALTER TABLE "${schemaFrom}"."${tableFrom}" ADD CONSTRAINT "${fk.name}" FOREIGN KEY (${columnsFrom}) REFERENCES "${schemaTo}"."${fk.tableTo}" (${columnsTo})`;
+  if (fk.onDelete) {
+    sql22 += ` ON DELETE ${fk.onDelete}`;
+  }
+  if (fk.onUpdate) {
+    sql22 += ` ON UPDATE ${fk.onUpdate}`;
+  }
+  return `${sql22};`;
+}
+function generateDropForeignKeySQL(fk) {
+  const [schema, tableName] = fk.tableFrom ? fk.tableFrom.includes(".") ? fk.tableFrom.split(".") : ["public", fk.tableFrom] : ["public", ""];
+  return `ALTER TABLE "${schema}"."${tableName}" DROP CONSTRAINT "${fk.name}";`;
+}
+function generateCreateUniqueConstraintSQL(constraint) {
+  const table = constraint.table || "";
+  const [schema, tableName] = table.includes(".") ? table.split(".") : ["public", table];
+  const name = constraint.name;
+  const columns = constraint.columns.map((c) => `"${c}"`).join(", ");
+  let sql22 = `ALTER TABLE "${schema}"."${tableName}" ADD CONSTRAINT "${name}" UNIQUE`;
+  if (constraint.nullsNotDistinct) {
+    sql22 += ` NULLS NOT DISTINCT`;
   }
+  sql22 += ` (${columns});`;
+  return sql22;
+}
+function generateDropUniqueConstraintSQL(constraint) {
+  const table = constraint.table || "";
+  const [schema, tableName] = table.includes(".") ? table.split(".") : ["public", table];
+  return `ALTER TABLE "${schema}"."${tableName}" DROP CONSTRAINT "${constraint.name}";`;
+}
+function generateCreateCheckConstraintSQL(constraint) {
+  const table = constraint.table || "";
+  const [schema, tableName] = table.includes(".") ? table.split(".") : ["public", table];
+  const name = constraint.name;
+  const value = constraint.value;
+  return `ALTER TABLE "${schema}"."${tableName}" ADD CONSTRAINT "${name}" CHECK (${value});`;
 }
-var init_database_introspector = () => {};
+function generateDropCheckConstraintSQL(constraint) {
+  const table = constraint.table || "";
+  const [schema, tableName] = table.includes(".") ? table.split(".") : ["public", table];
+  return `ALTER TABLE "${schema}"."${tableName}" DROP CONSTRAINT "${constraint.name}";`;
+}
+var init_sql_generator = () => {};
 
 // runtime-migrator/extension-manager.ts
 import { logger as logger5 } from "@elizaos/core";
@@ -6032,6 +6036,546 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
       await this.db.delete(pairingAllowlistTable).where(eq2(pairingAllowlistTable.id, id));
     });
   }
+  async isReady() {
+    try {
+      await this.db.execute(sql27`SELECT 1`);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async getConnection() {
+    return this.db;
+  }
+  async transaction(callback, _options) {
+    return callback(this);
+  }
+  async getComponentsByNaturalKeys(keys) {
+    if (keys.length === 0)
+      return [];
+    const results = [];
+    for (const key of keys) {
+      const component = await this.getComponent(key.entityId, key.type, key.worldId, key.sourceEntityId);
+      results.push(component);
+    }
+    return results;
+  }
+  async getComponentsForEntities(entityIds, worldId, sourceEntityId) {
+    if (entityIds.length === 0)
+      return [];
+    return this.withDatabase(async () => {
+      const conditions = [inArray(componentTable.entityId, entityIds)];
+      if (worldId) {
+        conditions.push(eq2(componentTable.worldId, worldId));
+      }
+      if (sourceEntityId) {
+        conditions.push(eq2(componentTable.sourceEntityId, sourceEntityId));
+      }
+      const result = await this.db.select().from(componentTable).where(and(...conditions));
+      return result.map((component) => ({
+        ...component,
+        id: component.id,
+        entityId: component.entityId,
+        agentId: component.agentId,
+        roomId: component.roomId,
+        worldId: component.worldId ?? "",
+        sourceEntityId: component.sourceEntityId ?? "",
+        data: component.data,
+        createdAt: component.createdAt.getTime()
+      }));
+    });
+  }
+  async createComponents(components) {
+    if (components.length === 0)
+      return [];
+    return this.withDatabase(async () => {
+      const ids = [];
+      for (const component of components) {
+        const success = await this.createComponent(component);
+        if (success)
+          ids.push(component.id);
+      }
+      return ids;
+    });
+  }
+  async getComponentsByIds(componentIds) {
+    if (componentIds.length === 0)
+      return [];
+    return this.withDatabase(async () => {
+      const result = await this.db.select().from(componentTable).where(inArray(componentTable.id, componentIds));
+      return result.map((component) => ({
+        ...component,
+        id: component.id,
+        entityId: component.entityId,
+        agentId: component.agentId,
+        roomId: component.roomId,
+        worldId: component.worldId ?? "",
+        sourceEntityId: component.sourceEntityId ?? "",
+        data: component.data,
+        createdAt: component.createdAt.getTime()
+      }));
+    });
+  }
+  async updateComponents(components) {
+    for (const component of components) {
+      await this.updateComponent(component);
+    }
+  }
+  async deleteComponents(componentIds) {
+    if (componentIds.length === 0)
+      return;
+    return this.withDatabase(async () => {
+      await this.db.delete(componentTable).where(inArray(componentTable.id, componentIds));
+    });
+  }
+  async upsertComponents(components, _options) {
+    for (const component of components) {
+      const existing = await this.getComponent(component.entityId, component.type, component.worldId, component.sourceEntityId);
+      if (existing) {
+        await this.updateComponent({ ...component, id: existing.id });
+      } else {
+        await this.createComponent(component);
+      }
+    }
+  }
+  async patchComponents(_updates, _options) {}
+  async upsertEntities(entities) {
+    for (const entity of entities) {
+      const existing = await this.getEntitiesByIds([entity.id]);
+      if (existing && existing.length > 0) {
+        await this.updateEntity(entity);
+      } else {
+        await this.createEntities([entity]);
+      }
+    }
+  }
+  async queryEntities(params) {
+    if (params.entityIds?.length) {
+      const entities = await this.getEntitiesByIds(params.entityIds);
+      return entities || [];
+    }
+    return this.withDatabase(async () => {
+      const conditions = [];
+      if (params.agentId) {
+        conditions.push(eq2(entityTable.agentId, params.agentId));
+      }
+      if (params.componentType) {
+        const subquery = sql27`EXISTS (
+          SELECT 1 FROM ${componentTable}
+          WHERE ${componentTable.entityId} = ${entityTable.id}
+          AND ${componentTable.type} = ${params.componentType}
+        )`;
+        conditions.push(subquery);
+      }
+      let query = this.db.select().from(entityTable).where(conditions.length > 0 ? and(...conditions) : undefined);
+      if (params.limit) {
+        query = query.limit(params.limit);
+      }
+      if (params.offset) {
+        query = query.offset(params.offset);
+      }
+      const result = await query;
+      return result.map((row) => ({
+        ...row,
+        id: row.id,
+        agentId: row.agentId,
+        names: row.names || [],
+        metadata: row.metadata || {}
+      }));
+    });
+  }
+  async updateEntities(entities) {
+    for (const entity of entities) {
+      await this.updateEntity(entity);
+    }
+  }
+  async deleteEntities(entityIds) {
+    for (const entityId of entityIds) {
+      await this.deleteEntity(entityId);
+    }
+  }
+  async getEntitiesForRooms(roomIds, includeComponents) {
+    const result = [];
+    for (const roomId of roomIds) {
+      const entities = await this.getEntitiesForRoom(roomId, includeComponents);
+      result.push({ roomId, entities });
+    }
+    return result;
+  }
+  async createLogs(params) {
+    for (const param of params) {
+      await this.log(param);
+    }
+  }
+  async getLogsByIds(logIds) {
+    if (logIds.length === 0)
+      return [];
+    return this.withDatabase(async () => {
+      const result = await this.db.select().from(logTable).where(inArray(logTable.id, logIds));
+      return result.map((log) => ({
+        ...log,
+        id: log.id,
+        entityId: log.entityId,
+        roomId: log.roomId,
+        type: log.type,
+        body: log.body,
+        createdAt: new Date(log.createdAt)
+      }));
+    });
+  }
+  async updateLogs(logs) {
+    return this.withDatabase(async () => {
+      for (const { id, updates } of logs) {
+        const setValues = {};
+        if (updates.body !== undefined)
+          setValues.body = updates.body;
+        if (updates.type !== undefined)
+          setValues.type = updates.type;
+        if (Object.keys(setValues).length > 0) {
+          await this.db.update(logTable).set(setValues).where(eq2(logTable.id, id));
+        }
+      }
+    });
+  }
+  async deleteLogs(logIds) {
+    if (logIds.length === 0)
+      return;
+    return this.withDatabase(async () => {
+      await this.db.delete(logTable).where(inArray(logTable.id, logIds));
+    });
+  }
+  async createMemories(memories) {
+    const ids = [];
+    for (const { memory, tableName, unique: unique3 } of memories) {
+      const memoryWithUnique = unique3 !== undefined ? { ...memory, unique: unique3 } : memory;
+      const id = await this.createMemory(memoryWithUnique, tableName);
+      ids.push(id);
+    }
+    return ids;
+  }
+  async updateMemories(memories) {
+    for (const memory of memories) {
+      await this.updateMemory(memory);
+    }
+  }
+  async upsertMemories(memories, _options) {
+    for (const { memory, tableName } of memories) {
+      if (memory.id) {
+        const existing = await this.getMemoryById(memory.id);
+        if (existing) {
+          await this.updateMemory(memory);
+          continue;
+        }
+      }
+      await this.createMemory(memory, tableName);
+    }
+  }
+  async deleteMemories(memoryIds) {
+    await this.deleteManyMemories(memoryIds);
+  }
+  async getWorldsByIds(worldIds) {
+    if (worldIds.length === 0)
+      return [];
+    return this.withDatabase(async () => {
+      const result = await this.db.select().from(worldTable).where(inArray(worldTable.id, worldIds));
+      return result.map((world) => this.mapWorldResult(world));
+    });
+  }
+  async createWorlds(worlds) {
+    const ids = [];
+    for (const world of worlds) {
+      const id = await this.createWorld(world);
+      ids.push(id);
+    }
+    return ids;
+  }
+  async deleteWorlds(worldIds) {
+    for (const id of worldIds) {
+      await this.removeWorld(id);
+    }
+  }
+  async updateWorlds(worlds) {
+    for (const world of worlds) {
+      await this.updateWorld(world);
+    }
+  }
+  async upsertWorlds(worlds) {
+    for (const world of worlds) {
+      const existing = await this.getWorld(world.id);
+      if (existing) {
+        await this.updateWorld(world);
+      } else {
+        await this.createWorld(world);
+      }
+    }
+  }
+  async deleteRoomsByWorldIds(worldIds) {
+    for (const worldId of worldIds) {
+      await this.deleteRoomsByWorldId(worldId);
+    }
+  }
+  async getRoomsByWorlds(worldIds, limit, offset) {
+    if (worldIds.length === 0)
+      return [];
+    return this.withDatabase(async () => {
+      const conditions = [
+        inArray(roomTable.worldId, worldIds),
+        eq2(roomTable.agentId, this.agentId)
+      ];
+      let query = this.db.select().from(roomTable).where(and(...conditions));
+      if (offset) {
+        query = query.offset(offset);
+      }
+      if (limit) {
+        query = query.limit(limit);
+      }
+      const result = await query;
+      return result.map((room) => ({
+        ...room,
+        id: room.id,
+        name: room.name ?? undefined,
+        agentId: room.agentId,
+        messageServerId: room.messageServerId,
+        serverId: room.messageServerId,
+        worldId: room.worldId,
+        channelId: room.channelId,
+        type: room.type,
+        metadata: room.metadata
+      }));
+    });
+  }
+  async upsertRooms(rooms) {
+    for (const room of rooms) {
+      const existing = await this.getRoomsByIds([room.id]);
+      if (existing && existing.length > 0) {
+        await this.updateRoom(room);
+      } else {
+        await this.createRooms([room]);
+      }
+    }
+  }
+  async createRoomParticipants(entityIds, roomId) {
+    const ids = [];
+    for (const entityId of entityIds) {
+      const success = await this.addParticipant(entityId, roomId);
+      if (success) {
+        ids.push(`${roomId}:${entityId}`);
+      }
+    }
+    return ids;
+  }
+  async deleteParticipants(participants) {
+    for (const { entityId, roomId } of participants) {
+      const success = await this.removeParticipant(entityId, roomId);
+      if (!success)
+        return false;
+    }
+    return true;
+  }
+  async updateParticipants(participants) {
+    for (const { entityId, roomId, updates } of participants) {
+      if (updates.roomState !== undefined) {
+        await this.setParticipantUserState(roomId, entityId, updates.roomState);
+      }
+    }
+  }
+  async updateRooms(rooms) {
+    for (const room of rooms) {
+      await this.updateRoom(room);
+    }
+  }
+  async deleteRooms(roomIds) {
+    for (const roomId of roomIds) {
+      await this.deleteRoom(roomId);
+    }
+  }
+  async getParticipantsForEntities(entityIds) {
+    const result = [];
+    for (const entityId of entityIds) {
+      const participants = await this.getParticipantsForEntity(entityId);
+      result.push(...participants);
+    }
+    return result;
+  }
+  async getParticipantsForRooms(roomIds) {
+    const result = [];
+    for (const roomId of roomIds) {
+      const entityIds = await this.getParticipantsForRoom(roomId);
+      result.push({ roomId, entityIds });
+    }
+    return result;
+  }
+  async areRoomParticipants(pairs) {
+    const results = [];
+    for (const { roomId, entityId } of pairs) {
+      const isParticipant = await this.isRoomParticipant(roomId, entityId);
+      results.push(isParticipant);
+    }
+    return results;
+  }
+  async getParticipantUserStates(pairs) {
+    const results = [];
+    for (const { roomId, entityId } of pairs) {
+      const state = await this.getParticipantUserState(roomId, entityId);
+      results.push(state);
+    }
+    return results;
+  }
+  async updateParticipantUserStates(updates) {
+    for (const { roomId, entityId, state } of updates) {
+      await this.setParticipantUserState(roomId, entityId, state);
+    }
+  }
+  async getRelationshipsByPairs(pairs) {
+    const results = [];
+    for (const pair of pairs) {
+      const rel = await this.getRelationship(pair);
+      results.push(rel);
+    }
+    return results;
+  }
+  async createRelationships(relationships) {
+    const ids = [];
+    for (const rel of relationships) {
+      const id = v4();
+      const success = await this.createRelationship(rel);
+      if (success)
+        ids.push(id);
+    }
+    return ids;
+  }
+  async getRelationshipsByIds(relationshipIds) {
+    if (relationshipIds.length === 0)
+      return [];
+    return this.withDatabase(async () => {
+      const result = await this.db.select().from(relationshipTable).where(inArray(relationshipTable.id, relationshipIds));
+      return result.map((relationship) => ({
+        ...relationship,
+        id: relationship.id,
+        sourceEntityId: relationship.sourceEntityId,
+        targetEntityId: relationship.targetEntityId,
+        agentId: relationship.agentId,
+        tags: relationship.tags ?? [],
+        metadata: relationship.metadata ?? {},
+        createdAt: relationship.createdAt.toISOString()
+      }));
+    });
+  }
+  async updateRelationships(relationships) {
+    for (const relationship of relationships) {
+      await this.updateRelationship(relationship);
+    }
+  }
+  async deleteRelationships(relationshipIds) {
+    if (relationshipIds.length === 0)
+      return;
+    return this.withDatabase(async () => {
+      await this.db.delete(relationshipTable).where(inArray(relationshipTable.id, relationshipIds));
+    });
+  }
+  async getCaches(keys) {
+    const result = new Map;
+    for (const key of keys) {
+      const value = await this.getCache(key);
+      if (value !== undefined) {
+        result.set(key, value);
+      }
+    }
+    return result;
+  }
+  async setCaches(entries) {
+    for (const { key, value } of entries) {
+      const success = await this.setCache(key, value);
+      if (!success)
+        return false;
+    }
+    return true;
+  }
+  async deleteCaches(keys) {
+    for (const key of keys) {
+      const success = await this.deleteCache(key);
+      if (!success)
+        return false;
+    }
+    return true;
+  }
+  async createTasks(tasks) {
+    const ids = [];
+    for (const task of tasks) {
+      const id = await this.createTask(task);
+      ids.push(id);
+    }
+    return ids;
+  }
+  async getTasksByIds(taskIds) {
+    const tasks = [];
+    for (const taskId of taskIds) {
+      const task = await this.getTask(taskId);
+      if (task)
+        tasks.push(task);
+    }
+    return tasks;
+  }
+  async updateTasks(updates) {
+    for (const { id, task } of updates) {
+      await this.updateTask(id, task);
+    }
+  }
+  async deleteTasks(taskIds) {
+    for (const taskId of taskIds) {
+      await this.deleteTask(taskId);
+    }
+  }
+  async getPairingAllowlists(queries) {
+    const result = [];
+    for (const { channel, agentId } of queries) {
+      const entries = await this.getPairingAllowlist(channel, agentId);
+      result.push({ channel, agentId, entries });
+    }
+    return result;
+  }
+  async createPairingRequests(requests) {
+    const ids = [];
+    for (const request of requests) {
+      const id = await this.createPairingRequest(request);
+      ids.push(id);
+    }
+    return ids;
+  }
+  async updatePairingRequests(requests) {
+    for (const request of requests) {
+      await this.updatePairingRequest(request);
+    }
+  }
+  async deletePairingRequests(ids) {
+    for (const id of ids) {
+      await this.deletePairingRequest(id);
+    }
+  }
+  async createPairingAllowlistEntries(entries) {
+    const ids = [];
+    for (const entry of entries) {
+      const id = await this.createPairingAllowlistEntry(entry);
+      ids.push(id);
+    }
+    return ids;
+  }
+  async updatePairingAllowlistEntries(entries) {
+    return this.withDatabase(async () => {
+      for (const entry of entries) {
+        if (!entry.id)
+          continue;
+        await this.db.update(pairingAllowlistTable).set({
+          metadata: entry.metadata || {}
+        }).where(eq2(pairingAllowlistTable.id, entry.id));
+      }
+    });
+  }
+  async deletePairingAllowlistEntries(ids) {
+    for (const id of ids) {
+      await this.deletePairingAllowlistEntry(id);
+    }
+  }
 }
 
 // pg/adapter.ts
@@ -6547,5 +7091,5 @@ export {
   DatabaseMigrationService
 };
 
-//# debugId=F6EE560563E18E7E64756E2164756E21
+//# debugId=42019694876F4CEA64756E2164756E21
 //# sourceMappingURL=index.node.js.map