@elizaos/plugin-sql 2.0.0-alpha.17 → 2.0.0-alpha.19

package/dist/node/index.node.js

@@ -1036,170 +1036,533 @@ 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) {
       const prevTable = prevTables[tableName];
@@ -1358,1134 +1721,783 @@ async function calculateDiff(previousSnapshot, currentSnapshot) {
             tableFrom: tableName
           });
         }
-      }
-    }
-  }
-  return diff;
-}
-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";
-function escapeSingleQuotes(str) {
-  return str.replace(/'/g, "''");
-}
-function isPgArrayType(sqlType) {
-  return sqlType.match(/.*\[\d*\].*|.*\[\].*/g) !== null;
-}
-function buildArrayString(array, sqlType) {
-  sqlType = sqlType.split("[")[0];
-  const values = array.map((value) => {
-    if (typeof value === "number" || typeof value === "bigint") {
-      return value.toString();
-    } else if (typeof value === "boolean") {
-      return value ? "true" : "false";
-    } else if (Array.isArray(value)) {
-      return buildArrayString(value, sqlType);
-    } else if (value instanceof Date) {
-      if (sqlType === "date") {
-        return `"${value.toISOString().split("T")[0]}"`;
-      } else if (sqlType === "timestamp") {
-        return `"${value.toISOString().replace("T", " ").slice(0, 23)}"`;
-      } else {
-        return `"${value.toISOString()}"`;
-      }
-    } else if (typeof value === "object") {
-      return `"${JSON.stringify(value).replaceAll('"', "\\\"")}"`;
-    }
-    return `"${value}"`;
-  }).join(",");
-  return `{${values}}`;
-}
-function extractTablesFromSchema(schema) {
-  const tables = [];
-  const exports = Object.values(schema);
-  exports.forEach((t) => {
-    if (is(t, PgTable)) {
-      tables.push(t);
-    }
-  });
-  return tables;
-}
-async function generateSnapshot(schema) {
-  const dialect = new PgDialect({ casing: undefined });
-  const tables = {};
-  const schemas = {};
-  const enums = {};
-  const pgTables = extractTablesFromSchema(schema);
-  for (const table of pgTables) {
-    const config = getTableConfig(table);
-    const {
-      name: tableName,
-      columns,
-      indexes,
-      foreignKeys,
-      schema: tableSchema,
-      primaryKeys,
-      uniqueConstraints,
-      checks
-    } = config;
-    const columnsObject = {};
-    const indexesObject = {};
-    const foreignKeysObject = {};
-    const primaryKeysObject = {};
-    const uniqueConstraintObject = {};
-    const checksObject = {};
-    columns.forEach((column) => {
-      const name = column.name;
-      const notNull = column.notNull;
-      const primaryKey4 = column.primary;
-      const sqlType = column.getSQLType();
-      const sqlTypeLowered = sqlType.toLowerCase();
-      const columnToSet = {
-        name,
-        type: sqlType,
-        primaryKey: primaryKey4,
-        notNull
-      };
-      if (column.default !== undefined) {
-        if (is(column.default, SQL)) {
-          columnToSet.default = sqlToStr(column.default, undefined);
-        } else {
-          if (typeof column.default === "string") {
-            columnToSet.default = `'${escapeSingleQuotes(column.default)}'`;
-          } else {
-            if (sqlTypeLowered === "jsonb" || sqlTypeLowered === "json") {
-              columnToSet.default = `'${JSON.stringify(column.default)}'::${sqlTypeLowered}`;
-            } else if (column.default instanceof Date) {
-              if (sqlTypeLowered === "date") {
-                columnToSet.default = `'${column.default.toISOString().split("T")[0]}'`;
-              } else if (sqlTypeLowered === "timestamp") {
-                columnToSet.default = `'${column.default.toISOString().replace("T", " ").slice(0, 23)}'`;
-              } else {
-                columnToSet.default = `'${column.default.toISOString()}'`;
-              }
-            } else if (isPgArrayType(sqlTypeLowered) && Array.isArray(column.default)) {
-              columnToSet.default = `'${buildArrayString(column.default, sqlTypeLowered)}'`;
-            } else {
-              columnToSet.default = column.default;
-            }
-          }
-        }
-      }
-      const columnWithConfig = column;
-      const columnConfig = columnWithConfig.config;
-      if (columnWithConfig.isUnique && columnConfig && columnConfig.uniqueName) {
-        uniqueConstraintObject[columnConfig.uniqueName] = {
-          name: columnConfig.uniqueName,
-          columns: [name],
-          nullsNotDistinct: columnConfig.uniqueType === "not distinct"
-        };
-      }
-      columnsObject[name] = columnToSet;
-    });
-    primaryKeys.forEach((pk) => {
-      const columnNames = pk.columns.map((c) => c.name);
-      const name = pk.getName();
-      primaryKeysObject[name] = {
-        name,
-        columns: columnNames
-      };
-    });
-    uniqueConstraints?.forEach((unq) => {
-      const columnNames = unq.columns.map((c) => c.name);
-      const name = unq.name || `${tableName}_${columnNames.join("_")}_unique`;
-      uniqueConstraintObject[name] = {
-        name,
-        columns: columnNames,
-        nullsNotDistinct: unq.nullsNotDistinct
-      };
-    });
-    foreignKeys.forEach((fk) => {
-      const reference = fk.reference();
-      const columnsFrom = reference.columns.map((it) => it.name);
-      const columnsTo = reference.foreignColumns.map((it) => it.name);
-      const tableTo = getTableConfig(reference.foreignTable).name;
-      const schemaTo = getTableConfig(reference.foreignTable).schema || "public";
-      const name = fk.getName();
-      foreignKeysObject[name] = {
-        name,
-        tableFrom: tableName,
-        schemaFrom: tableSchema,
-        tableTo,
-        schemaTo,
-        columnsFrom,
-        columnsTo,
-        onDelete: fk.onDelete || "no action",
-        onUpdate: fk.onUpdate || "no action"
-      };
-    });
-    indexes.forEach((idx) => {
-      const indexCols = idx.config.columns;
-      const indexColumns = indexCols.map((col) => {
-        if (is(col, SQL)) {
-          return {
-            expression: dialect.sqlToQuery(col).sql,
-            isExpression: true
-          };
-        } else {
-          const indexCol = {
-            expression: col.name,
-            isExpression: false,
-            asc: col.indexConfig && col.indexConfig.order === "asc"
-          };
-          if (col.indexConfig?.nulls) {
-            indexCol.nulls = col.indexConfig.nulls;
-          }
-          return indexCol;
-        }
-      });
-      const name = idx.config.name || `${tableName}_${indexColumns.map((c) => c.expression).join("_")}_index`;
-      indexesObject[name] = {
-        name,
-        columns: indexColumns,
-        isUnique: idx.config.unique || false,
-        method: idx.config.method || "btree"
-      };
-    });
-    if (checks) {
-      checks.forEach((check3) => {
-        const checkName = check3.name;
-        checksObject[checkName] = {
-          name: checkName,
-          value: dialect.sqlToQuery(check3.value).sql
-        };
-      });
-    }
-    tables[`${tableSchema || "public"}.${tableName}`] = {
-      name: tableName,
-      schema: tableSchema || "public",
-      columns: columnsObject,
-      indexes: indexesObject,
-      foreignKeys: foreignKeysObject,
-      compositePrimaryKeys: primaryKeysObject,
-      uniqueConstraints: uniqueConstraintObject,
-      checkConstraints: checksObject
-    };
-    if (tableSchema && tableSchema !== "public") {
-      schemas[tableSchema] = tableSchema;
+      }
     }
   }
-  const snapshot = {
-    version: "7",
-    dialect: "postgresql",
-    tables,
-    schemas,
-    enums,
-    _meta: {
-      schemas: {},
-      tables: {},
-      columns: {}
-    }
-  };
-  return snapshot;
-}
-function hashSnapshot(snapshot) {
-  const content = JSON.stringify(snapshot);
-  return extendedHash(content);
+  return diff;
 }
-function hasChanges(previousSnapshot, currentSnapshot) {
-  if (!previousSnapshot) {
-    return Object.keys(currentSnapshot.tables).length > 0;
-  }
-  const prevHash = hashSnapshot(previousSnapshot);
-  const currHash = hashSnapshot(currentSnapshot);
-  return prevHash !== currHash;
+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;
 }
-var sqlToStr = (sql21, _casing) => {
-  const config = {
-    escapeName: () => {
-      throw new Error("we don't support params for `sql` default values");
-    },
-    escapeParam: () => {
-      throw new Error("we don't support params for `sql` default values");
-    },
-    escapeString: () => {
-      throw new Error("we don't support params for `sql` default values");
-    },
-    casing: undefined
-  };
-  return sql21.toQuery(config).sql;
-};
-var init_snapshot_generator = () => {};
 
-// runtime-migrator/drizzle-adapters/sql-generator.ts
-import { logger as logger3 } from "@elizaos/core";
-function checkForDataLoss(diff) {
-  const result = {
-    hasDataLoss: false,
-    tablesToRemove: [],
-    columnsToRemove: [],
-    tablesToTruncate: [],
-    typeChanges: [],
-    warnings: [],
-    requiresConfirmation: false
-  };
-  if (diff.tables.deleted.length > 0) {
-    result.hasDataLoss = true;
-    result.requiresConfirmation = true;
-    result.tablesToRemove = [...diff.tables.deleted];
-    for (const table of diff.tables.deleted) {
-      result.warnings.push(`Table "${table}" will be dropped with all its data`);
-    }
-  }
-  if (diff.columns.deleted.length > 0) {
-    result.hasDataLoss = true;
-    result.requiresConfirmation = true;
-    for (const col of diff.columns.deleted) {
-      result.columnsToRemove.push(`${col.table}.${col.column}`);
-      result.warnings.push(`Column "${col.column}" in table "${col.table}" will be dropped`);
-    }
-  }
-  for (const modified of diff.columns.modified) {
-    const from = modified.changes.from;
-    const to = modified.changes.to;
-    if (!from || !to)
-      continue;
-    if (from.type !== to.type) {
-      const isDestructive = checkIfTypeChangeIsDestructive(from.type, to.type);
-      if (isDestructive) {
-        result.hasDataLoss = true;
-        result.requiresConfirmation = true;
-        result.typeChanges.push({
-          table: modified.table,
-          column: modified.column,
-          from: from.type,
-          to: to.type
-        });
-        result.tablesToTruncate.push(modified.table);
-        result.warnings.push(`Column "${modified.column}" in table "${modified.table}" changes type from "${from.type}" to "${to.type}". ` + `This may require truncating the table to avoid data conversion errors.`);
+// runtime-migrator/drizzle-adapters/snapshot-generator.ts
+import { is, SQL } from "drizzle-orm";
+import { getTableConfig, PgDialect, PgTable } from "drizzle-orm/pg-core";
+function escapeSingleQuotes(str) {
+  return str.replace(/'/g, "''");
+}
+function isPgArrayType(sqlType) {
+  return sqlType.match(/.*\[\d*\].*|.*\[\].*/g) !== null;
+}
+function buildArrayString(array, sqlType) {
+  sqlType = sqlType.split("[")[0];
+  const values = array.map((value) => {
+    if (typeof value === "number" || typeof value === "bigint") {
+      return value.toString();
+    } else if (typeof value === "boolean") {
+      return value ? "true" : "false";
+    } else if (Array.isArray(value)) {
+      return buildArrayString(value, sqlType);
+    } else if (value instanceof Date) {
+      if (sqlType === "date") {
+        return `"${value.toISOString().split("T")[0]}"`;
+      } else if (sqlType === "timestamp") {
+        return `"${value.toISOString().replace("T", " ").slice(0, 23)}"`;
+      } else {
+        return `"${value.toISOString()}"`;
       }
+    } else if (typeof value === "object") {
+      return `"${JSON.stringify(value).replaceAll('"', "\\\"")}"`;
     }
-    if (!from.notNull && to.notNull && !to.default) {
-      result.hasDataLoss = true;
-      result.requiresConfirmation = true;
-      result.warnings.push(`Column "${modified.column}" in table "${modified.table}" is becoming NOT NULL without a default value. ` + `This will fail if the table contains NULL values.`);
-    }
-  }
-  for (const added of diff.columns.added) {
-    if (added.definition.notNull && !added.definition.default) {
-      result.warnings.push(`Column "${added.column}" is being added to table "${added.table}" as NOT NULL without a default value. ` + `This will fail if the table contains data.`);
-    }
-  }
-  return result;
+    return `"${value}"`;
+  }).join(",");
+  return `{${values}}`;
 }
-function normalizeType2(type) {
-  if (!type)
-    return "";
-  const normalized = type.toLowerCase().trim();
-  if (normalized === "timestamp without time zone" || normalized === "timestamp with time zone" || normalized === "timestamptz") {
-    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]}` : ""})`;
+function extractTablesFromSchema(schema) {
+  const tables = [];
+  const exports = Object.values(schema);
+  exports.forEach((t) => {
+    if (is(t, PgTable)) {
+      tables.push(t);
     }
-    return "numeric";
-  }
-  if (normalized.startsWith("character varying")) {
-    return normalized.replace("character varying", "varchar");
-  }
-  if (normalized === "text[]" || normalized === "_text") {
-    return "text[]";
-  }
-  return normalized;
-}
-function checkIfTypeChangeIsDestructive(fromType, toType) {
-  const normalizedFrom = normalizeType2(fromType);
-  const normalizedTo = normalizeType2(toType);
-  if (normalizedFrom === normalizedTo) {
-    return false;
-  }
-  const safeConversions = {
-    smallint: ["integer", "bigint", "numeric", "real", "double precision"],
-    integer: ["bigint", "numeric", "real", "double precision"],
-    bigint: ["numeric"],
-    real: ["double precision"],
-    varchar: ["text"],
-    char: ["varchar", "text"],
-    citext: ["text"],
-    text: ["citext"],
-    uuid: ["text", "varchar"],
-    timestamp: ["timestamp"],
-    date: ["timestamp"],
-    time: ["timetz"]
-  };
-  const fromBase = normalizedFrom.split("(")[0];
-  const toBase = normalizedTo.split("(")[0];
-  if (fromBase === toBase) {
-    return false;
-  }
-  const safeTo = safeConversions[fromBase];
-  if (safeTo?.includes(toBase)) {
-    return false;
-  }
-  return true;
+  });
+  return tables;
 }
-async function generateMigrationSQL(previousSnapshot, currentSnapshot, diff) {
-  const statements = [];
-  if (!diff) {
-    const { calculateDiff: calculateDiff2 } = await Promise.resolve().then(() => exports_diff_calculator);
-    diff = await calculateDiff2(previousSnapshot, currentSnapshot);
-  }
-  const dataLossCheck = checkForDataLoss(diff);
-  if (dataLossCheck.warnings.length > 0) {
-    logger3.warn({ src: "plugin:sql", warnings: dataLossCheck.warnings }, "Schema changes may cause data loss");
-  }
-  const schemasToCreate = new Set;
-  for (const tableName of diff.tables.created) {
-    const table = currentSnapshot.tables[tableName];
-    if (table) {
-      const schema = table.schema || "public";
-      if (schema !== "public") {
-        schemasToCreate.add(schema);
+async function generateSnapshot(schema) {
+  const dialect = new PgDialect({ casing: undefined });
+  const tables = {};
+  const schemas = {};
+  const enums = {};
+  const pgTables = extractTablesFromSchema(schema);
+  for (const table of pgTables) {
+    const config = getTableConfig(table);
+    const {
+      name: tableName,
+      columns,
+      indexes,
+      foreignKeys,
+      schema: tableSchema,
+      primaryKeys,
+      uniqueConstraints,
+      checks
+    } = config;
+    const columnsObject = {};
+    const indexesObject = {};
+    const foreignKeysObject = {};
+    const primaryKeysObject = {};
+    const uniqueConstraintObject = {};
+    const checksObject = {};
+    columns.forEach((column) => {
+      const name = column.name;
+      const notNull = column.notNull;
+      const primaryKey4 = column.primary;
+      const sqlType = column.getSQLType();
+      const sqlTypeLowered = sqlType.toLowerCase();
+      const columnToSet = {
+        name,
+        type: sqlType,
+        primaryKey: primaryKey4,
+        notNull
+      };
+      if (column.default !== undefined) {
+        if (is(column.default, SQL)) {
+          columnToSet.default = sqlToStr(column.default, undefined);
+        } else {
+          if (typeof column.default === "string") {
+            columnToSet.default = `'${escapeSingleQuotes(column.default)}'`;
+          } else {
+            if (sqlTypeLowered === "jsonb" || sqlTypeLowered === "json") {
+              columnToSet.default = `'${JSON.stringify(column.default)}'::${sqlTypeLowered}`;
+            } else if (column.default instanceof Date) {
+              if (sqlTypeLowered === "date") {
+                columnToSet.default = `'${column.default.toISOString().split("T")[0]}'`;
+              } else if (sqlTypeLowered === "timestamp") {
+                columnToSet.default = `'${column.default.toISOString().replace("T", " ").slice(0, 23)}'`;
+              } else {
+                columnToSet.default = `'${column.default.toISOString()}'`;
+              }
+            } else if (isPgArrayType(sqlTypeLowered) && Array.isArray(column.default)) {
+              columnToSet.default = `'${buildArrayString(column.default, sqlTypeLowered)}'`;
+            } else {
+              columnToSet.default = column.default;
+            }
+          }
+        }
       }
-    }
-  }
-  for (const schema of schemasToCreate) {
-    statements.push(`CREATE SCHEMA IF NOT EXISTS "${schema}";`);
-  }
-  const createTableStatements = [];
-  const foreignKeyStatements = [];
-  for (const tableName of diff.tables.created) {
-    const table = currentSnapshot.tables[tableName];
-    if (table) {
-      const { tableSQL, fkSQLs } = generateCreateTableSQL(tableName, table);
-      createTableStatements.push(tableSQL);
-      foreignKeyStatements.push(...fkSQLs);
-    }
-  }
-  statements.push(...createTableStatements);
-  const uniqueFKs = new Set;
-  const dedupedFKStatements = [];
-  for (const fkSQL of foreignKeyStatements) {
-    const match = fkSQL.match(/ADD CONSTRAINT "([^"]+)"/);
-    if (match) {
-      const constraintName = match[1];
-      if (!uniqueFKs.has(constraintName)) {
-        uniqueFKs.add(constraintName);
-        dedupedFKStatements.push(fkSQL);
+      const columnWithConfig = column;
+      const columnConfig = columnWithConfig.config;
+      if (columnWithConfig.isUnique && columnConfig && columnConfig.uniqueName) {
+        uniqueConstraintObject[columnConfig.uniqueName] = {
+          name: columnConfig.uniqueName,
+          columns: [name],
+          nullsNotDistinct: columnConfig.uniqueType === "not distinct"
+        };
       }
-    } else {
-      dedupedFKStatements.push(fkSQL);
-    }
-  }
-  statements.push(...dedupedFKStatements);
-  for (const tableName of diff.tables.deleted) {
-    const [schema, name] = tableName.includes(".") ? tableName.split(".") : ["public", tableName];
-    statements.push(`DROP TABLE IF EXISTS "${schema}"."${name}" CASCADE;`);
-  }
-  for (const added of diff.columns.added) {
-    statements.push(generateAddColumnSQL(added.table, added.column, added.definition));
-  }
-  for (const deleted of diff.columns.deleted) {
-    statements.push(generateDropColumnSQL(deleted.table, deleted.column));
-  }
-  for (const modified of diff.columns.modified) {
-    const alterStatements = generateAlterColumnSQL(modified.table, modified.column, modified.changes);
-    statements.push(...alterStatements);
-  }
-  for (const index7 of diff.indexes.deleted) {
-    statements.push(generateDropIndexSQL(index7));
-  }
-  for (const alteredIndex of diff.indexes.altered) {
-    statements.push(generateDropIndexSQL(alteredIndex.old));
-  }
-  for (const index7 of diff.indexes.created) {
-    statements.push(generateCreateIndexSQL(index7));
-  }
-  for (const alteredIndex of diff.indexes.altered) {
-    statements.push(generateCreateIndexSQL(alteredIndex.new));
-  }
-  for (const constraint of diff.uniqueConstraints.created) {
-    const isNewTable = diff.tables.created.some((tableName) => {
-      const [schema, table] = tableName.includes(".") ? tableName.split(".") : ["public", tableName];
-      const constraintTable = constraint.table || "";
-      const [constraintSchema, constraintTableName] = constraintTable.includes(".") ? constraintTable.split(".") : ["public", constraintTable];
-      return table === constraintTableName && schema === constraintSchema;
+      columnsObject[name] = columnToSet;
     });
-    if (!isNewTable) {
-      statements.push(generateCreateUniqueConstraintSQL(constraint));
-    }
-  }
-  for (const constraint of diff.uniqueConstraints.deleted) {
-    statements.push(generateDropUniqueConstraintSQL(constraint));
-  }
-  for (const constraint of diff.checkConstraints.created) {
-    const isNewTable = diff.tables.created.some((tableName) => {
-      const [schema, table] = tableName.includes(".") ? tableName.split(".") : ["public", tableName];
-      const constraintTable = constraint.table || "";
-      const [constraintSchema, constraintTableName] = constraintTable.includes(".") ? constraintTable.split(".") : ["public", constraintTable];
-      return table === constraintTableName && schema === constraintSchema;
+    primaryKeys.forEach((pk) => {
+      const columnNames = pk.columns.map((c) => c.name);
+      const name = pk.getName();
+      primaryKeysObject[name] = {
+        name,
+        columns: columnNames
+      };
     });
-    if (!isNewTable) {
-      statements.push(generateCreateCheckConstraintSQL(constraint));
-    }
-  }
-  for (const constraint of diff.checkConstraints.deleted) {
-    statements.push(generateDropCheckConstraintSQL(constraint));
-  }
-  for (const fk of diff.foreignKeys.deleted) {
-    statements.push(generateDropForeignKeySQL(fk));
-  }
-  for (const alteredFK of diff.foreignKeys.altered) {
-    statements.push(generateDropForeignKeySQL(alteredFK.old));
-  }
-  for (const fk of diff.foreignKeys.created) {
-    const tableFrom = fk.tableFrom || "";
-    const schemaFrom = fk.schemaFrom || "public";
-    const isNewTable = diff.tables.created.some((tableName) => {
-      const [createdSchema, createdTable] = tableName.includes(".") ? tableName.split(".") : ["public", tableName];
-      return createdTable === tableFrom && createdSchema === schemaFrom;
+    uniqueConstraints?.forEach((unq) => {
+      const columnNames = unq.columns.map((c) => c.name);
+      const name = unq.name || `${tableName}_${columnNames.join("_")}_unique`;
+      uniqueConstraintObject[name] = {
+        name,
+        columns: columnNames,
+        nullsNotDistinct: unq.nullsNotDistinct
+      };
     });
-    if (!isNewTable) {
-      statements.push(generateCreateForeignKeySQL(fk));
+    foreignKeys.forEach((fk) => {
+      const reference = fk.reference();
+      const columnsFrom = reference.columns.map((it) => it.name);
+      const columnsTo = reference.foreignColumns.map((it) => it.name);
+      const tableTo = getTableConfig(reference.foreignTable).name;
+      const schemaTo = getTableConfig(reference.foreignTable).schema || "public";
+      const name = fk.getName();
+      foreignKeysObject[name] = {
+        name,
+        tableFrom: tableName,
+        schemaFrom: tableSchema,
+        tableTo,
+        schemaTo,
+        columnsFrom,
+        columnsTo,
+        onDelete: fk.onDelete || "no action",
+        onUpdate: fk.onUpdate || "no action"
+      };
+    });
+    indexes.forEach((idx) => {
+      const indexCols = idx.config.columns;
+      const indexColumns = indexCols.map((col) => {
+        if (is(col, SQL)) {
+          return {
+            expression: dialect.sqlToQuery(col).sql,
+            isExpression: true
+          };
+        } else {
+          const indexCol = {
+            expression: col.name,
+            isExpression: false,
+            asc: col.indexConfig && col.indexConfig.order === "asc"
+          };
+          if (col.indexConfig?.nulls) {
+            indexCol.nulls = col.indexConfig.nulls;
+          }
+          return indexCol;
+        }
+      });
+      const name = idx.config.name || `${tableName}_${indexColumns.map((c) => c.expression).join("_")}_index`;
+      indexesObject[name] = {
+        name,
+        columns: indexColumns,
+        isUnique: idx.config.unique || false,
+        method: idx.config.method || "btree"
+      };
+    });
+    if (checks) {
+      checks.forEach((check3) => {
+        const checkName = check3.name;
+        checksObject[checkName] = {
+          name: checkName,
+          value: dialect.sqlToQuery(check3.value).sql
+        };
+      });
+    }
+    tables[`${tableSchema || "public"}.${tableName}`] = {
+      name: tableName,
+      schema: tableSchema || "public",
+      columns: columnsObject,
+      indexes: indexesObject,
+      foreignKeys: foreignKeysObject,
+      compositePrimaryKeys: primaryKeysObject,
+      uniqueConstraints: uniqueConstraintObject,
+      checkConstraints: checksObject
+    };
+    if (tableSchema && tableSchema !== "public") {
+      schemas[tableSchema] = tableSchema;
     }
   }
-  for (const alteredFK of diff.foreignKeys.altered) {
-    statements.push(generateCreateForeignKeySQL(alteredFK.new));
-  }
-  return statements;
+  const snapshot = {
+    version: "7",
+    dialect: "postgresql",
+    tables,
+    schemas,
+    enums,
+    _meta: {
+      schemas: {},
+      tables: {},
+      columns: {}
+    }
+  };
+  return snapshot;
+}
+function hashSnapshot(snapshot) {
+  const content = JSON.stringify(snapshot);
+  return extendedHash(content);
 }
-function generateCreateTableSQL(fullTableName, table) {
-  const [schema, tableName] = fullTableName.includes(".") ? fullTableName.split(".") : ["public", fullTableName];
-  const columns = [];
-  const fkSQLs = [];
-  for (const [colName, colDef] of Object.entries(table.columns || {})) {
-    columns.push(generateColumnDefinition(colName, colDef));
+function hasChanges(previousSnapshot, currentSnapshot) {
+  if (!previousSnapshot) {
+    return Object.keys(currentSnapshot.tables).length > 0;
   }
-  const primaryKeys = table.compositePrimaryKeys || {};
-  for (const [pkName, pkDef] of Object.entries(primaryKeys)) {
-    const pk = pkDef;
-    if (pk.columns && pk.columns.length > 0) {
-      columns.push(`CONSTRAINT "${pkName}" PRIMARY KEY (${pk.columns.map((c) => `"${c}"`).join(", ")})`);
+  const prevHash = hashSnapshot(previousSnapshot);
+  const currHash = hashSnapshot(currentSnapshot);
+  return prevHash !== currHash;
+}
+var sqlToStr = (sql22, _casing) => {
+  const config = {
+    escapeName: () => {
+      throw new Error("we don't support params for `sql` default values");
+    },
+    escapeParam: () => {
+      throw new Error("we don't support params for `sql` default values");
+    },
+    escapeString: () => {
+      throw new Error("we don't support params for `sql` default values");
+    },
+    casing: undefined
+  };
+  return sql22.toQuery(config).sql;
+};
+var init_snapshot_generator = () => {};
+
+// runtime-migrator/drizzle-adapters/sql-generator.ts
+import { logger as logger4 } from "@elizaos/core";
+function checkForDataLoss(diff) {
+  const result = {
+    hasDataLoss: false,
+    tablesToRemove: [],
+    columnsToRemove: [],
+    tablesToTruncate: [],
+    typeChanges: [],
+    warnings: [],
+    requiresConfirmation: false
+  };
+  if (diff.tables.deleted.length > 0) {
+    result.hasDataLoss = true;
+    result.requiresConfirmation = true;
+    result.tablesToRemove = [...diff.tables.deleted];
+    for (const table of diff.tables.deleted) {
+      result.warnings.push(`Table "${table}" will be dropped with all its data`);
     }
   }
-  const uniqueConstraints = table.uniqueConstraints || {};
-  for (const [uqName, uqDef] of Object.entries(uniqueConstraints)) {
-    const uq = uqDef;
-    if (uq.columns && uq.columns.length > 0) {
-      const uniqueDef = uq.nullsNotDistinct ? `CONSTRAINT "${uqName}" UNIQUE NULLS NOT DISTINCT (${uq.columns.map((c) => `"${c}"`).join(", ")})` : `CONSTRAINT "${uqName}" UNIQUE (${uq.columns.map((c) => `"${c}"`).join(", ")})`;
-      columns.push(uniqueDef);
+  if (diff.columns.deleted.length > 0) {
+    result.hasDataLoss = true;
+    result.requiresConfirmation = true;
+    for (const col of diff.columns.deleted) {
+      result.columnsToRemove.push(`${col.table}.${col.column}`);
+      result.warnings.push(`Column "${col.column}" in table "${col.table}" will be dropped`);
     }
   }
-  const checkConstraints = table.checkConstraints || {};
-  for (const [checkName, checkDef] of Object.entries(checkConstraints)) {
-    const check3 = checkDef;
-    if (check3.value) {
-      columns.push(`CONSTRAINT "${checkName}" CHECK (${check3.value})`);
+  for (const modified of diff.columns.modified) {
+    const from = modified.changes.from;
+    const to = modified.changes.to;
+    if (!from || !to)
+      continue;
+    if (from.type !== to.type) {
+      const isDestructive = checkIfTypeChangeIsDestructive(from.type, to.type);
+      if (isDestructive) {
+        result.hasDataLoss = true;
+        result.requiresConfirmation = true;
+        result.typeChanges.push({
+          table: modified.table,
+          column: modified.column,
+          from: from.type,
+          to: to.type
+        });
+        result.tablesToTruncate.push(modified.table);
+        result.warnings.push(`Column "${modified.column}" in table "${modified.table}" changes type from "${from.type}" to "${to.type}". ` + `This may require truncating the table to avoid data conversion errors.`);
+      }
+    }
+    if (!from.notNull && to.notNull && !to.default) {
+      result.hasDataLoss = true;
+      result.requiresConfirmation = true;
+      result.warnings.push(`Column "${modified.column}" in table "${modified.table}" is becoming NOT NULL without a default value. ` + `This will fail if the table contains NULL values.`);
     }
   }
-  const tableSQL = `CREATE TABLE IF NOT EXISTS "${schema}"."${tableName}" (
-  ${columns.join(`,
-  `)}
-);`;
-  const foreignKeys = table.foreignKeys || {};
-  for (const [fkName, fkDef] of Object.entries(foreignKeys)) {
-    const fk = fkDef;
-    const fkSQL = `ALTER TABLE "${schema}"."${tableName}" ADD CONSTRAINT "${fkName}" FOREIGN KEY (${fk.columnsFrom.map((c) => `"${c}"`).join(", ")}) REFERENCES "${fk.schemaTo || "public"}"."${fk.tableTo}" (${fk.columnsTo.map((c) => `"${c}"`).join(", ")})${fk.onDelete ? ` ON DELETE ${fk.onDelete}` : ""}${fk.onUpdate ? ` ON UPDATE ${fk.onUpdate}` : ""};`;
-    fkSQLs.push(fkSQL);
+  for (const added of diff.columns.added) {
+    if (added.definition.notNull && !added.definition.default) {
+      result.warnings.push(`Column "${added.column}" is being added to table "${added.table}" as NOT NULL without a default value. ` + `This will fail if the table contains data.`);
+    }
   }
-  return { tableSQL, fkSQLs };
+  return result;
 }
-function generateColumnDefinition(name, def) {
-  let sql21 = `"${name}" ${def.type}`;
-  if (def.primaryKey && !def.type.includes("SERIAL")) {
-    sql21 += " PRIMARY KEY";
+function normalizeType2(type) {
+  if (!type)
+    return "";
+  const normalized = type.toLowerCase().trim();
+  if (normalized === "timestamp without time zone" || normalized === "timestamp with time zone" || normalized === "timestamptz") {
+    return "timestamp";
   }
-  if (def.notNull) {
-    sql21 += " NOT NULL";
+  if (normalized === "serial") {
+    return "integer";
   }
-  if (def.default !== undefined) {
-    const defaultValue = formatDefaultValue(def.default, def.type);
-    sql21 += ` DEFAULT ${defaultValue}`;
+  if (normalized === "bigserial") {
+    return "bigint";
   }
-  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 (normalized === "smallserial") {
+    return "smallint";
   }
-  if (definition.default !== undefined) {
-    const defaultValue = formatDefaultValue(definition.default, definition.type);
-    if (defaultValue) {
-      parts.push(`DEFAULT ${defaultValue}`);
+  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";
   }
-  const definitionWithGenerated = definition;
-  if (definitionWithGenerated.generated) {
-    parts.push(`GENERATED ALWAYS AS (${definitionWithGenerated.generated}) STORED`);
+  if (normalized.startsWith("character varying")) {
+    return normalized.replace("character varying", "varchar");
   }
-  if (definition.notNull) {
-    parts.push("NOT NULL");
+  if (normalized === "text[]" || normalized === "_text") {
+    return "text[]";
   }
-  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;`;
+  return normalized;
 }
-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;`);
-    }
+function checkIfTypeChangeIsDestructive(fromType, toType) {
+  const normalizedFrom = normalizeType2(fromType);
+  const normalizedTo = normalizeType2(toType);
+  if (normalizedFrom === normalizedTo) {
+    return false;
   }
-  return statements;
-}
-function checkIfNeedsUsingClause(fromType, toType) {
-  if (!fromType || !toType)
+  const safeConversions = {
+    smallint: ["integer", "bigint", "numeric", "real", "double precision"],
+    integer: ["bigint", "numeric", "real", "double precision"],
+    bigint: ["numeric"],
+    real: ["double precision"],
+    varchar: ["text"],
+    char: ["varchar", "text"],
+    citext: ["text"],
+    text: ["citext"],
+    uuid: ["text", "varchar"],
+    timestamp: ["timestamp"],
+    date: ["timestamp"],
+    time: ["timetz"]
+  };
+  const fromBase = normalizedFrom.split("(")[0];
+  const toBase = normalizedTo.split("(")[0];
+  if (fromBase === toBase) {
     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 safeTo = safeConversions[fromBase];
+  if (safeTo?.includes(toBase)) {
+    return false;
   }
-  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 true;
+}
+async function generateMigrationSQL(previousSnapshot, currentSnapshot, diff) {
+  const statements = [];
+  if (!diff) {
+    const { calculateDiff: calculateDiff2 } = await Promise.resolve().then(() => exports_diff_calculator);
+    diff = await calculateDiff2(previousSnapshot, currentSnapshot);
   }
-  return false;
-}
-function formatDefaultValue(value, type) {
-  if (value === null || value === "NULL") {
-    return "NULL";
+  const dataLossCheck = checkForDataLoss(diff);
+  if (dataLossCheck.warnings.length > 0) {
+    logger4.warn({ src: "plugin:sql", warnings: dataLossCheck.warnings }, "Schema changes may cause data loss");
   }
-  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";
+  const schemasToCreate = new Set;
+  for (const tableName of diff.tables.created) {
+    const table = currentSnapshot.tables[tableName];
+    if (table) {
+      const schema = table.schema || "public";
+      if (schema !== "public") {
+        schemasToCreate.add(schema);
+      }
     }
   }
-  if (type?.match(/^(integer|bigint|smallint|numeric|decimal|real|double)/i)) {
-    return String(value);
+  for (const schema of schemasToCreate) {
+    statements.push(`CREATE SCHEMA IF NOT EXISTS "${schema}";`);
   }
-  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;
+  const createTableStatements = [];
+  const foreignKeyStatements = [];
+  for (const tableName of diff.tables.created) {
+    const table = currentSnapshot.tables[tableName];
+    if (table) {
+      const { tableSQL, fkSQLs } = generateCreateTableSQL(tableName, table);
+      createTableStatements.push(tableSQL);
+      foreignKeyStatements.push(...fkSQLs);
     }
-    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;
+  statements.push(...createTableStatements);
+  const uniqueFKs = new Set;
+  const dedupedFKStatements = [];
+  for (const fkSQL of foreignKeyStatements) {
+    const match = fkSQL.match(/ADD CONSTRAINT "([^"]+)"/);
+    if (match) {
+      const constraintName = match[1];
+      if (!uniqueFKs.has(constraintName)) {
+        uniqueFKs.add(constraintName);
+        dedupedFKStatements.push(fkSQL);
+      }
+    } else {
+      dedupedFKStatements.push(fkSQL);
     }
-    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}`;
+  statements.push(...dedupedFKStatements);
+  for (const tableName of diff.tables.deleted) {
+    const [schema, name] = tableName.includes(".") ? tableName.split(".") : ["public", tableName];
+    statements.push(`DROP TABLE IF EXISTS "${schema}"."${name}" CASCADE;`);
   }
-  if (fk.onUpdate) {
-    sql21 += ` ON UPDATE ${fk.onUpdate}`;
+  for (const added of diff.columns.added) {
+    statements.push(generateAddColumnSQL(added.table, added.column, added.definition));
   }
-  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}";`;
-}
-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 sql21 = `ALTER TABLE "${schema}"."${tableName}" ADD CONSTRAINT "${name}" UNIQUE`;
-  if (constraint.nullsNotDistinct) {
-    sql21 += ` NULLS NOT DISTINCT`;
+  for (const deleted of diff.columns.deleted) {
+    statements.push(generateDropColumnSQL(deleted.table, deleted.column));
   }
-  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}";`;
-}
-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});`;
-}
-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/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;
+  for (const modified of diff.columns.modified) {
+    const alterStatements = generateAlterColumnSQL(modified.table, modified.column, modified.changes);
+    statements.push(...alterStatements);
   }
-  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;
-      }
+  for (const index7 of diff.indexes.deleted) {
+    statements.push(generateDropIndexSQL(index7));
+  }
+  for (const alteredIndex of diff.indexes.altered) {
+    statements.push(generateDropIndexSQL(alteredIndex.old));
+  }
+  for (const index7 of diff.indexes.created) {
+    statements.push(generateCreateIndexSQL(index7));
+  }
+  for (const alteredIndex of diff.indexes.altered) {
+    statements.push(generateCreateIndexSQL(alteredIndex.new));
+  }
+  for (const constraint of diff.uniqueConstraints.created) {
+    const isNewTable = diff.tables.created.some((tableName) => {
+      const [schema, table] = tableName.includes(".") ? tableName.split(".") : ["public", tableName];
+      const constraintTable = constraint.table || "";
+      const [constraintSchema, constraintTableName] = constraintTable.includes(".") ? constraintTable.split(".") : ["public", constraintTable];
+      return table === constraintTableName && schema === constraintSchema;
+    });
+    if (!isNewTable) {
+      statements.push(generateCreateUniqueConstraintSQL(constraint));
+    }
+  }
+  for (const constraint of diff.uniqueConstraints.deleted) {
+    statements.push(generateDropUniqueConstraintSQL(constraint));
+  }
+  for (const constraint of diff.checkConstraints.created) {
+    const isNewTable = diff.tables.created.some((tableName) => {
+      const [schema, table] = tableName.includes(".") ? tableName.split(".") : ["public", tableName];
+      const constraintTable = constraint.table || "";
+      const [constraintSchema, constraintTableName] = constraintTable.includes(".") ? constraintTable.split(".") : ["public", constraintTable];
+      return table === constraintTableName && schema === constraintSchema;
+    });
+    if (!isNewTable) {
+      statements.push(generateCreateCheckConstraintSQL(constraint));
     }
-    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);
+  }
+  for (const constraint of diff.checkConstraints.deleted) {
+    statements.push(generateDropCheckConstraintSQL(constraint));
+  }
+  for (const fk of diff.foreignKeys.deleted) {
+    statements.push(generateDropForeignKeySQL(fk));
+  }
+  for (const alteredFK of diff.foreignKeys.altered) {
+    statements.push(generateDropForeignKeySQL(alteredFK.old));
+  }
+  for (const fk of diff.foreignKeys.created) {
+    const tableFrom = fk.tableFrom || "";
+    const schemaFrom = fk.schemaFrom || "public";
+    const isNewTable = diff.tables.created.some((tableName) => {
+      const [createdSchema, createdTable] = tableName.includes(".") ? tableName.split(".") : ["public", tableName];
+      return createdTable === tableFrom && createdSchema === schemaFrom;
+    });
+    if (!isNewTable) {
+      statements.push(generateCreateForeignKeySQL(fk));
     }
-    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);
+  for (const alteredFK of diff.foreignKeys.altered) {
+    statements.push(generateCreateForeignKeySQL(alteredFK.new));
   }
-  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);
+  return statements;
+}
+function generateCreateTableSQL(fullTableName, table) {
+  const [schema, tableName] = fullTableName.includes(".") ? fullTableName.split(".") : ["public", fullTableName];
+  const columns = [];
+  const fkSQLs = [];
+  for (const [colName, colDef] of Object.entries(table.columns || {})) {
+    columns.push(generateColumnDefinition(colName, colDef));
   }
-  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);
+  const primaryKeys = table.compositePrimaryKeys || {};
+  for (const [pkName, pkDef] of Object.entries(primaryKeys)) {
+    const pk = pkDef;
+    if (pk.columns && pk.columns.length > 0) {
+      columns.push(`CONSTRAINT "${pkName}" PRIMARY KEY (${pk.columns.map((c) => `"${c}"`).join(", ")})`);
+    }
   }
-  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 uniqueConstraints = table.uniqueConstraints || {};
+  for (const [uqName, uqDef] of Object.entries(uniqueConstraints)) {
+    const uq = uqDef;
+    if (uq.columns && uq.columns.length > 0) {
+      const uniqueDef = uq.nullsNotDistinct ? `CONSTRAINT "${uqName}" UNIQUE NULLS NOT DISTINCT (${uq.columns.map((c) => `"${c}"`).join(", ")})` : `CONSTRAINT "${uqName}" UNIQUE (${uq.columns.map((c) => `"${c}"`).join(", ")})`;
+      columns.push(uniqueDef);
+    }
+  }
+  const checkConstraints = table.checkConstraints || {};
+  for (const [checkName, checkDef] of Object.entries(checkConstraints)) {
+    const check3 = checkDef;
+    if (check3.value) {
+      columns.push(`CONSTRAINT "${checkName}" CHECK (${check3.value})`);
+    }
+  }
+  const tableSQL = `CREATE TABLE IF NOT EXISTS "${schema}"."${tableName}" (
+  ${columns.join(`,
+  `)}
+);`;
+  const foreignKeys = table.foreignKeys || {};
+  for (const [fkName, fkDef] of Object.entries(foreignKeys)) {
+    const fk = fkDef;
+    const fkSQL = wrapConstraintCreationGuard(fkName, buildCreateForeignKeyBodySQL({
+      ...fk,
+      name: fkName,
+      schemaFrom: schema,
+      tableFrom: tableName
+    }));
+    fkSQLs.push(fkSQL);
+  }
+  return { tableSQL, fkSQLs };
+}
+function generateColumnDefinition(name, def) {
+  let sql22 = `"${name}" ${def.type}`;
+  if (def.primaryKey && !def.type.includes("SERIAL")) {
+    sql22 += " PRIMARY KEY";
+  }
+  if (def.notNull) {
+    sql22 += " NOT NULL";
+  }
+  if (def.default !== undefined) {
+    const defaultValue = formatDefaultValue(def.default, def.type);
+    sql22 += ` DEFAULT ${defaultValue}`;
+  }
+  return sql22;
+}
+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};`);
+    }
   }
-  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 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 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);
+  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 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);
+  return statements;
+}
+function checkIfNeedsUsingClause(fromType, toType) {
+  if (!fromType || !toType)
+    return false;
+  if (fromType.includes("enum") || toType.includes("enum")) {
+    return true;
   }
-  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);
+  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;
   }
-  parseDefault(defaultValue, dataType) {
-    if (!defaultValue)
-      return;
-    const match = defaultValue.match(/^'(.*)'::/);
-    if (match) {
-      return `'${match[1]}'`;
+  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;
     }
-    if (defaultValue.includes("nextval(")) {
-      return;
+  }
+  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 (dataType === "boolean") {
-      if (defaultValue === "true")
-        return "true";
-      if (defaultValue === "false")
-        return "false";
+    if (value === false || value === "false" || value === "f" || value === 0) {
+      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;
+  if (type?.match(/^(integer|bigint|smallint|numeric|decimal|real|double)/i)) {
+    return String(value);
   }
-  deriveSchemaName(pluginName) {
-    return pluginName.replace("@", "").replace("/", "_").replace(/-/g, "_").toLowerCase();
+  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);
 }
-var init_database_introspector = () => {};
+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) {
+  return wrapConstraintCreationGuard(fk.name, buildCreateForeignKeyBodySQL(fk));
+}
+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});`;
+}
+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}";`;
+}
+function buildCreateForeignKeyBodySQL(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 wrapConstraintCreationGuard(constraintName, statement) {
+  const escapedConstraintName = constraintName.replace(/'/g, "''");
+  return `DO $$ BEGIN IF NOT EXISTS (SELECT 1 FROM pg_constraint WHERE conname = '${escapedConstraintName}') THEN ${statement}; END IF; END $$;`;
+}
+var init_sql_generator = () => {};
 
 // runtime-migrator/extension-manager.ts
 import { logger as logger5 } from "@elizaos/core";
@@ -3161,14 +3173,10 @@ var init_runtime_migrator = __esm(() => {
   init_migration_tracker();
   init_snapshot_storage();
 });
+
 // runtime-migrator/index.ts
 var init_runtime_migrator2 = __esm(() => {
-  init_snapshot_generator();
-  init_sql_generator();
   init_runtime_migrator();
-  init_journal_storage();
-  init_migration_tracker();
-  init_snapshot_storage();
 });
 
 // migration-service.ts
@@ -3782,7 +3790,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
     return [String(names)];
   }
   isValidUUID(value) {
-    return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value);
+    return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value);
   }
   normalizeWorldData(world) {
     const worldData = {
@@ -5169,11 +5177,14 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
   async addParticipant(entityId, roomId) {
     return this.withDatabase(async () => {
       try {
-        await this.db.insert(participantTable).values({
-          entityId,
-          roomId,
-          agentId: this.agentId
-        }).onConflictDoNothing();
+        const existing = await this.db.select({ id: participantTable.id }).from(participantTable).where(and(eq2(participantTable.entityId, entityId), eq2(participantTable.roomId, roomId), eq2(participantTable.agentId, this.agentId))).limit(1);
+        if (existing.length === 0) {
+          await this.db.insert(participantTable).values({
+            entityId,
+            roomId,
+            agentId: this.agentId
+          });
+        }
         return true;
       } catch (error) {
         logger9.error({
@@ -5190,12 +5201,16 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
   async addParticipantsRoom(entityIds, roomId) {
     return this.withDatabase(async () => {
       try {
-        const values = entityIds.map((id) => ({
-          entityId: id,
-          roomId,
-          agentId: this.agentId
-        }));
-        await this.db.insert(participantTable).values(values).onConflictDoNothing().execute();
+        for (const id of entityIds) {
+          const existing = await this.db.select({ id: participantTable.id }).from(participantTable).where(and(eq2(participantTable.entityId, id), eq2(participantTable.roomId, roomId), eq2(participantTable.agentId, this.agentId))).limit(1);
+          if (existing.length === 0) {
+            await this.db.insert(participantTable).values({
+              entityId: id,
+              roomId,
+              agentId: this.agentId
+            });
+          }
+        }
         return true;
       } catch (error) {
         logger9.error({
@@ -5345,19 +5360,27 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
   }
   async getRelationships(params) {
     return this.withDatabase(async () => {
-      const { entityId, tags } = params;
-      let query;
+      const { entityIds: rawEntityIds, entityId, tags, limit, offset } = params;
+      const entityIds = (rawEntityIds && rawEntityIds.length > 0 ? rawEntityIds : entityId ? [entityId] : []).filter((id) => typeof id === "string" && id.trim().length > 0);
+      if (entityIds.length === 0) {
+        return [];
+      }
+      const entityFilter = sql27.join(entityIds.map((id) => sql27`(${relationshipTable.sourceEntityId} = ${id} OR ${relationshipTable.targetEntityId} = ${id})`), sql27` OR `);
+      let query = sql27`
+        SELECT * FROM ${relationshipTable}
+        WHERE (${entityFilter})
+      `;
       if (tags && tags.length > 0) {
         query = sql27`
-          SELECT * FROM ${relationshipTable}
-          WHERE (${relationshipTable.sourceEntityId} = ${entityId} OR ${relationshipTable.targetEntityId} = ${entityId})
+          ${query}
           AND ${relationshipTable.tags} && CAST(ARRAY[${sql27.join(tags, sql27`, `)}] AS text[])
         `;
-      } else {
-        query = sql27`
-          SELECT * FROM ${relationshipTable}
-          WHERE ${relationshipTable.sourceEntityId} = ${entityId} OR ${relationshipTable.targetEntityId} = ${entityId}
-        `;
+      }
+      if (typeof limit === "number") {
+        query = sql27`${query} LIMIT ${limit}`;
+      }
+      if (typeof offset === "number" && offset > 0) {
+        query = sql27`${query} OFFSET ${offset}`;
       }
       const result = await this.db.execute(query);
       return result.rows.map((relationship) => ({
@@ -7095,5 +7118,5 @@ export {
   DatabaseMigrationService
 };
 
-//# debugId=65F51AC9F4802DC764756E2164756E21
+//# debugId=606A9AD08C7E6C2364756E2164756E21
 //# sourceMappingURL=index.node.js.map