@elizaos/plugin-sql 1.6.5-alpha.9 → 1.6.5

package/dist/browser/index.browser.js

@@ -35,6 +35,44 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 
+// src/schema/agent.ts
+import { sql } from "drizzle-orm";
+import { boolean, jsonb, pgTable, text, timestamp, uuid } from "drizzle-orm/pg-core";
+var agentTable;
+var init_agent = __esm(() => {
+  agentTable = pgTable("agents", {
+    id: uuid("id").primaryKey().defaultRandom(),
+    enabled: boolean("enabled").default(true).notNull(),
+    server_id: uuid("server_id"),
+    createdAt: timestamp("created_at", { withTimezone: true }).default(sql`now()`).notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).default(sql`now()`).notNull(),
+    name: text("name").notNull(),
+    username: text("username"),
+    system: text("system").default(""),
+    bio: jsonb("bio").$type().default(sql`'[]'::jsonb`),
+    messageExamples: jsonb("message_examples").$type().default(sql`'[]'::jsonb`).notNull(),
+    postExamples: jsonb("post_examples").$type().default(sql`'[]'::jsonb`).notNull(),
+    topics: jsonb("topics").$type().default(sql`'[]'::jsonb`).notNull(),
+    adjectives: jsonb("adjectives").$type().default(sql`'[]'::jsonb`).notNull(),
+    knowledge: jsonb("knowledge").$type().default(sql`'[]'::jsonb`).notNull(),
+    plugins: jsonb("plugins").$type().default(sql`'[]'::jsonb`).notNull(),
+    settings: jsonb("settings").$type().default(sql`'{}'::jsonb`).notNull(),
+    style: jsonb("style").$type().default(sql`'{}'::jsonb`).notNull()
+  });
+});
+
+// src/schema/server.ts
+import { sql as sql10 } from "drizzle-orm";
+import { pgTable as pgTable10, timestamp as timestamp10, uuid as uuid10 } from "drizzle-orm/pg-core";
+var serverTable;
+var init_server = __esm(() => {
+  serverTable = pgTable10("servers", {
+    id: uuid10("id").primaryKey(),
+    createdAt: timestamp10("created_at", { withTimezone: true }).default(sql10`now()`).notNull(),
+    updatedAt: timestamp10("updated_at", { withTimezone: true }).default(sql10`now()`).notNull()
+  });
+});
+
 // src/runtime-migrator/storage/migration-tracker.ts
 import { sql as sql17 } from "drizzle-orm";
 
@@ -213,14 +251,14 @@ class ExtensionManager {
     for (const extension of extensions) {
       try {
         if (!/^[a-zA-Z0-9_-]+$/.test(extension)) {
-          logger.warn(`[RuntimeMigrator] Invalid extension name "${extension}" - contains invalid characters`);
+          logger.warn({ src: "plugin:sql", extension }, "Invalid extension name - contains invalid characters");
           continue;
         }
         await this.db.execute(sql20`CREATE EXTENSION IF NOT EXISTS ${sql20.identifier(extension)}`);
-        logger.debug(`[RuntimeMigrator] Extension installed: ${extension}`);
+        logger.debug({ src: "plugin:sql", extension }, "Extension installed");
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
-        logger.warn(`[RuntimeMigrator] Could not install extension ${extension}: ${errorMessage}`);
+        logger.warn({ src: "plugin:sql", extension, error: errorMessage }, "Could not install extension");
       }
     }
   }
@@ -2351,7 +2389,7 @@ var require_stream = __commonJS((exports, module) => {
   var __commonJS2 = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
   var require_primordials = __commonJS2((exports2, module2) => {
 
-    class AggregateError extends Error {
+    class AggregateError2 extends Error {
       constructor(errors) {
         if (!Array.isArray(errors))
           throw TypeError(`Expected input to be an Array, got ${typeof errors}`);
@@ -2363,7 +2401,7 @@ var require_stream = __commonJS((exports, module) => {
         this.name = "AggregateError", this.errors = errors;
       }
     }
-    module2.exports = { AggregateError, ArrayIsArray(self2) {
+    module2.exports = { AggregateError: AggregateError2, ArrayIsArray(self2) {
       return Array.isArray(self2);
     }, ArrayPrototypeIncludes(self2, el) {
       return self2.includes(el);
@@ -2455,7 +2493,7 @@ var require_stream = __commonJS((exports, module) => {
     } };
   });
   var require_errors = __commonJS2((exports2, module2) => {
-    var { format: format2, inspect: inspect2 } = require_inspect(), { AggregateError: CustomAggregateError } = require_primordials(), AggregateError = globalThis.AggregateError || CustomAggregateError, kIsNodeError = Symbol("kIsNodeError"), kTypes = ["string", "function", "number", "object", "Function", "Object", "boolean", "bigint", "symbol"], classRegExp = /^([A-Z][a-z0-9]*)+$/, codes = {};
+    var { format: format2, inspect: inspect2 } = require_inspect(), { AggregateError: CustomAggregateError } = require_primordials(), AggregateError2 = globalThis.AggregateError || CustomAggregateError, kIsNodeError = Symbol("kIsNodeError"), kTypes = ["string", "function", "number", "object", "Function", "Object", "boolean", "bigint", "symbol"], classRegExp = /^([A-Z][a-z0-9]*)+$/, codes = {};
     function assert(value, message) {
       if (!value)
         throw new codes.ERR_INTERNAL_ASSERTION(message);
@@ -2498,7 +2536,7 @@ var require_stream = __commonJS((exports, module) => {
       if (innerError && outerError && innerError !== outerError) {
         if (Array.isArray(outerError.errors))
           return outerError.errors.push(innerError), outerError;
-        let err = new AggregateError([outerError, innerError], outerError.message);
+        let err = new AggregateError2([outerError, innerError], outerError.message);
         return err.code = outerError.code, err;
       }
       return innerError || outerError;
@@ -3007,7 +3045,7 @@ var require_stream = __commonJS((exports, module) => {
     module2.exports.AbortSignal = AbortSignal;
   });
   var require_util = __commonJS2((exports2, module2) => {
-    var bufferModule = (init_buffer(), __toCommonJS(exports_buffer)), { format: format2, inspect: inspect2 } = require_inspect(), { codes: { ERR_INVALID_ARG_TYPE: ERR_INVALID_ARG_TYPE3 } } = require_errors(), { kResistStopPropagation, AggregateError, SymbolDispose } = require_primordials(), AbortSignal = globalThis.AbortSignal || require_abort_controller().AbortSignal, AbortController = globalThis.AbortController || require_abort_controller().AbortController, AsyncFunction = Object.getPrototypeOf(async function() {}).constructor, Blob2 = globalThis.Blob || bufferModule.Blob, isBlob = typeof Blob2 < "u" ? function(b) {
+    var bufferModule = (init_buffer(), __toCommonJS(exports_buffer)), { format: format2, inspect: inspect2 } = require_inspect(), { codes: { ERR_INVALID_ARG_TYPE: ERR_INVALID_ARG_TYPE3 } } = require_errors(), { kResistStopPropagation, AggregateError: AggregateError2, SymbolDispose } = require_primordials(), AbortSignal = globalThis.AbortSignal || require_abort_controller().AbortSignal, AbortController = globalThis.AbortController || require_abort_controller().AbortController, AsyncFunction = Object.getPrototypeOf(async function() {}).constructor, Blob2 = globalThis.Blob || bufferModule.Blob, isBlob = typeof Blob2 < "u" ? function(b) {
       return b instanceof Blob2;
     } : function(b) {
       return false;
@@ -3018,7 +3056,7 @@ var require_stream = __commonJS((exports, module) => {
       if (typeof value !== "function")
         throw new ERR_INVALID_ARG_TYPE3(name, "Function", value);
     };
-    module2.exports = { AggregateError, kEmptyObject: Object.freeze({}), once(callback) {
+    module2.exports = { AggregateError: AggregateError2, kEmptyObject: Object.freeze({}), once(callback) {
       let called = false;
       return function(...args) {
         if (called)
@@ -6327,7 +6365,7 @@ var __create, __getProtoOf, __defProp2, __getOwnPropNames2, __hasOwnProp2, __toE
     if (!__hasOwnProp2.call(to, key))
       __defProp2(to, key, { get: () => mod[key], enumerable: true });
   return to;
-}, __commonJS2 = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports), require_randombytes, require_create_hash, require_create_hmac, require_algorithms, require_precondition, require_default_encoding, require_safe_buffer, require_to_buffer, require_sync, require_async, require_pbkdf2, require_browserify_cipher, require_diffie_hellman, require_browserify_sign, require_package, require_bn, require_minimalistic_assert, require_utils, require_utils2, require_brorand, require_base, require_inherits_browser, require_inherits, require_short, require_mont, require_edwards, require_curve, require_utils3, require_common, require_common2, require_1, require_256, require_224, require_512, require_384, require_sha, require_ripemd, require_hmac, require_hash, require_secp256k1, require_curves, require_hmac_drbg, require_key, require_signature, require_ec, require_key2, require_signature2, require_eddsa, require_elliptic, require_bn2, require_browser, require_create_ecdh, require_bn3, require_api, require_reporter, require_buffer, require_node, require_base2, require_der, require_constants, require_der2, require_pem, require_decoders, require_der3, require_pem2, require_encoders, require_asn1, require_certificate, require_asn12, require_aesid, require_hash_base, require_md5, require_evp_bytestokey, require_browserify_aes, require_fixProc, require_parse_asn1, require_mgf, require_xor, require_bn4, require_withPublic, require_bn5, require_browserify_rsa, require_publicEncrypt, require_privateDecrypt, require_browser2, require_public_encrypt, require_browser3, require_randomfill, require_crypto_browserify, cryptoBrowserify, prng2, pseudoRandomBytes2, rng2, randomBytes2, Hash2, createHash2, Hmac2, createHmac2, getHashes2, pbkdf22, pbkdf2Sync2, Cipher2, createCipher2, Cipheriv2, createCipheriv2, Decipher2, createDecipher2, Decipheriv2, createDecipheriv2, getCiphers2, listCiphers2, DiffieHellmanGroup2, createDiffieHellmanGroup2, getDiffieHellman2, createDiffieHellman2, DiffieHellman2, createSign2, Sign2, createVerify2, Verify2, createECDH2, publicEncrypt2, privateEncrypt2, publicDecrypt2, privateDecrypt2, randomFill2, randomFillSync2, createCredentials2, constants2, DEFAULT_ENCODING = "buffer", getRandomValues2 = (array) => {
+}, __commonJS2 = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports), require_randombytes, require_create_hash, require_create_hmac, require_algorithms, require_precondition, require_default_encoding, require_safe_buffer, require_isarray, require_type, require_es_object_atoms, require_es_errors, require_eval, require_range, require_ref, require_syntax, require_uri, require_abs, require_floor, require_max, require_min, require_pow, require_round, require_isNaN, require_sign, require_gOPD, require_gopd, require_es_define_property, require_shams, require_has_symbols, require_Reflect_getPrototypeOf, require_Object_getPrototypeOf, require_implementation, require_function_bind, require_functionCall, require_functionApply, require_reflectApply, require_actualApply, require_call_bind_apply_helpers, require_get, require_get_proto, require_hasown, require_get_intrinsic, require_call_bound, require_is_callable, require_for_each, require_possible_typed_array_names, require_available_typed_arrays, require_define_data_property, require_has_property_descriptors, require_set_function_length, require_applyBind, require_call_bind, require_shams2, require_which_typed_array, require_is_typed_array, require_typed_array_buffer, require_to_buffer, require_to_buffer2, require_sync, require_async, require_pbkdf2, require_browserify_cipher, require_diffie_hellman, require_browserify_sign, require_package, require_bn, require_minimalistic_assert, require_utils, require_utils2, require_brorand, require_base, require_inherits_browser, require_inherits, require_short, require_mont, require_edwards, require_curve, require_utils3, require_common, require_common2, require_1, require_256, require_224, require_512, require_384, require_sha, require_ripemd, require_hmac, require_hash, require_secp256k1, require_curves, require_hmac_drbg, require_key, require_signature, require_ec, require_key2, require_signature2, require_eddsa, require_elliptic, require_bn2, require_browser, require_create_ecdh, require_bn3, require_api, require_reporter, require_buffer, require_node, require_base2, require_der, require_constants, require_der2, require_pem, require_decoders, require_der3, require_pem2, require_encoders, require_asn1, require_certificate, require_asn12, require_aesid, require_hash_base, require_md5, require_evp_bytestokey, require_browserify_aes, require_fixProc, require_parse_asn1, require_mgf, require_xor, require_bn4, require_withPublic, require_bn5, require_browserify_rsa, require_publicEncrypt, require_privateDecrypt, require_browser2, require_public_encrypt, require_browser3, require_randomfill, require_crypto_browserify, cryptoBrowserify, prng2, pseudoRandomBytes2, rng2, randomBytes2, Hash2, createHash2, Hmac2, createHmac2, getHashes2, pbkdf22, pbkdf2Sync2, Cipher2, createCipher2, Cipheriv2, createCipheriv2, Decipher2, createDecipher2, Decipheriv2, createDecipheriv2, getCiphers2, listCiphers2, DiffieHellmanGroup2, createDiffieHellmanGroup2, getDiffieHellman2, createDiffieHellman2, DiffieHellman2, createSign2, Sign2, createVerify2, Verify2, createECDH2, publicEncrypt2, privateEncrypt2, publicDecrypt2, privateDecrypt2, randomFill2, randomFillSync2, createCredentials2, constants2, DEFAULT_ENCODING = "buffer", getRandomValues2 = (array) => {
   return crypto.getRandomValues(array);
 }, randomUUID2 = () => {
   return crypto.randomUUID();
@@ -6349,11 +6387,11 @@ var init_crypto = __esm(() => {
     module.exports = { sha224WithRSAEncryption: { sign: "rsa", hash: "sha224", id: "302d300d06096086480165030402040500041c" }, "RSA-SHA224": { sign: "ecdsa/rsa", hash: "sha224", id: "302d300d06096086480165030402040500041c" }, sha256WithRSAEncryption: { sign: "rsa", hash: "sha256", id: "3031300d060960864801650304020105000420" }, "RSA-SHA256": { sign: "ecdsa/rsa", hash: "sha256", id: "3031300d060960864801650304020105000420" }, sha384WithRSAEncryption: { sign: "rsa", hash: "sha384", id: "3041300d060960864801650304020205000430" }, "RSA-SHA384": { sign: "ecdsa/rsa", hash: "sha384", id: "3041300d060960864801650304020205000430" }, sha512WithRSAEncryption: { sign: "rsa", hash: "sha512", id: "3051300d060960864801650304020305000440" }, "RSA-SHA512": { sign: "ecdsa/rsa", hash: "sha512", id: "3051300d060960864801650304020305000440" }, "RSA-SHA1": { sign: "rsa", hash: "sha1", id: "3021300906052b0e03021a05000414" }, "ecdsa-with-SHA1": { sign: "ecdsa", hash: "sha1", id: "" }, sha256: { sign: "ecdsa", hash: "sha256", id: "" }, sha224: { sign: "ecdsa", hash: "sha224", id: "" }, sha384: { sign: "ecdsa", hash: "sha384", id: "" }, sha512: { sign: "ecdsa", hash: "sha512", id: "" }, "DSA-SHA": { sign: "dsa", hash: "sha1", id: "" }, "DSA-SHA1": { sign: "dsa", hash: "sha1", id: "" }, DSA: { sign: "dsa", hash: "sha1", id: "" }, "DSA-WITH-SHA224": { sign: "dsa", hash: "sha224", id: "" }, "DSA-SHA224": { sign: "dsa", hash: "sha224", id: "" }, "DSA-WITH-SHA256": { sign: "dsa", hash: "sha256", id: "" }, "DSA-SHA256": { sign: "dsa", hash: "sha256", id: "" }, "DSA-WITH-SHA384": { sign: "dsa", hash: "sha384", id: "" }, "DSA-SHA384": { sign: "dsa", hash: "sha384", id: "" }, "DSA-WITH-SHA512": { sign: "dsa", hash: "sha512", id: "" }, "DSA-SHA512": { sign: "dsa", hash: "sha512", id: "" }, "DSA-RIPEMD160": { sign: "dsa", hash: "rmd160", id: "" }, ripemd160WithRSA: { sign: "rsa", hash: "rmd160", id: "3021300906052b2403020105000414" }, "RSA-RIPEMD160": { sign: "rsa", hash: "rmd160", id: "3021300906052b2403020105000414" }, md5WithRSAEncryption: { sign: "rsa", hash: "md5", id: "3020300c06082a864886f70d020505000410" }, "RSA-MD5": { sign: "rsa", hash: "md5", id: "3020300c06082a864886f70d020505000410" } };
   });
   require_precondition = __commonJS2((exports, module) => {
-    var MAX_ALLOC = Math.pow(2, 30) - 1;
+    var $isFinite = isFinite, MAX_ALLOC = Math.pow(2, 30) - 1;
     module.exports = function(iterations, keylen) {
       if (typeof iterations !== "number")
         throw TypeError("Iterations not a number");
-      if (iterations < 0)
+      if (iterations < 0 || !$isFinite(iterations))
         throw TypeError("Bad iterations");
       if (typeof keylen !== "number")
         throw TypeError("Key length not a number");
@@ -6417,31 +6455,706 @@ var init_crypto = __esm(() => {
       return buffer.SlowBuffer(size);
     };
   });
+  require_isarray = __commonJS2((exports, module) => {
+    var toString = {}.toString;
+    module.exports = Array.isArray || function(arr) {
+      return toString.call(arr) == "[object Array]";
+    };
+  });
+  require_type = __commonJS2((exports, module) => {
+    module.exports = TypeError;
+  });
+  require_es_object_atoms = __commonJS2((exports, module) => {
+    module.exports = Object;
+  });
+  require_es_errors = __commonJS2((exports, module) => {
+    module.exports = Error;
+  });
+  require_eval = __commonJS2((exports, module) => {
+    module.exports = EvalError;
+  });
+  require_range = __commonJS2((exports, module) => {
+    module.exports = RangeError;
+  });
+  require_ref = __commonJS2((exports, module) => {
+    module.exports = ReferenceError;
+  });
+  require_syntax = __commonJS2((exports, module) => {
+    module.exports = SyntaxError;
+  });
+  require_uri = __commonJS2((exports, module) => {
+    module.exports = URIError;
+  });
+  require_abs = __commonJS2((exports, module) => {
+    module.exports = Math.abs;
+  });
+  require_floor = __commonJS2((exports, module) => {
+    module.exports = Math.floor;
+  });
+  require_max = __commonJS2((exports, module) => {
+    module.exports = Math.max;
+  });
+  require_min = __commonJS2((exports, module) => {
+    module.exports = Math.min;
+  });
+  require_pow = __commonJS2((exports, module) => {
+    module.exports = Math.pow;
+  });
+  require_round = __commonJS2((exports, module) => {
+    module.exports = Math.round;
+  });
+  require_isNaN = __commonJS2((exports, module) => {
+    module.exports = Number.isNaN || function(a) {
+      return a !== a;
+    };
+  });
+  require_sign = __commonJS2((exports, module) => {
+    var $isNaN = require_isNaN();
+    module.exports = function(number) {
+      if ($isNaN(number) || number === 0)
+        return number;
+      return number < 0 ? -1 : 1;
+    };
+  });
+  require_gOPD = __commonJS2((exports, module) => {
+    module.exports = Object.getOwnPropertyDescriptor;
+  });
+  require_gopd = __commonJS2((exports, module) => {
+    var $gOPD = require_gOPD();
+    if ($gOPD)
+      try {
+        $gOPD([], "length");
+      } catch (e) {
+        $gOPD = null;
+      }
+    module.exports = $gOPD;
+  });
+  require_es_define_property = __commonJS2((exports, module) => {
+    var $defineProperty = Object.defineProperty || false;
+    if ($defineProperty)
+      try {
+        $defineProperty({}, "a", { value: 1 });
+      } catch (e) {
+        $defineProperty = false;
+      }
+    module.exports = $defineProperty;
+  });
+  require_shams = __commonJS2((exports, module) => {
+    module.exports = function() {
+      if (typeof Symbol !== "function" || typeof Object.getOwnPropertySymbols !== "function")
+        return false;
+      if (typeof Symbol.iterator === "symbol")
+        return true;
+      var obj = {}, sym = Symbol("test"), symObj = Object(sym);
+      if (typeof sym === "string")
+        return false;
+      if (Object.prototype.toString.call(sym) !== "[object Symbol]")
+        return false;
+      if (Object.prototype.toString.call(symObj) !== "[object Symbol]")
+        return false;
+      var symVal = 42;
+      obj[sym] = symVal;
+      for (var _ in obj)
+        return false;
+      if (typeof Object.keys === "function" && Object.keys(obj).length !== 0)
+        return false;
+      if (typeof Object.getOwnPropertyNames === "function" && Object.getOwnPropertyNames(obj).length !== 0)
+        return false;
+      var syms = Object.getOwnPropertySymbols(obj);
+      if (syms.length !== 1 || syms[0] !== sym)
+        return false;
+      if (!Object.prototype.propertyIsEnumerable.call(obj, sym))
+        return false;
+      if (typeof Object.getOwnPropertyDescriptor === "function") {
+        var descriptor = Object.getOwnPropertyDescriptor(obj, sym);
+        if (descriptor.value !== symVal || descriptor.enumerable !== true)
+          return false;
+      }
+      return true;
+    };
+  });
+  require_has_symbols = __commonJS2((exports, module) => {
+    var origSymbol = typeof Symbol < "u" && Symbol, hasSymbolSham = require_shams();
+    module.exports = function() {
+      if (typeof origSymbol !== "function")
+        return false;
+      if (typeof Symbol !== "function")
+        return false;
+      if (typeof origSymbol("foo") !== "symbol")
+        return false;
+      if (typeof Symbol("bar") !== "symbol")
+        return false;
+      return hasSymbolSham();
+    };
+  });
+  require_Reflect_getPrototypeOf = __commonJS2((exports, module) => {
+    module.exports = typeof Reflect < "u" && Reflect.getPrototypeOf || null;
+  });
+  require_Object_getPrototypeOf = __commonJS2((exports, module) => {
+    var $Object = require_es_object_atoms();
+    module.exports = $Object.getPrototypeOf || null;
+  });
+  require_implementation = __commonJS2((exports, module) => {
+    var ERROR_MESSAGE = "Function.prototype.bind called on incompatible ", toStr = Object.prototype.toString, max = Math.max, funcType = "[object Function]", concatty = function(a, b) {
+      var arr = [];
+      for (var i2 = 0;i2 < a.length; i2 += 1)
+        arr[i2] = a[i2];
+      for (var j = 0;j < b.length; j += 1)
+        arr[j + a.length] = b[j];
+      return arr;
+    }, slicy = function(arrLike, offset) {
+      var arr = [];
+      for (var i2 = offset || 0, j = 0;i2 < arrLike.length; i2 += 1, j += 1)
+        arr[j] = arrLike[i2];
+      return arr;
+    }, joiny = function(arr, joiner) {
+      var str = "";
+      for (var i2 = 0;i2 < arr.length; i2 += 1)
+        if (str += arr[i2], i2 + 1 < arr.length)
+          str += joiner;
+      return str;
+    };
+    module.exports = function(that) {
+      var target = this;
+      if (typeof target !== "function" || toStr.apply(target) !== funcType)
+        throw TypeError(ERROR_MESSAGE + target);
+      var args = slicy(arguments, 1), bound, binder = function() {
+        if (this instanceof bound) {
+          var result = target.apply(this, concatty(args, arguments));
+          if (Object(result) === result)
+            return result;
+          return this;
+        }
+        return target.apply(that, concatty(args, arguments));
+      }, boundLength = max(0, target.length - args.length), boundArgs = [];
+      for (var i2 = 0;i2 < boundLength; i2++)
+        boundArgs[i2] = "$" + i2;
+      if (bound = Function("binder", "return function (" + joiny(boundArgs, ",") + "){ return binder.apply(this,arguments); }")(binder), target.prototype) {
+        var Empty = function() {};
+        Empty.prototype = target.prototype, bound.prototype = new Empty, Empty.prototype = null;
+      }
+      return bound;
+    };
+  });
+  require_function_bind = __commonJS2((exports, module) => {
+    var implementation = require_implementation();
+    module.exports = Function.prototype.bind || implementation;
+  });
+  require_functionCall = __commonJS2((exports, module) => {
+    module.exports = Function.prototype.call;
+  });
+  require_functionApply = __commonJS2((exports, module) => {
+    module.exports = Function.prototype.apply;
+  });
+  require_reflectApply = __commonJS2((exports, module) => {
+    module.exports = typeof Reflect < "u" && Reflect && Reflect.apply;
+  });
+  require_actualApply = __commonJS2((exports, module) => {
+    var bind = require_function_bind(), $apply = require_functionApply(), $call = require_functionCall(), $reflectApply = require_reflectApply();
+    module.exports = $reflectApply || bind.call($call, $apply);
+  });
+  require_call_bind_apply_helpers = __commonJS2((exports, module) => {
+    var bind = require_function_bind(), $TypeError = require_type(), $call = require_functionCall(), $actualApply = require_actualApply();
+    module.exports = function(args) {
+      if (args.length < 1 || typeof args[0] !== "function")
+        throw new $TypeError("a function is required");
+      return $actualApply(bind, $call, args);
+    };
+  });
+  require_get = __commonJS2((exports, module) => {
+    var callBind = require_call_bind_apply_helpers(), gOPD = require_gopd(), hasProtoAccessor;
+    try {
+      hasProtoAccessor = [].__proto__ === Array.prototype;
+    } catch (e) {
+      if (!e || typeof e !== "object" || !("code" in e) || e.code !== "ERR_PROTO_ACCESS")
+        throw e;
+    }
+    var desc = !!hasProtoAccessor && gOPD && gOPD(Object.prototype, "__proto__"), $Object = Object, $getPrototypeOf = $Object.getPrototypeOf;
+    module.exports = desc && typeof desc.get === "function" ? callBind([desc.get]) : typeof $getPrototypeOf === "function" ? function(value) {
+      return $getPrototypeOf(value == null ? value : $Object(value));
+    } : false;
+  });
+  require_get_proto = __commonJS2((exports, module) => {
+    var reflectGetProto = require_Reflect_getPrototypeOf(), originalGetProto = require_Object_getPrototypeOf(), getDunderProto = require_get();
+    module.exports = reflectGetProto ? function(O) {
+      return reflectGetProto(O);
+    } : originalGetProto ? function(O) {
+      if (!O || typeof O !== "object" && typeof O !== "function")
+        throw TypeError("getProto: not an object");
+      return originalGetProto(O);
+    } : getDunderProto ? function(O) {
+      return getDunderProto(O);
+    } : null;
+  });
+  require_hasown = __commonJS2((exports, module) => {
+    var call = Function.prototype.call, $hasOwn = Object.prototype.hasOwnProperty, bind = require_function_bind();
+    module.exports = bind.call(call, $hasOwn);
+  });
+  require_get_intrinsic = __commonJS2((exports, module) => {
+    var undefined2, $Object = require_es_object_atoms(), $Error = require_es_errors(), $EvalError = require_eval(), $RangeError = require_range(), $ReferenceError = require_ref(), $SyntaxError = require_syntax(), $TypeError = require_type(), $URIError = require_uri(), abs = require_abs(), floor = require_floor(), max = require_max(), min = require_min(), pow = require_pow(), round = require_round(), sign = require_sign(), $Function = Function, getEvalledConstructor = function(expressionSyntax) {
+      try {
+        return $Function('"use strict"; return (' + expressionSyntax + ").constructor;")();
+      } catch (e) {}
+    }, $gOPD = require_gopd(), $defineProperty = require_es_define_property(), throwTypeError = function() {
+      throw new $TypeError;
+    }, ThrowTypeError = $gOPD ? function() {
+      try {
+        return arguments.callee, throwTypeError;
+      } catch (calleeThrows) {
+        try {
+          return $gOPD(arguments, "callee").get;
+        } catch (gOPDthrows) {
+          return throwTypeError;
+        }
+      }
+    }() : throwTypeError, hasSymbols = require_has_symbols()(), getProto = require_get_proto(), $ObjectGPO = require_Object_getPrototypeOf(), $ReflectGPO = require_Reflect_getPrototypeOf(), $apply = require_functionApply(), $call = require_functionCall(), needsEval = {}, TypedArray = typeof Uint8Array > "u" || !getProto ? undefined2 : getProto(Uint8Array), INTRINSICS = { __proto__: null, "%AggregateError%": typeof AggregateError > "u" ? undefined2 : AggregateError, "%Array%": Array, "%ArrayBuffer%": typeof ArrayBuffer > "u" ? undefined2 : ArrayBuffer, "%ArrayIteratorPrototype%": hasSymbols && getProto ? getProto([][Symbol.iterator]()) : undefined2, "%AsyncFromSyncIteratorPrototype%": undefined2, "%AsyncFunction%": needsEval, "%AsyncGenerator%": needsEval, "%AsyncGeneratorFunction%": needsEval, "%AsyncIteratorPrototype%": needsEval, "%Atomics%": typeof Atomics > "u" ? undefined2 : Atomics, "%BigInt%": typeof BigInt > "u" ? undefined2 : BigInt, "%BigInt64Array%": typeof BigInt64Array > "u" ? undefined2 : BigInt64Array, "%BigUint64Array%": typeof BigUint64Array > "u" ? undefined2 : BigUint64Array, "%Boolean%": Boolean, "%DataView%": typeof DataView > "u" ? undefined2 : DataView, "%Date%": Date, "%decodeURI%": decodeURI, "%decodeURIComponent%": decodeURIComponent, "%encodeURI%": encodeURI, "%encodeURIComponent%": encodeURIComponent, "%Error%": $Error, "%eval%": eval, "%EvalError%": $EvalError, "%Float16Array%": typeof Float16Array > "u" ? undefined2 : Float16Array, "%Float32Array%": typeof Float32Array > "u" ? undefined2 : Float32Array, "%Float64Array%": typeof Float64Array > "u" ? undefined2 : Float64Array, "%FinalizationRegistry%": typeof FinalizationRegistry > "u" ? undefined2 : FinalizationRegistry, "%Function%": $Function, "%GeneratorFunction%": needsEval, "%Int8Array%": typeof Int8Array > "u" ? undefined2 : Int8Array, "%Int16Array%": typeof Int16Array > "u" ? undefined2 : Int16Array, "%Int32Array%": typeof Int32Array > "u" ? undefined2 : Int32Array, "%isFinite%": isFinite, "%isNaN%": isNaN, "%IteratorPrototype%": hasSymbols && getProto ? getProto(getProto([][Symbol.iterator]())) : undefined2, "%JSON%": typeof JSON === "object" ? JSON : undefined2, "%Map%": typeof Map > "u" ? undefined2 : Map, "%MapIteratorPrototype%": typeof Map > "u" || !hasSymbols || !getProto ? undefined2 : getProto(new Map()[Symbol.iterator]()), "%Math%": Math, "%Number%": Number, "%Object%": $Object, "%Object.getOwnPropertyDescriptor%": $gOPD, "%parseFloat%": parseFloat, "%parseInt%": parseInt, "%Promise%": typeof Promise > "u" ? undefined2 : Promise, "%Proxy%": typeof Proxy > "u" ? undefined2 : Proxy, "%RangeError%": $RangeError, "%ReferenceError%": $ReferenceError, "%Reflect%": typeof Reflect > "u" ? undefined2 : Reflect, "%RegExp%": RegExp, "%Set%": typeof Set > "u" ? undefined2 : Set, "%SetIteratorPrototype%": typeof Set > "u" || !hasSymbols || !getProto ? undefined2 : getProto(new Set()[Symbol.iterator]()), "%SharedArrayBuffer%": typeof SharedArrayBuffer > "u" ? undefined2 : SharedArrayBuffer, "%String%": String, "%StringIteratorPrototype%": hasSymbols && getProto ? getProto(""[Symbol.iterator]()) : undefined2, "%Symbol%": hasSymbols ? Symbol : undefined2, "%SyntaxError%": $SyntaxError, "%ThrowTypeError%": ThrowTypeError, "%TypedArray%": TypedArray, "%TypeError%": $TypeError, "%Uint8Array%": typeof Uint8Array > "u" ? undefined2 : Uint8Array, "%Uint8ClampedArray%": typeof Uint8ClampedArray > "u" ? undefined2 : Uint8ClampedArray, "%Uint16Array%": typeof Uint16Array > "u" ? undefined2 : Uint16Array, "%Uint32Array%": typeof Uint32Array > "u" ? undefined2 : Uint32Array, "%URIError%": $URIError, "%WeakMap%": typeof WeakMap > "u" ? undefined2 : WeakMap, "%WeakRef%": typeof WeakRef > "u" ? undefined2 : WeakRef, "%WeakSet%": typeof WeakSet > "u" ? undefined2 : WeakSet, "%Function.prototype.call%": $call, "%Function.prototype.apply%": $apply, "%Object.defineProperty%": $defineProperty, "%Object.getPrototypeOf%": $ObjectGPO, "%Math.abs%": abs, "%Math.floor%": floor, "%Math.max%": max, "%Math.min%": min, "%Math.pow%": pow, "%Math.round%": round, "%Math.sign%": sign, "%Reflect.getPrototypeOf%": $ReflectGPO };
+    if (getProto)
+      try {
+        null.error;
+      } catch (e) {
+        errorProto = getProto(getProto(e)), INTRINSICS["%Error.prototype%"] = errorProto;
+      }
+    var errorProto, doEval = function doEval(name) {
+      var value;
+      if (name === "%AsyncFunction%")
+        value = getEvalledConstructor("async function () {}");
+      else if (name === "%GeneratorFunction%")
+        value = getEvalledConstructor("function* () {}");
+      else if (name === "%AsyncGeneratorFunction%")
+        value = getEvalledConstructor("async function* () {}");
+      else if (name === "%AsyncGenerator%") {
+        var fn = doEval("%AsyncGeneratorFunction%");
+        if (fn)
+          value = fn.prototype;
+      } else if (name === "%AsyncIteratorPrototype%") {
+        var gen = doEval("%AsyncGenerator%");
+        if (gen && getProto)
+          value = getProto(gen.prototype);
+      }
+      return INTRINSICS[name] = value, value;
+    }, LEGACY_ALIASES = { __proto__: null, "%ArrayBufferPrototype%": ["ArrayBuffer", "prototype"], "%ArrayPrototype%": ["Array", "prototype"], "%ArrayProto_entries%": ["Array", "prototype", "entries"], "%ArrayProto_forEach%": ["Array", "prototype", "forEach"], "%ArrayProto_keys%": ["Array", "prototype", "keys"], "%ArrayProto_values%": ["Array", "prototype", "values"], "%AsyncFunctionPrototype%": ["AsyncFunction", "prototype"], "%AsyncGenerator%": ["AsyncGeneratorFunction", "prototype"], "%AsyncGeneratorPrototype%": ["AsyncGeneratorFunction", "prototype", "prototype"], "%BooleanPrototype%": ["Boolean", "prototype"], "%DataViewPrototype%": ["DataView", "prototype"], "%DatePrototype%": ["Date", "prototype"], "%ErrorPrototype%": ["Error", "prototype"], "%EvalErrorPrototype%": ["EvalError", "prototype"], "%Float32ArrayPrototype%": ["Float32Array", "prototype"], "%Float64ArrayPrototype%": ["Float64Array", "prototype"], "%FunctionPrototype%": ["Function", "prototype"], "%Generator%": ["GeneratorFunction", "prototype"], "%GeneratorPrototype%": ["GeneratorFunction", "prototype", "prototype"], "%Int8ArrayPrototype%": ["Int8Array", "prototype"], "%Int16ArrayPrototype%": ["Int16Array", "prototype"], "%Int32ArrayPrototype%": ["Int32Array", "prototype"], "%JSONParse%": ["JSON", "parse"], "%JSONStringify%": ["JSON", "stringify"], "%MapPrototype%": ["Map", "prototype"], "%NumberPrototype%": ["Number", "prototype"], "%ObjectPrototype%": ["Object", "prototype"], "%ObjProto_toString%": ["Object", "prototype", "toString"], "%ObjProto_valueOf%": ["Object", "prototype", "valueOf"], "%PromisePrototype%": ["Promise", "prototype"], "%PromiseProto_then%": ["Promise", "prototype", "then"], "%Promise_all%": ["Promise", "all"], "%Promise_reject%": ["Promise", "reject"], "%Promise_resolve%": ["Promise", "resolve"], "%RangeErrorPrototype%": ["RangeError", "prototype"], "%ReferenceErrorPrototype%": ["ReferenceError", "prototype"], "%RegExpPrototype%": ["RegExp", "prototype"], "%SetPrototype%": ["Set", "prototype"], "%SharedArrayBufferPrototype%": ["SharedArrayBuffer", "prototype"], "%StringPrototype%": ["String", "prototype"], "%SymbolPrototype%": ["Symbol", "prototype"], "%SyntaxErrorPrototype%": ["SyntaxError", "prototype"], "%TypedArrayPrototype%": ["TypedArray", "prototype"], "%TypeErrorPrototype%": ["TypeError", "prototype"], "%Uint8ArrayPrototype%": ["Uint8Array", "prototype"], "%Uint8ClampedArrayPrototype%": ["Uint8ClampedArray", "prototype"], "%Uint16ArrayPrototype%": ["Uint16Array", "prototype"], "%Uint32ArrayPrototype%": ["Uint32Array", "prototype"], "%URIErrorPrototype%": ["URIError", "prototype"], "%WeakMapPrototype%": ["WeakMap", "prototype"], "%WeakSetPrototype%": ["WeakSet", "prototype"] }, bind = require_function_bind(), hasOwn = require_hasown(), $concat = bind.call($call, Array.prototype.concat), $spliceApply = bind.call($apply, Array.prototype.splice), $replace = bind.call($call, String.prototype.replace), $strSlice = bind.call($call, String.prototype.slice), $exec = bind.call($call, RegExp.prototype.exec), rePropName = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g, reEscapeChar = /\\(\\)?/g, stringToPath = function(string) {
+      var first = $strSlice(string, 0, 1), last = $strSlice(string, -1);
+      if (first === "%" && last !== "%")
+        throw new $SyntaxError("invalid intrinsic syntax, expected closing `%`");
+      else if (last === "%" && first !== "%")
+        throw new $SyntaxError("invalid intrinsic syntax, expected opening `%`");
+      var result = [];
+      return $replace(string, rePropName, function(match, number, quote, subString) {
+        result[result.length] = quote ? $replace(subString, reEscapeChar, "$1") : number || match;
+      }), result;
+    }, getBaseIntrinsic = function(name, allowMissing) {
+      var intrinsicName = name, alias;
+      if (hasOwn(LEGACY_ALIASES, intrinsicName))
+        alias = LEGACY_ALIASES[intrinsicName], intrinsicName = "%" + alias[0] + "%";
+      if (hasOwn(INTRINSICS, intrinsicName)) {
+        var value = INTRINSICS[intrinsicName];
+        if (value === needsEval)
+          value = doEval(intrinsicName);
+        if (typeof value > "u" && !allowMissing)
+          throw new $TypeError("intrinsic " + name + " exists, but is not available. Please file an issue!");
+        return { alias, name: intrinsicName, value };
+      }
+      throw new $SyntaxError("intrinsic " + name + " does not exist!");
+    };
+    module.exports = function(name, allowMissing) {
+      if (typeof name !== "string" || name.length === 0)
+        throw new $TypeError("intrinsic name must be a non-empty string");
+      if (arguments.length > 1 && typeof allowMissing !== "boolean")
+        throw new $TypeError('"allowMissing" argument must be a boolean');
+      if ($exec(/^%?[^%]*%?$/, name) === null)
+        throw new $SyntaxError("`%` may not be present anywhere but at the beginning and end of the intrinsic name");
+      var parts = stringToPath(name), intrinsicBaseName = parts.length > 0 ? parts[0] : "", intrinsic = getBaseIntrinsic("%" + intrinsicBaseName + "%", allowMissing), intrinsicRealName = intrinsic.name, value = intrinsic.value, skipFurtherCaching = false, alias = intrinsic.alias;
+      if (alias)
+        intrinsicBaseName = alias[0], $spliceApply(parts, $concat([0, 1], alias));
+      for (var i2 = 1, isOwn = true;i2 < parts.length; i2 += 1) {
+        var part = parts[i2], first = $strSlice(part, 0, 1), last = $strSlice(part, -1);
+        if ((first === '"' || first === "'" || first === "`" || (last === '"' || last === "'" || last === "`")) && first !== last)
+          throw new $SyntaxError("property names with quotes must have matching quotes");
+        if (part === "constructor" || !isOwn)
+          skipFurtherCaching = true;
+        if (intrinsicBaseName += "." + part, intrinsicRealName = "%" + intrinsicBaseName + "%", hasOwn(INTRINSICS, intrinsicRealName))
+          value = INTRINSICS[intrinsicRealName];
+        else if (value != null) {
+          if (!(part in value)) {
+            if (!allowMissing)
+              throw new $TypeError("base intrinsic for " + name + " exists, but the property is not available.");
+            return;
+          }
+          if ($gOPD && i2 + 1 >= parts.length) {
+            var desc = $gOPD(value, part);
+            if (isOwn = !!desc, isOwn && "get" in desc && !("originalValue" in desc.get))
+              value = desc.get;
+            else
+              value = value[part];
+          } else
+            isOwn = hasOwn(value, part), value = value[part];
+          if (isOwn && !skipFurtherCaching)
+            INTRINSICS[intrinsicRealName] = value;
+        }
+      }
+      return value;
+    };
+  });
+  require_call_bound = __commonJS2((exports, module) => {
+    var GetIntrinsic = require_get_intrinsic(), callBindBasic = require_call_bind_apply_helpers(), $indexOf = callBindBasic([GetIntrinsic("%String.prototype.indexOf%")]);
+    module.exports = function(name, allowMissing) {
+      var intrinsic = GetIntrinsic(name, !!allowMissing);
+      if (typeof intrinsic === "function" && $indexOf(name, ".prototype.") > -1)
+        return callBindBasic([intrinsic]);
+      return intrinsic;
+    };
+  });
+  require_is_callable = __commonJS2((exports, module) => {
+    var fnToStr = Function.prototype.toString, reflectApply = typeof Reflect === "object" && Reflect !== null && Reflect.apply, badArrayLike, isCallableMarker;
+    if (typeof reflectApply === "function" && typeof Object.defineProperty === "function")
+      try {
+        badArrayLike = Object.defineProperty({}, "length", { get: function() {
+          throw isCallableMarker;
+        } }), isCallableMarker = {}, reflectApply(function() {
+          throw 42;
+        }, null, badArrayLike);
+      } catch (_) {
+        if (_ !== isCallableMarker)
+          reflectApply = null;
+      }
+    else
+      reflectApply = null;
+    var constructorRegex = /^\s*class\b/, isES6ClassFn = function(value) {
+      try {
+        var fnStr = fnToStr.call(value);
+        return constructorRegex.test(fnStr);
+      } catch (e) {
+        return false;
+      }
+    }, tryFunctionObject = function(value) {
+      try {
+        if (isES6ClassFn(value))
+          return false;
+        return fnToStr.call(value), true;
+      } catch (e) {
+        return false;
+      }
+    }, toStr = Object.prototype.toString, objectClass = "[object Object]", fnClass = "[object Function]", genClass = "[object GeneratorFunction]", ddaClass = "[object HTMLAllCollection]", ddaClass2 = "[object HTML document.all class]", ddaClass3 = "[object HTMLCollection]", hasToStringTag = typeof Symbol === "function" && !!Symbol.toStringTag, isIE68 = !(0 in [,]), isDDA = function() {
+      return false;
+    };
+    if (typeof document === "object") {
+      if (all = document.all, toStr.call(all) === toStr.call(document.all))
+        isDDA = function(value) {
+          if ((isIE68 || !value) && (typeof value > "u" || typeof value === "object"))
+            try {
+              var str = toStr.call(value);
+              return (str === ddaClass || str === ddaClass2 || str === ddaClass3 || str === objectClass) && value("") == null;
+            } catch (e) {}
+          return false;
+        };
+    }
+    var all;
+    module.exports = reflectApply ? function(value) {
+      if (isDDA(value))
+        return true;
+      if (!value)
+        return false;
+      if (typeof value !== "function" && typeof value !== "object")
+        return false;
+      try {
+        reflectApply(value, null, badArrayLike);
+      } catch (e) {
+        if (e !== isCallableMarker)
+          return false;
+      }
+      return !isES6ClassFn(value) && tryFunctionObject(value);
+    } : function(value) {
+      if (isDDA(value))
+        return true;
+      if (!value)
+        return false;
+      if (typeof value !== "function" && typeof value !== "object")
+        return false;
+      if (hasToStringTag)
+        return tryFunctionObject(value);
+      if (isES6ClassFn(value))
+        return false;
+      var strClass = toStr.call(value);
+      if (strClass !== fnClass && strClass !== genClass && !/^\[object HTML/.test(strClass))
+        return false;
+      return tryFunctionObject(value);
+    };
+  });
+  require_for_each = __commonJS2((exports, module) => {
+    var isCallable = require_is_callable(), toStr = Object.prototype.toString, hasOwnProperty2 = Object.prototype.hasOwnProperty, forEachArray = function(array, iterator, receiver) {
+      for (var i2 = 0, len2 = array.length;i2 < len2; i2++)
+        if (hasOwnProperty2.call(array, i2))
+          if (receiver == null)
+            iterator(array[i2], i2, array);
+          else
+            iterator.call(receiver, array[i2], i2, array);
+    }, forEachString = function(string, iterator, receiver) {
+      for (var i2 = 0, len2 = string.length;i2 < len2; i2++)
+        if (receiver == null)
+          iterator(string.charAt(i2), i2, string);
+        else
+          iterator.call(receiver, string.charAt(i2), i2, string);
+    }, forEachObject = function(object, iterator, receiver) {
+      for (var k in object)
+        if (hasOwnProperty2.call(object, k))
+          if (receiver == null)
+            iterator(object[k], k, object);
+          else
+            iterator.call(receiver, object[k], k, object);
+    };
+    function isArray2(x) {
+      return toStr.call(x) === "[object Array]";
+    }
+    module.exports = function(list, iterator, thisArg) {
+      if (!isCallable(iterator))
+        throw TypeError("iterator must be a function");
+      var receiver;
+      if (arguments.length >= 3)
+        receiver = thisArg;
+      if (isArray2(list))
+        forEachArray(list, iterator, receiver);
+      else if (typeof list === "string")
+        forEachString(list, iterator, receiver);
+      else
+        forEachObject(list, iterator, receiver);
+    };
+  });
+  require_possible_typed_array_names = __commonJS2((exports, module) => {
+    module.exports = ["Float16Array", "Float32Array", "Float64Array", "Int8Array", "Int16Array", "Int32Array", "Uint8Array", "Uint8ClampedArray", "Uint16Array", "Uint32Array", "BigInt64Array", "BigUint64Array"];
+  });
+  require_available_typed_arrays = __commonJS2((exports, module) => {
+    var possibleNames = require_possible_typed_array_names(), g = typeof globalThis > "u" ? globalThis : globalThis;
+    module.exports = function() {
+      var out = [];
+      for (var i2 = 0;i2 < possibleNames.length; i2++)
+        if (typeof g[possibleNames[i2]] === "function")
+          out[out.length] = possibleNames[i2];
+      return out;
+    };
+  });
+  require_define_data_property = __commonJS2((exports, module) => {
+    var $defineProperty = require_es_define_property(), $SyntaxError = require_syntax(), $TypeError = require_type(), gopd = require_gopd();
+    module.exports = function(obj, property, value) {
+      if (!obj || typeof obj !== "object" && typeof obj !== "function")
+        throw new $TypeError("`obj` must be an object or a function`");
+      if (typeof property !== "string" && typeof property !== "symbol")
+        throw new $TypeError("`property` must be a string or a symbol`");
+      if (arguments.length > 3 && typeof arguments[3] !== "boolean" && arguments[3] !== null)
+        throw new $TypeError("`nonEnumerable`, if provided, must be a boolean or null");
+      if (arguments.length > 4 && typeof arguments[4] !== "boolean" && arguments[4] !== null)
+        throw new $TypeError("`nonWritable`, if provided, must be a boolean or null");
+      if (arguments.length > 5 && typeof arguments[5] !== "boolean" && arguments[5] !== null)
+        throw new $TypeError("`nonConfigurable`, if provided, must be a boolean or null");
+      if (arguments.length > 6 && typeof arguments[6] !== "boolean")
+        throw new $TypeError("`loose`, if provided, must be a boolean");
+      var nonEnumerable = arguments.length > 3 ? arguments[3] : null, nonWritable = arguments.length > 4 ? arguments[4] : null, nonConfigurable = arguments.length > 5 ? arguments[5] : null, loose = arguments.length > 6 ? arguments[6] : false, desc = !!gopd && gopd(obj, property);
+      if ($defineProperty)
+        $defineProperty(obj, property, { configurable: nonConfigurable === null && desc ? desc.configurable : !nonConfigurable, enumerable: nonEnumerable === null && desc ? desc.enumerable : !nonEnumerable, value, writable: nonWritable === null && desc ? desc.writable : !nonWritable });
+      else if (loose || !nonEnumerable && !nonWritable && !nonConfigurable)
+        obj[property] = value;
+      else
+        throw new $SyntaxError("This environment does not support defining a property as non-configurable, non-writable, or non-enumerable.");
+    };
+  });
+  require_has_property_descriptors = __commonJS2((exports, module) => {
+    var $defineProperty = require_es_define_property(), hasPropertyDescriptors = function() {
+      return !!$defineProperty;
+    };
+    hasPropertyDescriptors.hasArrayLengthDefineBug = function() {
+      if (!$defineProperty)
+        return null;
+      try {
+        return $defineProperty([], "length", { value: 1 }).length !== 1;
+      } catch (e) {
+        return true;
+      }
+    };
+    module.exports = hasPropertyDescriptors;
+  });
+  require_set_function_length = __commonJS2((exports, module) => {
+    var GetIntrinsic = require_get_intrinsic(), define = require_define_data_property(), hasDescriptors = require_has_property_descriptors()(), gOPD = require_gopd(), $TypeError = require_type(), $floor = GetIntrinsic("%Math.floor%");
+    module.exports = function(fn, length) {
+      if (typeof fn !== "function")
+        throw new $TypeError("`fn` is not a function");
+      if (typeof length !== "number" || length < 0 || length > 4294967295 || $floor(length) !== length)
+        throw new $TypeError("`length` must be a positive 32-bit integer");
+      var loose = arguments.length > 2 && !!arguments[2], functionLengthIsConfigurable = true, functionLengthIsWritable = true;
+      if ("length" in fn && gOPD) {
+        var desc = gOPD(fn, "length");
+        if (desc && !desc.configurable)
+          functionLengthIsConfigurable = false;
+        if (desc && !desc.writable)
+          functionLengthIsWritable = false;
+      }
+      if (functionLengthIsConfigurable || functionLengthIsWritable || !loose)
+        if (hasDescriptors)
+          define(fn, "length", length, true, true);
+        else
+          define(fn, "length", length);
+      return fn;
+    };
+  });
+  require_applyBind = __commonJS2((exports, module) => {
+    var bind = require_function_bind(), $apply = require_functionApply(), actualApply = require_actualApply();
+    module.exports = function() {
+      return actualApply(bind, $apply, arguments);
+    };
+  });
+  require_call_bind = __commonJS2((exports, module) => {
+    var setFunctionLength = require_set_function_length(), $defineProperty = require_es_define_property(), callBindBasic = require_call_bind_apply_helpers(), applyBind = require_applyBind();
+    module.exports = function(originalFunction) {
+      var func = callBindBasic(arguments), adjustedLength = originalFunction.length - (arguments.length - 1);
+      return setFunctionLength(func, 1 + (adjustedLength > 0 ? adjustedLength : 0), true);
+    };
+    if ($defineProperty)
+      $defineProperty(module.exports, "apply", { value: applyBind });
+    else
+      module.exports.apply = applyBind;
+  });
+  require_shams2 = __commonJS2((exports, module) => {
+    var hasSymbols = require_shams();
+    module.exports = function() {
+      return hasSymbols() && !!Symbol.toStringTag;
+    };
+  });
+  require_which_typed_array = __commonJS2((exports, module) => {
+    var forEach = require_for_each(), availableTypedArrays = require_available_typed_arrays(), callBind = require_call_bind(), callBound = require_call_bound(), gOPD = require_gopd(), getProto = require_get_proto(), $toString = callBound("Object.prototype.toString"), hasToStringTag = require_shams2()(), g = typeof globalThis > "u" ? globalThis : globalThis, typedArrays = availableTypedArrays(), $slice = callBound("String.prototype.slice"), $indexOf = callBound("Array.prototype.indexOf", true) || function(array, value) {
+      for (var i2 = 0;i2 < array.length; i2 += 1)
+        if (array[i2] === value)
+          return i2;
+      return -1;
+    }, cache = { __proto__: null };
+    if (hasToStringTag && gOPD && getProto)
+      forEach(typedArrays, function(typedArray) {
+        var arr = new g[typedArray];
+        if (Symbol.toStringTag in arr && getProto) {
+          var proto = getProto(arr), descriptor = gOPD(proto, Symbol.toStringTag);
+          if (!descriptor && proto) {
+            var superProto = getProto(proto);
+            descriptor = gOPD(superProto, Symbol.toStringTag);
+          }
+          cache["$" + typedArray] = callBind(descriptor.get);
+        }
+      });
+    else
+      forEach(typedArrays, function(typedArray) {
+        var arr = new g[typedArray], fn = arr.slice || arr.set;
+        if (fn)
+          cache["$" + typedArray] = callBind(fn);
+      });
+    var tryTypedArrays = function(value) {
+      var found = false;
+      return forEach(cache, function(getter, typedArray) {
+        if (!found)
+          try {
+            if ("$" + getter(value) === typedArray)
+              found = $slice(typedArray, 1);
+          } catch (e) {}
+      }), found;
+    }, trySlices = function(value) {
+      var found = false;
+      return forEach(cache, function(getter, name) {
+        if (!found)
+          try {
+            getter(value), found = $slice(name, 1);
+          } catch (e) {}
+      }), found;
+    };
+    module.exports = function(value) {
+      if (!value || typeof value !== "object")
+        return false;
+      if (!hasToStringTag) {
+        var tag = $slice($toString(value), 8, -1);
+        if ($indexOf(typedArrays, tag) > -1)
+          return tag;
+        if (tag !== "Object")
+          return false;
+        return trySlices(value);
+      }
+      if (!gOPD)
+        return null;
+      return tryTypedArrays(value);
+    };
+  });
+  require_is_typed_array = __commonJS2((exports, module) => {
+    var whichTypedArray = require_which_typed_array();
+    module.exports = function(value) {
+      return !!whichTypedArray(value);
+    };
+  });
+  require_typed_array_buffer = __commonJS2((exports, module) => {
+    var $TypeError = require_type(), callBound = require_call_bound(), $typedArrayBuffer = callBound("TypedArray.prototype.buffer", true), isTypedArray = require_is_typed_array();
+    module.exports = $typedArrayBuffer || function(x) {
+      if (!isTypedArray(x))
+        throw new $TypeError("Not a Typed Array");
+      return x.buffer;
+    };
+  });
   require_to_buffer = __commonJS2((exports, module) => {
-    var Buffer22 = require_safe_buffer().Buffer;
+    var Buffer22 = require_safe_buffer().Buffer, isArray2 = require_isarray(), typedArrayBuffer = require_typed_array_buffer(), isView = ArrayBuffer.isView || function(obj) {
+      try {
+        return typedArrayBuffer(obj), true;
+      } catch (e) {
+        return false;
+      }
+    }, useUint8Array = typeof Uint8Array < "u", useArrayBuffer = typeof ArrayBuffer < "u" && typeof Uint8Array < "u", useFromArrayBuffer = useArrayBuffer && (Buffer22.prototype instanceof Uint8Array || Buffer22.TYPED_ARRAY_SUPPORT);
+    module.exports = function(data, encoding) {
+      if (Buffer22.isBuffer(data)) {
+        if (data.constructor && !("isBuffer" in data))
+          return Buffer22.from(data);
+        return data;
+      }
+      if (typeof data === "string")
+        return Buffer22.from(data, encoding);
+      if (useArrayBuffer && isView(data)) {
+        if (data.byteLength === 0)
+          return Buffer22.alloc(0);
+        if (useFromArrayBuffer) {
+          var res = Buffer22.from(data.buffer, data.byteOffset, data.byteLength);
+          if (res.byteLength === data.byteLength)
+            return res;
+        }
+        var uint8 = data instanceof Uint8Array ? data : new Uint8Array(data.buffer, data.byteOffset, data.byteLength), result = Buffer22.from(uint8);
+        if (result.length === data.byteLength)
+          return result;
+      }
+      if (useUint8Array && data instanceof Uint8Array)
+        return Buffer22.from(data);
+      var isArr = isArray2(data);
+      if (isArr)
+        for (var i2 = 0;i2 < data.length; i2 += 1) {
+          var x = data[i2];
+          if (typeof x !== "number" || x < 0 || x > 255 || ~~x !== x)
+            throw RangeError("Array items must be numbers in the range 0-255.");
+        }
+      if (isArr || Buffer22.isBuffer(data) && data.constructor && typeof data.constructor.isBuffer === "function" && data.constructor.isBuffer(data))
+        return Buffer22.from(data);
+      throw TypeError('The "data" argument must be a string, an Array, a Buffer, a Uint8Array, or a DataView.');
+    };
+  });
+  require_to_buffer2 = __commonJS2((exports, module) => {
+    var Buffer22 = require_safe_buffer().Buffer, toBuffer = require_to_buffer(), useUint8Array = typeof Uint8Array < "u", useArrayBuffer = useUint8Array && typeof ArrayBuffer < "u", isView = useArrayBuffer && ArrayBuffer.isView;
     module.exports = function(thing, encoding, name) {
-      if (Buffer22.isBuffer(thing))
-        return thing;
-      else if (typeof thing === "string")
-        return Buffer22.from(thing, encoding);
-      else if (ArrayBuffer.isView(thing))
-        return Buffer22.from(thing.buffer);
-      else
-        throw TypeError(name + " must be a string, a Buffer, a typed array or a DataView");
+      if (typeof thing === "string" || Buffer22.isBuffer(thing) || useUint8Array && thing instanceof Uint8Array || isView && isView(thing))
+        return toBuffer(thing, encoding);
+      throw TypeError(name + " must be a string, a Buffer, a Uint8Array, or a DataView");
     };
   });
   require_sync = __commonJS2((exports, module) => {
-    var sizes = { md5: 16, sha1: 20, sha224: 28, sha256: 32, sha384: 48, sha512: 64, rmd160: 20, ripemd160: 20 }, createHmac = require_create_hmac(), Buffer22 = require_safe_buffer().Buffer, checkParameters = require_precondition(), defaultEncoding = require_default_encoding(), toBuffer = require_to_buffer();
+    var sizes = { __proto__: null, md5: 16, sha1: 20, sha224: 28, sha256: 32, sha384: 48, sha512: 64, "sha512-256": 32, rmd160: 20, ripemd160: 20 }, mapping = { __proto__: null, "sha-1": "sha1", "sha-224": "sha224", "sha-256": "sha256", "sha-384": "sha384", "sha-512": "sha512", "ripemd-160": "ripemd160" }, createHmac = require_create_hmac(), Buffer22 = require_safe_buffer().Buffer, checkParameters = require_precondition(), defaultEncoding = require_default_encoding(), toBuffer = require_to_buffer2();
     function pbkdf2(password, salt, iterations, keylen, digest) {
-      checkParameters(iterations, keylen), password = toBuffer(password, defaultEncoding, "Password"), salt = toBuffer(salt, defaultEncoding, "Salt"), digest = digest || "sha1";
+      checkParameters(iterations, keylen), password = toBuffer(password, defaultEncoding, "Password"), salt = toBuffer(salt, defaultEncoding, "Salt");
+      var lowerDigest = (digest || "sha1").toLowerCase(), mappedDigest = mapping[lowerDigest] || lowerDigest, size = sizes[mappedDigest];
+      if (typeof size !== "number" || !size)
+        throw TypeError("Digest algorithm not supported: " + digest);
       var DK = Buffer22.allocUnsafe(keylen), block1 = Buffer22.allocUnsafe(salt.length + 4);
       salt.copy(block1, 0, 0, salt.length);
-      var destPos = 0, hLen = sizes[digest], l = Math.ceil(keylen / hLen);
+      var destPos = 0, hLen = size, l = Math.ceil(keylen / hLen);
       for (var i2 = 1;i2 <= l; i2++) {
         block1.writeUInt32BE(i2, salt.length);
-        var T = createHmac(digest, password).update(block1).digest(), U = T;
+        var T = createHmac(mappedDigest, password).update(block1).digest(), U = T;
         for (var j = 1;j < iterations; j++) {
-          U = createHmac(digest, password).update(U).digest();
+          U = createHmac(mappedDigest, password).update(U).digest();
           for (var k = 0;k < hLen; k++)
             T[k] ^= U[k];
         }
@@ -6452,23 +7165,7 @@ var init_crypto = __esm(() => {
     module.exports = pbkdf2;
   });
   require_async = __commonJS2((exports, module) => {
-    var Buffer22 = require_safe_buffer().Buffer, checkParameters = require_precondition(), defaultEncoding = require_default_encoding(), sync = require_sync(), toBuffer = require_to_buffer(), ZERO_BUF, subtle = globalThis.crypto && globalThis.crypto.subtle, toBrowser = { sha: "SHA-1", "sha-1": "SHA-1", sha1: "SHA-1", sha256: "SHA-256", "sha-256": "SHA-256", sha384: "SHA-384", "sha-384": "SHA-384", "sha-512": "SHA-512", sha512: "SHA-512" }, checks = [];
-    function checkNative(algo) {
-      if (globalThis.process && !globalThis.process.browser)
-        return Promise.resolve(false);
-      if (!subtle || !subtle.importKey || !subtle.deriveBits)
-        return Promise.resolve(false);
-      if (checks[algo] !== undefined)
-        return checks[algo];
-      ZERO_BUF = ZERO_BUF || Buffer22.alloc(8);
-      var prom = browserPbkdf2(ZERO_BUF, ZERO_BUF, 10, 128, algo).then(function() {
-        return true;
-      }).catch(function() {
-        return false;
-      });
-      return checks[algo] = prom, prom;
-    }
-    var nextTick;
+    var Buffer22 = require_safe_buffer().Buffer, checkParameters = require_precondition(), defaultEncoding = require_default_encoding(), sync = require_sync(), toBuffer = require_to_buffer2(), ZERO_BUF, subtle = globalThis.crypto && globalThis.crypto.subtle, toBrowser = { sha: "SHA-1", "sha-1": "SHA-1", sha1: "SHA-1", sha256: "SHA-256", "sha-256": "SHA-256", sha384: "SHA-384", "sha-384": "SHA-384", "sha-512": "SHA-512", sha512: "SHA-512" }, checks = [], nextTick;
     function getNextTick() {
       if (nextTick)
         return nextTick;
@@ -6489,6 +7186,21 @@ var init_crypto = __esm(() => {
         return Buffer22.from(res);
       });
     }
+    function checkNative(algo) {
+      if (globalThis.process && !globalThis.process.browser)
+        return Promise.resolve(false);
+      if (!subtle || !subtle.importKey || !subtle.deriveBits)
+        return Promise.resolve(false);
+      if (checks[algo] !== undefined)
+        return checks[algo];
+      ZERO_BUF = ZERO_BUF || Buffer22.alloc(8);
+      var prom = browserPbkdf2(ZERO_BUF, ZERO_BUF, 10, 128, algo).then(function() {
+        return true;
+      }, function() {
+        return false;
+      });
+      return checks[algo] = prom, prom;
+    }
     function resolvePromise(promise, callback) {
       promise.then(function(out) {
         getNextTick()(function() {
@@ -6503,6 +7215,8 @@ var init_crypto = __esm(() => {
     module.exports = function(password, salt, iterations, keylen, digest, callback) {
       if (typeof digest === "function")
         callback = digest, digest = undefined;
+      if (checkParameters(iterations, keylen), password = toBuffer(password, defaultEncoding, "Password"), salt = toBuffer(salt, defaultEncoding, "Salt"), typeof callback !== "function")
+        throw Error("No callback provided to pbkdf2");
       digest = digest || "sha1";
       var algo = toBrowser[digest.toLowerCase()];
       if (!algo || typeof globalThis.Promise !== "function") {
@@ -6511,14 +7225,13 @@ var init_crypto = __esm(() => {
           try {
             out = sync(password, salt, iterations, keylen, digest);
           } catch (e) {
-            return callback(e);
+            callback(e);
+            return;
           }
           callback(null, out);
         });
         return;
       }
-      if (checkParameters(iterations, keylen), password = toBuffer(password, defaultEncoding, "Password"), salt = toBuffer(salt, defaultEncoding, "Salt"), typeof callback !== "function")
-        throw Error("No callback provided to pbkdf2");
       resolvePromise(checkNative(algo).then(function(resp) {
         if (resp)
           return browserPbkdf2(password, salt, iterations, keylen, algo);
@@ -6527,18 +7240,18 @@ var init_crypto = __esm(() => {
     };
   });
   require_pbkdf2 = __commonJS2((exports) => {
-    var native = (init_crypto(), __toCommonJS(exports_crypto)), checkParameters = require_precondition(), defaultEncoding = require_default_encoding(), toBuffer = require_to_buffer();
+    var nativeImpl = (init_crypto(), __toCommonJS(exports_crypto)), checkParameters = require_precondition(), defaultEncoding = require_default_encoding(), toBuffer = require_to_buffer2();
     function nativePBKDF2(password, salt, iterations, keylen, digest, callback) {
       if (checkParameters(iterations, keylen), password = toBuffer(password, defaultEncoding, "Password"), salt = toBuffer(salt, defaultEncoding, "Salt"), typeof digest === "function")
         callback = digest, digest = "sha1";
       if (typeof callback !== "function")
         throw Error("No callback provided to pbkdf2");
-      return native.pbkdf2(password, salt, iterations, keylen, digest, callback);
+      return nativeImpl.pbkdf2(password, salt, iterations, keylen, digest, callback);
     }
     function nativePBKDF2Sync(password, salt, iterations, keylen, digest) {
-      return checkParameters(iterations, keylen), password = toBuffer(password, defaultEncoding, "Password"), salt = toBuffer(salt, defaultEncoding, "Salt"), digest = digest || "sha1", native.pbkdf2Sync(password, salt, iterations, keylen, digest);
+      return checkParameters(iterations, keylen), password = toBuffer(password, defaultEncoding, "Password"), salt = toBuffer(salt, defaultEncoding, "Salt"), digest = digest || "sha1", nativeImpl.pbkdf2Sync(password, salt, iterations, keylen, digest);
     }
-    if (!native.pbkdf2Sync || native.pbkdf2Sync.toString().indexOf("keylen, digest") === -1)
+    if (!nativeImpl.pbkdf2Sync || nativeImpl.pbkdf2Sync.toString().indexOf("keylen, digest") === -1)
       exports.pbkdf2Sync = require_sync(), exports.pbkdf2 = require_async();
     else
       exports.pbkdf2Sync = nativePBKDF2Sync, exports.pbkdf2 = nativePBKDF2;
@@ -14371,9 +15084,9 @@ var init_crypto = __esm(() => {
     };
   });
   require_parse_asn1 = __commonJS2((exports, module) => {
-    var asn1 = require_asn12(), aesid = require_aesid(), fixProc = require_fixProc(), ciphers = require_browserify_aes(), compat = require_pbkdf2(), Buffer22 = require_safe_buffer().Buffer;
+    var asn1 = require_asn12(), aesid = require_aesid(), fixProc = require_fixProc(), ciphers = require_browserify_aes(), pbkdf2Sync = require_pbkdf2().pbkdf2Sync, Buffer22 = require_safe_buffer().Buffer;
     function decrypt(data, password) {
-      var salt = data.algorithm.decrypt.kde.kdeparams.salt, iters = parseInt(data.algorithm.decrypt.kde.kdeparams.iters.toString(), 10), algo = aesid[data.algorithm.decrypt.cipher.algo.join(".")], iv = data.algorithm.decrypt.cipher.iv, cipherText = data.subjectPrivateKey, keylen = parseInt(algo.split("-")[1], 10) / 8, key = compat.pbkdf2Sync(password, salt, iters, keylen, "sha1"), cipher = ciphers.createDecipheriv(algo, key, iv), out = [];
+      var salt = data.algorithm.decrypt.kde.kdeparams.salt, iters = parseInt(data.algorithm.decrypt.kde.kdeparams.iters.toString(), 10), algo = aesid[data.algorithm.decrypt.cipher.algo.join(".")], iv = data.algorithm.decrypt.cipher.iv, cipherText = data.subjectPrivateKey, keylen = parseInt(algo.split("-")[1], 10) / 8, key = pbkdf2Sync(password, salt, iters, keylen, "sha1"), cipher = ciphers.createDecipheriv(algo, key, iv), out = [];
       return out.push(cipher.update(cipherText)), out.push(cipher.final()), Buffer22.concat(out);
     }
     function parseKeys(buffer) {
@@ -18340,10 +19053,7 @@ async function generateMigrationSQL(previousSnapshot, currentSnapshot, diff) {
   }
   const dataLossCheck = checkForDataLoss(diff);
   if (dataLossCheck.warnings.length > 0) {
-    logger2.warn("[RuntimeMigrator] Schema changes may cause data loss:");
-    for (const warning of dataLossCheck.warnings) {
-      logger2.warn(`  - ${warning}`);
-    }
+    logger2.warn({ src: "plugin:sql", warnings: dataLossCheck.warnings }, "Schema changes may cause data loss");
   }
   const schemasToCreate = new Set;
   for (const tableName of diff.tables.created) {
@@ -18768,7 +19478,7 @@ class DatabaseIntrospector {
     this.db = db;
   }
   async introspectSchema(schemaName = "public") {
-    logger4.info(`[DatabaseIntrospector] Starting introspection for schema: ${schemaName}`);
+    logger4.info({ src: "plugin:sql", schemaName }, "Starting database introspection");
     const tables = {};
     const schemas = {};
     const enums = {};
@@ -18776,7 +19486,7 @@ class DatabaseIntrospector {
     for (const tableInfo of allTables) {
       const tableName = tableInfo.table_name;
       const tableSchema = tableInfo.table_schema || "public";
-      logger4.debug(`[DatabaseIntrospector] Introspecting table: ${tableSchema}.${tableName}`);
+      logger4.debug({ src: "plugin:sql", tableSchema, tableName }, "Introspecting table");
       const columns = await this.getColumns(tableSchema, tableName);
       const columnsObject = {};
       const uniqueConstraintObject = {};
@@ -18793,15 +19503,17 @@ class DatabaseIntrospector {
       const indexesObject = {};
       for (const idx of indexes) {
         if (!idx.is_primary && !idx.is_unique_constraint) {
-          indexesObject[idx.name] = {
-            name: idx.name,
-            columns: idx.columns.map((col) => ({
-              expression: col,
-              isExpression: false
-            })),
-            isUnique: idx.is_unique,
-            method: idx.method || "btree"
-          };
+          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);
@@ -18869,7 +19581,7 @@ class DatabaseIntrospector {
       }
       enums[key].values.push(enumInfo.value);
     }
-    logger4.info(`[DatabaseIntrospector] Introspection complete. Found ${Object.keys(tables).length} tables`);
+    logger4.info({ src: "plugin:sql", tableCount: Object.keys(tables).length }, "Database introspection complete");
     return {
       version: "7",
       dialect: "postgresql",
@@ -19129,7 +19841,7 @@ class RuntimeMigrator {
       }
     }
     for (const schemaName of schemasToCreate) {
-      logger5.debug(`[RuntimeMigrator] Ensuring schema '${schemaName}' exists`);
+      logger5.debug({ src: "plugin:sql", schemaName }, "Ensuring schema exists");
       await this.db.execute(sql22.raw(`CREATE SCHEMA IF NOT EXISTS "${schemaName}"`));
     }
   }
@@ -19140,10 +19852,15 @@ class RuntimeMigrator {
       const tableData = table;
       const actualSchema = tableData.schema || "public";
       if (!isCorePLugin && actualSchema === "public") {
-        logger5.warn(`[RuntimeMigrator] WARNING: Plugin '${pluginName}' table '${tableData.name}' is using public schema. ` + `Consider using pgSchema('${expectedSchema}').table(...) for better isolation.`);
+        logger5.warn({ src: "plugin:sql", pluginName, tableName: tableData.name, expectedSchema }, "Plugin table is using public schema - consider using pgSchema for better isolation");
       }
       if (isCorePLugin && actualSchema !== "public") {
-        logger5.warn(`[RuntimeMigrator] WARNING: Core plugin '@elizaos/plugin-sql' table '${tableData.name}' is using schema '${actualSchema}'. ` + `Core tables should use public schema.`);
+        logger5.warn({
+          src: "plugin:sql",
+          pluginName: "@elizaos/plugin-sql",
+          tableName: tableData.name,
+          actualSchema
+        }, "Core plugin table should use public schema");
       }
     }
   }
@@ -19354,13 +20071,13 @@ class RuntimeMigrator {
         }
       }
     }
-    logger5.debug(`[RuntimeMigrator] Connection string did not match any PostgreSQL patterns: ${url.substring(0, 50)}...`);
+    logger5.debug({ src: "plugin:sql", urlPreview: url.substring(0, 50) }, "Connection string did not match any PostgreSQL patterns");
     return false;
   }
   async initialize() {
-    logger5.info("[RuntimeMigrator] Initializing migration system...");
+    logger5.info({ src: "plugin:sql" }, "Initializing migration system");
     await this.migrationTracker.ensureTables();
-    logger5.info("[RuntimeMigrator] Migration system initialized");
+    logger5.info({ src: "plugin:sql" }, "Migration system initialized");
   }
   async migrate(pluginName, schema, options = {}) {
     const lockId = this.getAdvisoryLockId(pluginName);
@@ -19369,46 +20086,54 @@ class RuntimeMigrator {
     }
     let lockAcquired = false;
     try {
-      logger5.info(`[RuntimeMigrator] Starting migration for plugin: ${pluginName}`);
+      logger5.info({ src: "plugin:sql", pluginName }, "Starting migration for plugin");
       await this.initialize();
       const postgresUrl = process.env.POSTGRES_URL || process.env.DATABASE_URL || "";
       const isRealPostgres = this.isRealPostgresDatabase(postgresUrl);
       if (isRealPostgres) {
         try {
-          logger5.debug(`[RuntimeMigrator] Using PostgreSQL advisory locks for ${pluginName}`);
+          logger5.debug({ src: "plugin:sql", pluginName }, "Using PostgreSQL advisory locks");
           const lockIdStr = lockId.toString();
           const lockResult = await this.db.execute(sql22`SELECT pg_try_advisory_lock(CAST(${lockIdStr} AS bigint)) as acquired`);
           lockAcquired = lockResult.rows[0]?.acquired === true;
           if (!lockAcquired) {
-            logger5.info(`[RuntimeMigrator] Migration already in progress for ${pluginName}, waiting for lock...`);
+            logger5.info({ src: "plugin:sql", pluginName }, "Migration already in progress, waiting for lock");
             await this.db.execute(sql22`SELECT pg_advisory_lock(CAST(${lockIdStr} AS bigint))`);
             lockAcquired = true;
-            logger5.info(`[RuntimeMigrator] Lock acquired for ${pluginName}`);
+            logger5.info({ src: "plugin:sql", pluginName }, "Lock acquired");
           } else {
-            logger5.debug(`[RuntimeMigrator] Advisory lock acquired for ${pluginName} (lock ID: ${lockIdStr})`);
+            logger5.debug({ src: "plugin:sql", pluginName, lockId: lockIdStr }, "Advisory lock acquired");
           }
         } catch (lockError) {
-          logger5.warn(`[RuntimeMigrator] Failed to acquire advisory lock, continuing without lock: ${lockError}`);
+          logger5.warn({
+            src: "plugin:sql",
+            pluginName,
+            error: lockError instanceof Error ? lockError.message : String(lockError)
+          }, "Failed to acquire advisory lock, continuing without lock");
           lockAcquired = false;
         }
       } else {
-        logger5.debug(`[RuntimeMigrator] Development database detected (PGLite or non-PostgreSQL), skipping advisory locks`);
+        logger5.debug({ src: "plugin:sql" }, "Development database detected, skipping advisory locks");
       }
-      await this.extensionManager.installRequiredExtensions(["vector", "fuzzystrmatch"]);
+      await this.extensionManager.installRequiredExtensions([
+        "vector",
+        "fuzzystrmatch",
+        "pgcrypto"
+      ]);
       const currentSnapshot = await generateSnapshot(schema);
       await this.ensureSchemasExist(currentSnapshot);
       this.validateSchemaUsage(pluginName, currentSnapshot);
       const currentHash = hashSnapshot(currentSnapshot);
       const lastMigration = await this.migrationTracker.getLastMigration(pluginName);
       if (lastMigration && lastMigration.hash === currentHash) {
-        logger5.info(`[RuntimeMigrator] No changes detected for ${pluginName}, skipping migration (hash: ${currentHash})`);
+        logger5.info({ src: "plugin:sql", pluginName, hash: currentHash }, "No changes detected, skipping migration");
         return;
       }
       let previousSnapshot = await this.snapshotStorage.getLatestSnapshot(pluginName);
       if (!previousSnapshot && Object.keys(currentSnapshot.tables).length > 0) {
         const hasExistingTables = await this.introspector.hasExistingTables(pluginName);
         if (hasExistingTables) {
-          logger5.info(`[RuntimeMigrator] No snapshot found for ${pluginName} but tables exist in database. Introspecting...`);
+          logger5.info({ src: "plugin:sql", pluginName }, "No snapshot found but tables exist in database, introspecting");
           const schemaName = this.getExpectedSchemaName(pluginName);
           const introspectedSnapshot = await this.introspector.introspectSchema(schemaName);
           if (Object.keys(introspectedSnapshot.tables).length > 0) {
@@ -19416,15 +20141,15 @@ class RuntimeMigrator {
             await this.journalStorage.updateJournal(pluginName, 0, `introspected_${Date.now()}`, true);
             const introspectedHash = hashSnapshot(introspectedSnapshot);
             await this.migrationTracker.recordMigration(pluginName, introspectedHash, Date.now());
-            logger5.info(`[RuntimeMigrator] Created initial snapshot from existing database for ${pluginName}`);
+            logger5.info({ src: "plugin:sql", pluginName }, "Created initial snapshot from existing database");
             previousSnapshot = introspectedSnapshot;
           }
         }
       }
       if (!hasChanges(previousSnapshot, currentSnapshot)) {
-        logger5.info(`[RuntimeMigrator] No schema changes for ${pluginName}`);
+        logger5.info({ src: "plugin:sql", pluginName }, "No schema changes");
         if (!previousSnapshot && Object.keys(currentSnapshot.tables).length === 0) {
-          logger5.info(`[RuntimeMigrator] Recording empty schema for ${pluginName}`);
+          logger5.info({ src: "plugin:sql", pluginName }, "Recording empty schema");
           await this.migrationTracker.recordMigration(pluginName, currentHash, Date.now());
           const idx = await this.journalStorage.getNextIdx(pluginName);
           const tag = this.generateMigrationTag(idx, pluginName);
@@ -19435,7 +20160,7 @@ class RuntimeMigrator {
       }
       const diff = await calculateDiff(previousSnapshot, currentSnapshot);
       if (!hasDiffChanges(diff)) {
-        logger5.info(`[RuntimeMigrator] No actionable changes for ${pluginName}`);
+        logger5.info({ src: "plugin:sql", pluginName }, "No actionable changes");
         return;
       }
       const dataLossCheck = checkForDataLoss(diff);
@@ -19443,55 +20168,43 @@ class RuntimeMigrator {
         const isProduction = false;
         const allowDestructive = options.force || options.allowDataLoss || process.env.ELIZA_ALLOW_DESTRUCTIVE_MIGRATIONS === "true";
         if (!allowDestructive) {
-          logger5.error("[RuntimeMigrator] Destructive migration blocked");
-          logger5.error(`[RuntimeMigrator] Plugin: ${pluginName}`);
-          logger5.error(`[RuntimeMigrator] Environment: ${isProduction ? "PRODUCTION" : "DEVELOPMENT"}`);
-          logger5.error("[RuntimeMigrator] Destructive operations detected:");
-          for (const warning of dataLossCheck.warnings) {
-            logger5.error(`[RuntimeMigrator]   - ${warning}`);
-          }
-          logger5.error("[RuntimeMigrator] To proceed with destructive migrations:");
-          logger5.error("[RuntimeMigrator]   1. Set environment variable: export ELIZA_ALLOW_DESTRUCTIVE_MIGRATIONS=true");
-          logger5.error("[RuntimeMigrator]   2. Or use option: migrate(plugin, schema, { force: true })");
-          if (isProduction) {
-            logger5.error("[RuntimeMigrator]   3. For production, consider using drizzle-kit for manual migration");
-          }
+          logger5.error({
+            src: "plugin:sql",
+            pluginName,
+            environment: isProduction ? "PRODUCTION" : "DEVELOPMENT",
+            warnings: dataLossCheck.warnings
+          }, "Destructive migration blocked - set ELIZA_ALLOW_DESTRUCTIVE_MIGRATIONS=true or use force option");
           const errorMessage = isProduction ? `Destructive migration blocked in production for ${pluginName}. Set ELIZA_ALLOW_DESTRUCTIVE_MIGRATIONS=true or use drizzle-kit.` : `Destructive migration blocked for ${pluginName}. Set ELIZA_ALLOW_DESTRUCTIVE_MIGRATIONS=true to proceed.`;
           throw new Error(errorMessage);
         }
         if (dataLossCheck.requiresConfirmation) {
-          logger5.warn("[RuntimeMigrator] Proceeding with destructive migration");
-          logger5.warn(`[RuntimeMigrator] Plugin: ${pluginName}`);
-          logger5.warn("[RuntimeMigrator] The following operations will be performed:");
-          for (const warning of dataLossCheck.warnings) {
-            logger5.warn(`[RuntimeMigrator]   ⚠️ ${warning}`);
-          }
+          logger5.warn({ src: "plugin:sql", pluginName, warnings: dataLossCheck.warnings }, "Proceeding with destructive migration");
         }
       }
       const sqlStatements = await generateMigrationSQL(previousSnapshot, currentSnapshot, diff);
       if (sqlStatements.length === 0) {
-        logger5.info(`[RuntimeMigrator] No SQL statements to execute for ${pluginName}`);
+        logger5.info({ src: "plugin:sql", pluginName }, "No SQL statements to execute");
         return;
       }
-      logger5.info(`[RuntimeMigrator] Executing ${sqlStatements.length} SQL statements for ${pluginName}`);
+      logger5.info({ src: "plugin:sql", pluginName, statementCount: sqlStatements.length }, "Executing SQL statements");
       if (options.verbose) {
         sqlStatements.forEach((stmt, i2) => {
-          logger5.debug(`[RuntimeMigrator] Statement ${i2 + 1}: ${stmt}`);
+          logger5.debug({ src: "plugin:sql", statementIndex: i2 + 1, statement: stmt }, "SQL statement");
         });
       }
       if (options.dryRun) {
-        logger5.info("[RuntimeMigrator] DRY RUN mode - not executing statements");
-        logger5.info("[RuntimeMigrator] Would execute:");
-        sqlStatements.forEach((stmt, i2) => {
-          logger5.info(`  ${i2 + 1}. ${stmt}`);
-        });
+        logger5.info({ src: "plugin:sql", pluginName, statements: sqlStatements }, "DRY RUN mode - not executing statements");
         return;
       }
       await this.executeMigration(pluginName, currentSnapshot, currentHash, sqlStatements);
-      logger5.info(`[RuntimeMigrator] Migration completed successfully for ${pluginName}`);
+      logger5.info({ src: "plugin:sql", pluginName }, "Migration completed successfully");
       return;
     } catch (error) {
-      logger5.error(`[RuntimeMigrator] Migration failed for ${pluginName}:`, JSON.stringify(error));
+      logger5.error({
+        src: "plugin:sql",
+        pluginName,
+        error: error instanceof Error ? error.message : String(error)
+      }, "Migration failed");
       throw error;
     } finally {
       const postgresUrl = process.env.POSTGRES_URL || process.env.DATABASE_URL || "";
@@ -19500,9 +20213,13 @@ class RuntimeMigrator {
         try {
           const lockIdStr = lockId.toString();
           await this.db.execute(sql22`SELECT pg_advisory_unlock(CAST(${lockIdStr} AS bigint))`);
-          logger5.debug(`[RuntimeMigrator] Advisory lock released for ${pluginName}`);
+          logger5.debug({ src: "plugin:sql", pluginName }, "Advisory lock released");
         } catch (unlockError) {
-          logger5.warn(`[RuntimeMigrator] Failed to release advisory lock for ${pluginName}:`, JSON.stringify(unlockError));
+          logger5.warn({
+            src: "plugin:sql",
+            pluginName,
+            error: unlockError instanceof Error ? unlockError.message : String(unlockError)
+          }, "Failed to release advisory lock");
         }
       }
     }
@@ -19513,7 +20230,7 @@ class RuntimeMigrator {
       await this.db.execute(sql22`BEGIN`);
       transactionStarted = true;
       for (const stmt of sqlStatements) {
-        logger5.debug(`[RuntimeMigrator] Executing: ${stmt}`);
+        logger5.debug({ src: "plugin:sql", statement: stmt }, "Executing SQL statement");
         await this.db.execute(sql22.raw(stmt));
       }
       const idx = await this.journalStorage.getNextIdx(pluginName);
@@ -19522,14 +20239,17 @@ class RuntimeMigrator {
       await this.journalStorage.updateJournal(pluginName, idx, tag, true);
       await this.snapshotStorage.saveSnapshot(pluginName, idx, snapshot);
       await this.db.execute(sql22`COMMIT`);
-      logger5.info(`[RuntimeMigrator] Recorded migration ${tag} for ${pluginName}`);
+      logger5.info({ src: "plugin:sql", pluginName, tag }, "Recorded migration");
     } catch (error) {
       if (transactionStarted) {
         try {
           await this.db.execute(sql22`ROLLBACK`);
-          logger5.error("[RuntimeMigrator] Migration failed, rolled back:", JSON.stringify(error));
+          logger5.error({ src: "plugin:sql", error: error instanceof Error ? error.message : String(error) }, "Migration failed, rolled back");
         } catch (rollbackError) {
-          logger5.error("[RuntimeMigrator] Failed to rollback transaction:", JSON.stringify(rollbackError));
+          logger5.error({
+            src: "plugin:sql",
+            error: rollbackError instanceof Error ? rollbackError.message : String(rollbackError)
+          }, "Failed to rollback transaction");
         }
       }
       throw error;
@@ -19552,31 +20272,35 @@ class RuntimeMigrator {
     };
   }
   async reset(pluginName) {
-    logger5.warn(`[RuntimeMigrator] Resetting migrations for ${pluginName}`);
+    logger5.warn({ src: "plugin:sql", pluginName }, "Resetting migrations");
     await this.db.execute(sql22`DELETE FROM migrations._migrations WHERE plugin_name = ${pluginName}`);
     await this.db.execute(sql22`DELETE FROM migrations._journal WHERE plugin_name = ${pluginName}`);
     await this.db.execute(sql22`DELETE FROM migrations._snapshots WHERE plugin_name = ${pluginName}`);
-    logger5.warn(`[RuntimeMigrator] Reset complete for ${pluginName}`);
+    logger5.warn({ src: "plugin:sql", pluginName }, "Reset complete");
   }
   async checkMigration(pluginName, schema) {
     try {
-      logger5.info(`[RuntimeMigrator] Checking migration for ${pluginName}...`);
+      logger5.info({ src: "plugin:sql", pluginName }, "Checking migration");
       const currentSnapshot = await generateSnapshot(schema);
       const previousSnapshot = await this.snapshotStorage.getLatestSnapshot(pluginName);
       if (!hasChanges(previousSnapshot, currentSnapshot)) {
-        logger5.info(`[RuntimeMigrator] No changes detected for ${pluginName}`);
+        logger5.info({ src: "plugin:sql", pluginName }, "No changes detected");
         return null;
       }
       const diff = await calculateDiff(previousSnapshot, currentSnapshot);
       const dataLossCheck = checkForDataLoss(diff);
       if (dataLossCheck.hasDataLoss) {
-        logger5.warn(`[RuntimeMigrator] Migration for ${pluginName} would cause data loss`);
+        logger5.warn({ src: "plugin:sql", pluginName }, "Migration would cause data loss");
       } else {
-        logger5.info(`[RuntimeMigrator] Migration for ${pluginName} is safe (no data loss)`);
+        logger5.info({ src: "plugin:sql", pluginName }, "Migration is safe (no data loss)");
       }
       return dataLossCheck;
     } catch (error) {
-      logger5.error(`[RuntimeMigrator] Failed to check migration for ${pluginName}:`, JSON.stringify(error));
+      logger5.error({
+        src: "plugin:sql",
+        pluginName,
+        error: error instanceof Error ? error.message : String(error)
+      }, "Failed to check migration");
       throw error;
     }
   }
@@ -19598,12 +20322,660 @@ var init_runtime_migrator2 = __esm(() => {
   init_runtime_migrator();
 });
 
+// src/migrations.ts
+import { logger as logger6 } from "@elizaos/core";
+import { sql as sql23 } from "drizzle-orm";
+async function migrateToEntityRLS(adapter) {
+  const db = adapter.db;
+  try {
+    await db.execute(sql23`SELECT 1 FROM pg_tables LIMIT 1`);
+  } catch {
+    logger6.debug("[Migration] ⊘ Not PostgreSQL, skipping PostgreSQL-specific migrations");
+    return;
+  }
+  logger6.info("[Migration] Starting develop → feat/entity-rls migration...");
+  try {
+    logger6.debug("[Migration] → Clearing RuntimeMigrator snapshot cache...");
+    try {
+      await db.execute(sql23`DELETE FROM migrations._snapshots WHERE plugin_name = '@elizaos/plugin-sql'`);
+      logger6.debug("[Migration] ✓ Snapshot cache cleared");
+    } catch (error) {
+      logger6.debug("[Migration] ⊘ No snapshot cache to clear (migrations schema not yet created)");
+    }
+    logger6.debug("[Migration] → Disabling Row Level Security on all tables...");
+    try {
+      const tablesResult = await db.execute(sql23`
+        SELECT tablename
+        FROM pg_tables
+        WHERE schemaname = 'public'
+        ORDER BY tablename
+      `);
+      for (const row of tablesResult.rows || []) {
+        const tableName = row.tablename;
+        try {
+          await db.execute(sql23.raw(`ALTER TABLE "${tableName}" DISABLE ROW LEVEL SECURITY`));
+          logger6.debug(`[Migration] ✓ Disabled RLS on ${tableName}`);
+        } catch (error) {
+          logger6.debug(`[Migration] ⊘ Could not disable RLS on ${tableName}`);
+        }
+      }
+    } catch (error) {
+      logger6.debug("[Migration] ⊘ Could not disable RLS (may not have permissions)");
+    }
+    logger6.debug("[Migration] → Handling server_id → message_server_id migrations...");
+    const tablesToMigrate = ["channels", "worlds", "rooms"];
+    for (const tableName of tablesToMigrate) {
+      try {
+        const columnsResult = await db.execute(sql23`
+          SELECT column_name, data_type, is_nullable
+          FROM information_schema.columns
+          WHERE table_schema = 'public'
+            AND table_name = ${tableName}
+            AND column_name IN ('server_id', 'message_server_id')
+          ORDER BY column_name
+        `);
+        const columns = columnsResult.rows || [];
+        const serverId = columns.find((c) => c.column_name === "server_id");
+        const messageServerId = columns.find((c) => c.column_name === "message_server_id");
+        if (serverId && !messageServerId) {
+          logger6.debug(`[Migration] → Renaming ${tableName}.server_id to message_server_id...`);
+          await db.execute(sql23.raw(`ALTER TABLE "${tableName}" RENAME COLUMN "server_id" TO "message_server_id"`));
+          logger6.debug(`[Migration] ✓ Renamed ${tableName}.server_id → message_server_id`);
+          if (serverId.data_type === "text") {
+            try {
+              logger6.debug(`[Migration] → Dropping DEFAULT constraint on ${tableName}.message_server_id...`);
+              await db.execute(sql23.raw(`ALTER TABLE "${tableName}" ALTER COLUMN "message_server_id" DROP DEFAULT`));
+              logger6.debug(`[Migration] ✓ Dropped DEFAULT constraint`);
+              logger6.debug(`[Migration] → Converting ${tableName}.message_server_id from text to uuid...`);
+              await db.execute(sql23.raw(`ALTER TABLE "${tableName}" ALTER COLUMN "message_server_id" TYPE uuid USING "message_server_id"::uuid`));
+              logger6.debug(`[Migration] ✓ Converted ${tableName}.message_server_id to uuid`);
+            } catch (convertError) {
+              logger6.warn(`[Migration] ⚠️ Could not convert ${tableName}.message_server_id to uuid - data may not be valid UUIDs`);
+              logger6.debug(`[Migration] → Setting invalid UUIDs to NULL in ${tableName}.message_server_id...`);
+              await db.execute(sql23.raw(`ALTER TABLE "${tableName}" ALTER COLUMN "message_server_id" TYPE uuid USING CASE WHEN "message_server_id" ~ '^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$' THEN "message_server_id"::uuid ELSE NULL END`));
+            }
+          }
+          if (tableName === "channels") {
+            const nullCountResult = await db.execute(sql23.raw(`SELECT COUNT(*) as count FROM "${tableName}" WHERE "message_server_id" IS NULL`));
+            const nullCount = nullCountResult.rows?.[0]?.count;
+            if (nullCount && parseInt(nullCount) > 0) {
+              logger6.warn(`[Migration] ⚠️ ${tableName} has ${nullCount} rows with NULL message_server_id - these will be deleted`);
+              await db.execute(sql23.raw(`DELETE FROM "${tableName}" WHERE "message_server_id" IS NULL`));
+              logger6.debug(`[Migration] ✓ Deleted ${nullCount} rows with NULL message_server_id from ${tableName}`);
+            }
+            logger6.debug(`[Migration] → Making ${tableName}.message_server_id NOT NULL...`);
+            await db.execute(sql23.raw(`ALTER TABLE "${tableName}" ALTER COLUMN "message_server_id" SET NOT NULL`));
+            logger6.debug(`[Migration] ✓ Set ${tableName}.message_server_id NOT NULL`);
+          }
+        } else if (serverId && messageServerId) {
+          logger6.debug(`[Migration] → ${tableName} has both columns, dropping server_id...`);
+          await db.execute(sql23.raw(`ALTER TABLE "${tableName}" DROP COLUMN "server_id" CASCADE`));
+          logger6.debug(`[Migration] ✓ Dropped ${tableName}.server_id (will be re-added by RuntimeMigrator for RLS)`);
+        } else if (!serverId && messageServerId) {
+          if (messageServerId.data_type === "text") {
+            logger6.debug(`[Migration] → ${tableName}.message_server_id exists but is TEXT, needs UUID conversion...`);
+            logger6.debug(`[Migration] → Dropping DEFAULT constraint on ${tableName}.message_server_id...`);
+            await db.execute(sql23.raw(`ALTER TABLE "${tableName}" ALTER COLUMN "message_server_id" DROP DEFAULT`));
+            logger6.debug(`[Migration] ✓ Dropped DEFAULT constraint`);
+            logger6.debug(`[Migration] → Converting ${tableName}.message_server_id from text to uuid (generating UUIDs from text)...`);
+            await db.execute(sql23.raw(`
+              ALTER TABLE "${tableName}"
+              ALTER COLUMN "message_server_id" TYPE uuid
+              USING CASE
+                WHEN "message_server_id" ~ '^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$'
+                THEN "message_server_id"::uuid
+                ELSE md5("message_server_id")::uuid
+              END
+            `));
+            logger6.debug(`[Migration] ✓ Converted ${tableName}.message_server_id to uuid`);
+          } else {
+            logger6.debug(`[Migration] ⊘ ${tableName}.message_server_id already UUID, skipping`);
+          }
+        } else {
+          logger6.debug(`[Migration] ⊘ ${tableName} already migrated, skipping`);
+        }
+      } catch (error) {
+        logger6.warn(`[Migration] ⚠️ Error migrating ${tableName}.server_id: ${error}`);
+      }
+    }
+    logger6.debug("[Migration] → Dropping all remaining RLS-managed server_id columns...");
+    try {
+      const serverIdColumnsResult = await db.execute(sql23`
+        SELECT table_name
+        FROM information_schema.columns
+        WHERE table_schema = 'public'
+          AND column_name = 'server_id'
+          AND table_name NOT IN (
+            'servers',              -- server_id is the primary key
+            'agents',               -- server_id is in the schema (for RLS)
+            'channels',             -- already handled above
+            'worlds',               -- already handled above
+            'rooms',                -- already handled above
+            'server_agents',        -- server_id is part of composite key
+            'drizzle_migrations',
+            '__drizzle_migrations'
+          )
+        ORDER BY table_name
+      `);
+      const tablesToClean = serverIdColumnsResult.rows || [];
+      logger6.debug(`[Migration] → Found ${tablesToClean.length} tables with server_id columns`);
+      for (const row of tablesToClean) {
+        const tableName = row.table_name;
+        try {
+          await db.execute(sql23.raw(`ALTER TABLE "${tableName}" DROP COLUMN IF EXISTS server_id CASCADE`));
+          logger6.debug(`[Migration] ✓ Dropped server_id from ${tableName}`);
+        } catch (error) {
+          logger6.debug(`[Migration] ⊘ Could not drop server_id from ${tableName}`);
+        }
+      }
+    } catch (error) {
+      logger6.debug("[Migration] ⊘ Could not drop server_id columns (may not have permissions)");
+    }
+    logger6.debug("[Migration] → Checking server_agents table rename...");
+    try {
+      const tablesResult = await db.execute(sql23`
+        SELECT table_name
+        FROM information_schema.tables
+        WHERE table_schema = 'public'
+          AND table_name IN ('server_agents', 'message_server_agents')
+        ORDER BY table_name
+      `);
+      const tables = tablesResult.rows || [];
+      const hasServerAgents = tables.some((t) => t.table_name === "server_agents");
+      const hasMessageServerAgents = tables.some((t) => t.table_name === "message_server_agents");
+      if (hasServerAgents && !hasMessageServerAgents) {
+        logger6.debug("[Migration] → Renaming server_agents to message_server_agents...");
+        await db.execute(sql23.raw(`ALTER TABLE "server_agents" RENAME TO "message_server_agents"`));
+        logger6.debug("[Migration] ✓ Renamed server_agents → message_server_agents");
+        logger6.debug("[Migration] → Renaming message_server_agents.server_id to message_server_id...");
+        await db.execute(sql23.raw(`ALTER TABLE "message_server_agents" RENAME COLUMN "server_id" TO "message_server_id"`));
+        logger6.debug("[Migration] ✓ Renamed message_server_agents.server_id → message_server_id");
+      } else if (!hasServerAgents && !hasMessageServerAgents) {
+        logger6.debug("[Migration] ⊘ No server_agents table to migrate");
+      } else if (hasMessageServerAgents) {
+        logger6.debug("[Migration] → Checking message_server_agents columns...");
+        const columnsResult = await db.execute(sql23`
+          SELECT column_name
+          FROM information_schema.columns
+          WHERE table_schema = 'public'
+            AND table_name = 'message_server_agents'
+            AND column_name IN ('server_id', 'message_server_id')
+          ORDER BY column_name
+        `);
+        const columns = columnsResult.rows || [];
+        const hasServerId = columns.some((c) => c.column_name === "server_id");
+        const hasMessageServerId = columns.some((c) => c.column_name === "message_server_id");
+        if (hasServerId && !hasMessageServerId) {
+          logger6.debug("[Migration] → Renaming message_server_agents.server_id to message_server_id...");
+          await db.execute(sql23.raw(`ALTER TABLE "message_server_agents" RENAME COLUMN "server_id" TO "message_server_id"`));
+          logger6.debug("[Migration] ✓ Renamed message_server_agents.server_id → message_server_id");
+        } else if (!hasServerId && !hasMessageServerId) {
+          logger6.debug("[Migration] → message_server_agents exists without required columns, truncating...");
+          await db.execute(sql23`TRUNCATE TABLE message_server_agents CASCADE`);
+          logger6.debug("[Migration] ✓ Truncated message_server_agents");
+        } else {
+          logger6.debug("[Migration] ⊘ message_server_agents already has correct schema");
+        }
+      }
+    } catch (error) {
+      logger6.debug("[Migration] ⊘ Could not check/migrate server_agents table");
+    }
+    logger6.debug("[Migration] → Checking channel_participants table...");
+    try {
+      const columnsResult = await db.execute(sql23`
+        SELECT column_name
+        FROM information_schema.columns
+        WHERE table_schema = 'public'
+          AND table_name = 'channel_participants'
+          AND column_name IN ('user_id', 'entity_id')
+        ORDER BY column_name
+      `);
+      const columns = columnsResult.rows || [];
+      const hasUserId = columns.some((c) => c.column_name === "user_id");
+      const hasEntityId = columns.some((c) => c.column_name === "entity_id");
+      if (hasUserId && !hasEntityId) {
+        logger6.debug("[Migration] → Renaming channel_participants.user_id to entity_id...");
+        await db.execute(sql23.raw(`ALTER TABLE "channel_participants" RENAME COLUMN "user_id" TO "entity_id"`));
+        logger6.debug("[Migration] ✓ Renamed channel_participants.user_id → entity_id");
+      } else if (!hasUserId && !hasEntityId) {
+        logger6.debug("[Migration] → channel_participants exists without entity_id or user_id, truncating...");
+        await db.execute(sql23`TRUNCATE TABLE channel_participants CASCADE`);
+        logger6.debug("[Migration] ✓ Truncated channel_participants");
+      } else {
+        logger6.debug("[Migration] ⊘ channel_participants already has entity_id column");
+      }
+    } catch (error) {
+      logger6.debug("[Migration] ⊘ Could not check/migrate channel_participants");
+    }
+    logger6.debug("[Migration] → Discovering and dropping all regular indexes...");
+    try {
+      const indexesResult = await db.execute(sql23`
+        SELECT i.relname AS index_name
+        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
+        LEFT JOIN pg_constraint con ON con.conindid = idx.indexrelid
+        WHERE n.nspname = 'public'
+          AND NOT idx.indisprimary  -- Not a primary key
+          AND con.contype IS NULL   -- Not a constraint (unique, etc)
+        ORDER BY i.relname
+      `);
+      const indexesToDrop = indexesResult.rows || [];
+      logger6.debug(`[Migration] → Found ${indexesToDrop.length} indexes to drop`);
+      for (const row of indexesToDrop) {
+        const indexName = row.index_name;
+        try {
+          await db.execute(sql23.raw(`DROP INDEX IF EXISTS "${indexName}"`));
+          logger6.debug(`[Migration] ✓ Dropped index ${indexName}`);
+        } catch (error) {
+          logger6.debug(`[Migration] ⊘ Could not drop index ${indexName}`);
+        }
+      }
+    } catch (error) {
+      logger6.debug("[Migration] ⊘ Could not drop indexes (may not have permissions)");
+    }
+    logger6.info("[Migration] ✓ Migration complete - develop to feat/entity-rls migration finished");
+  } catch (error) {
+    logger6.error("[Migration] Migration failed:", String(error));
+    throw error;
+  }
+}
+var init_migrations = () => {};
+
+// src/rls.ts
+import { logger as logger7, validateUuid } from "@elizaos/core";
+import { sql as sql24, eq } from "drizzle-orm";
+async function installRLSFunctions(adapter) {
+  const db = adapter.db;
+  await db.execute(sql24`
+    CREATE TABLE IF NOT EXISTS servers (
+      id UUID PRIMARY KEY,
+      created_at TIMESTAMPTZ DEFAULT NOW() NOT NULL,
+      updated_at TIMESTAMPTZ DEFAULT NOW() NOT NULL
+    )
+  `);
+  await db.execute(sql24`
+    CREATE OR REPLACE FUNCTION current_server_id() RETURNS UUID AS $$
+    DECLARE
+      app_name TEXT;
+    BEGIN
+      app_name := NULLIF(current_setting('application_name', TRUE), '');
+
+      -- Return NULL if application_name is not set or not a valid UUID
+      -- This allows admin queries to work without RLS restrictions
+      BEGIN
+        RETURN app_name::UUID;
+      EXCEPTION WHEN OTHERS THEN
+        RETURN NULL;
+      END;
+    END;
+    $$ LANGUAGE plpgsql STABLE;
+  `);
+  await db.execute(sql24`
+    CREATE OR REPLACE FUNCTION add_server_isolation(
+      schema_name text,
+      table_name text
+    ) RETURNS void AS $$
+    DECLARE
+      full_table_name text;
+      column_exists boolean;
+      orphaned_count bigint;
+    BEGIN
+      full_table_name := schema_name || '.' || table_name;
+
+      -- Check if server_id column already exists
+      SELECT EXISTS (
+        SELECT 1 FROM information_schema.columns
+        WHERE information_schema.columns.table_schema = schema_name
+          AND information_schema.columns.table_name = add_server_isolation.table_name
+          AND information_schema.columns.column_name = 'server_id'
+      ) INTO column_exists;
+
+      -- Add server_id column if missing (DEFAULT populates it automatically for new rows)
+      IF NOT column_exists THEN
+        EXECUTE format('ALTER TABLE %I.%I ADD COLUMN server_id UUID DEFAULT current_server_id()', schema_name, table_name);
+
+        -- Backfill existing rows with current server_id
+        -- This ensures all existing data belongs to the server instance that is enabling RLS
+        EXECUTE format('UPDATE %I.%I SET server_id = current_server_id() WHERE server_id IS NULL', schema_name, table_name);
+      ELSE
+        -- Column already exists (RLS was previously enabled then disabled)
+        -- Restore the DEFAULT clause (may have been removed during uninstallRLS)
+        EXECUTE format('ALTER TABLE %I.%I ALTER COLUMN server_id SET DEFAULT current_server_id()', schema_name, table_name);
+
+        -- Only backfill NULL server_id rows, do NOT steal data from other servers
+        EXECUTE format('SELECT COUNT(*) FROM %I.%I WHERE server_id IS NULL', schema_name, table_name) INTO orphaned_count;
+
+        IF orphaned_count > 0 THEN
+          RAISE NOTICE 'Backfilling % rows with NULL server_id in %.%', orphaned_count, schema_name, table_name;
+          EXECUTE format('UPDATE %I.%I SET server_id = current_server_id() WHERE server_id IS NULL', schema_name, table_name);
+        END IF;
+      END IF;
+
+      -- Create index for efficient server_id filtering
+      EXECUTE format('CREATE INDEX IF NOT EXISTS idx_%I_server_id ON %I.%I(server_id)', table_name, schema_name, table_name);
+
+      -- Enable RLS on the table
+      EXECUTE format('ALTER TABLE %I.%I ENABLE ROW LEVEL SECURITY', schema_name, table_name);
+
+      -- FORCE RLS even for table owners (critical for security)
+      EXECUTE format('ALTER TABLE %I.%I FORCE ROW LEVEL SECURITY', schema_name, table_name);
+
+      -- Drop existing policy if present
+      EXECUTE format('DROP POLICY IF EXISTS server_isolation_policy ON %I.%I', schema_name, table_name);
+
+      -- Create isolation policy: users can only see/modify rows where server_id matches current server instance
+      -- No NULL clause - all rows must have a valid server_id (backfilled during column addition)
+      EXECUTE format('
+        CREATE POLICY server_isolation_policy ON %I.%I
+        USING (server_id = current_server_id())
+        WITH CHECK (server_id = current_server_id())
+      ', schema_name, table_name);
+    END;
+    $$ LANGUAGE plpgsql;
+  `);
+  await db.execute(sql24`
+    CREATE OR REPLACE FUNCTION apply_rls_to_all_tables() RETURNS void AS $$
+    DECLARE
+      tbl record;
+    BEGIN
+      FOR tbl IN
+        SELECT schemaname, tablename
+        FROM pg_tables
+        WHERE schemaname = 'public'
+          AND tablename NOT IN (
+            'servers',
+            'drizzle_migrations',
+            '__drizzle_migrations'
+          )
+      LOOP
+        BEGIN
+          PERFORM add_server_isolation(tbl.schemaname, tbl.tablename);
+        EXCEPTION WHEN OTHERS THEN
+          RAISE WARNING 'Failed to apply RLS to %.%: %', tbl.schemaname, tbl.tablename, SQLERRM;
+        END;
+      END LOOP;
+    END;
+    $$ LANGUAGE plpgsql;
+  `);
+  logger7.info({ src: "plugin:sql" }, "RLS PostgreSQL functions installed");
+  await installEntityRLS(adapter);
+}
+async function applyRLSToNewTables(adapter) {
+  const db = adapter.db;
+  try {
+    await db.execute(sql24`SELECT apply_rls_to_all_tables()`);
+    logger7.info({ src: "plugin:sql" }, "RLS applied to all tables");
+  } catch (error) {
+    logger7.warn({ src: "plugin:sql", error: String(error) }, "Failed to apply RLS to some tables");
+  }
+}
+async function installEntityRLS(adapter) {
+  const db = adapter.db;
+  logger7.info("[Entity RLS] Installing entity RLS functions and policies...");
+  await db.execute(sql24`
+    CREATE OR REPLACE FUNCTION current_entity_id()
+    RETURNS UUID AS $$
+    DECLARE
+      entity_id_text TEXT;
+    BEGIN
+      -- Read from transaction-local variable
+      entity_id_text := NULLIF(current_setting('app.entity_id', TRUE), '');
+
+      IF entity_id_text IS NULL OR entity_id_text = '' THEN
+        RETURN NULL;
+      END IF;
+
+      BEGIN
+        RETURN entity_id_text::UUID;
+      EXCEPTION WHEN OTHERS THEN
+        RETURN NULL;
+      END;
+    END;
+    $$ LANGUAGE plpgsql STABLE;
+  `);
+  logger7.info("[Entity RLS] Created current_entity_id() function");
+  await db.execute(sql24`
+    CREATE OR REPLACE FUNCTION add_entity_isolation(
+      schema_name text,
+      table_name text,
+      require_entity boolean DEFAULT false
+    ) RETURNS void AS $$
+    DECLARE
+      full_table_name text;
+      has_entity_id boolean;
+      has_author_id boolean;
+      has_channel_id boolean;
+      has_room_id boolean;
+      entity_column_name text;
+      room_column_name text;
+    BEGIN
+      full_table_name := schema_name || '.' || table_name;
+
+      -- Check which columns exist (using camelCase as per schema definition)
+      SELECT EXISTS (
+        SELECT 1 FROM information_schema.columns
+        WHERE information_schema.columns.table_schema = schema_name
+          AND information_schema.columns.table_name = add_entity_isolation.table_name
+          AND information_schema.columns.column_name = 'entityId'
+      ) INTO has_entity_id;
+
+      SELECT EXISTS (
+        SELECT 1 FROM information_schema.columns
+        WHERE information_schema.columns.table_schema = schema_name
+          AND information_schema.columns.table_name = add_entity_isolation.table_name
+          AND information_schema.columns.column_name = 'authorId'
+      ) INTO has_author_id;
+
+      SELECT EXISTS (
+        SELECT 1 FROM information_schema.columns
+        WHERE information_schema.columns.table_schema = schema_name
+          AND information_schema.columns.table_name = add_entity_isolation.table_name
+          AND information_schema.columns.column_name = 'roomId'
+      ) INTO has_room_id;
+
+      -- Skip if no entity-related columns
+      IF NOT (has_entity_id OR has_author_id OR has_room_id) THEN
+        RAISE NOTICE '[Entity RLS] Skipping %.%: no entity columns found', schema_name, table_name;
+        RETURN;
+      END IF;
+
+      -- Determine which column to use for entity filtering
+      -- Priority: roomId (shared access via participants) > entityId/authorId (direct access)
+      --
+      -- SPECIAL CASE: participants table must use direct entityId to avoid infinite recursion
+      IF table_name = 'participants' AND has_entity_id THEN
+        entity_column_name := 'entityId';
+        room_column_name := NULL;
+      ELSIF has_room_id THEN
+        room_column_name := 'roomId';
+        entity_column_name := NULL;
+      ELSIF has_entity_id THEN
+        entity_column_name := 'entityId';
+        room_column_name := NULL;
+      ELSIF has_author_id THEN
+        entity_column_name := 'authorId';
+        room_column_name := NULL;
+      ELSE
+        entity_column_name := NULL;
+        room_column_name := NULL;
+      END IF;
+
+      -- Enable RLS on the table
+      EXECUTE format('ALTER TABLE %I.%I ENABLE ROW LEVEL SECURITY', schema_name, table_name);
+      EXECUTE format('ALTER TABLE %I.%I FORCE ROW LEVEL SECURITY', schema_name, table_name);
+
+      -- Drop existing entity policies if present
+      EXECUTE format('DROP POLICY IF EXISTS entity_isolation_policy ON %I.%I', schema_name, table_name);
+
+      -- CASE 1: Table has roomId or channelId (shared access via participants)
+      IF room_column_name IS NOT NULL THEN
+        -- Determine the corresponding column name in participants table
+        -- If the table has roomId, look for roomId in participants.roomId
+        -- participants table uses: entityId (for participant), roomId (for room)
+        -- RESTRICTIVE: Must pass BOTH server RLS AND entity RLS (combined with AND)
+
+        -- Build policy with or without NULL check based on require_entity parameter
+        IF require_entity THEN
+          -- STRICT MODE: Entity context is REQUIRED (blocks NULL entity_id)
+          EXECUTE format('
+            CREATE POLICY entity_isolation_policy ON %I.%I
+            AS RESTRICTIVE
+            USING (
+              current_entity_id() IS NOT NULL
+              AND %I IN (
+                SELECT "roomId"
+                FROM participants
+                WHERE "entityId" = current_entity_id()
+              )
+            )
+            WITH CHECK (
+              current_entity_id() IS NOT NULL
+              AND %I IN (
+                SELECT "roomId"
+                FROM participants
+                WHERE "entityId" = current_entity_id()
+              )
+            )
+          ', schema_name, table_name, room_column_name, room_column_name);
+          RAISE NOTICE '[Entity RLS] Applied STRICT RESTRICTIVE to %.% (via % → participants.roomId, entity REQUIRED)', schema_name, table_name, room_column_name;
+        ELSE
+          -- PERMISSIVE MODE: NULL entity_id allows system/admin access
+          EXECUTE format('
+            CREATE POLICY entity_isolation_policy ON %I.%I
+            AS RESTRICTIVE
+            USING (
+              current_entity_id() IS NULL
+              OR %I IN (
+                SELECT "roomId"
+                FROM participants
+                WHERE "entityId" = current_entity_id()
+              )
+            )
+            WITH CHECK (
+              current_entity_id() IS NULL
+              OR %I IN (
+                SELECT "roomId"
+                FROM participants
+                WHERE "entityId" = current_entity_id()
+              )
+            )
+          ', schema_name, table_name, room_column_name, room_column_name);
+          RAISE NOTICE '[Entity RLS] Applied PERMISSIVE RESTRICTIVE to %.% (via % → participants.roomId, NULL allowed)', schema_name, table_name, room_column_name;
+        END IF;
+
+      -- CASE 2: Table has direct entity_id or author_id column
+      ELSIF entity_column_name IS NOT NULL THEN
+        -- RESTRICTIVE: Must pass BOTH server RLS AND entity RLS (combined with AND)
+
+        IF require_entity THEN
+          -- STRICT MODE: Entity context is REQUIRED
+          EXECUTE format('
+            CREATE POLICY entity_isolation_policy ON %I.%I
+            AS RESTRICTIVE
+            USING (
+              current_entity_id() IS NOT NULL
+              AND %I = current_entity_id()
+            )
+            WITH CHECK (
+              current_entity_id() IS NOT NULL
+              AND %I = current_entity_id()
+            )
+          ', schema_name, table_name, entity_column_name, entity_column_name);
+          RAISE NOTICE '[Entity RLS] Applied STRICT RESTRICTIVE to %.% (direct column: %, entity REQUIRED)', schema_name, table_name, entity_column_name;
+        ELSE
+          -- PERMISSIVE MODE: NULL entity_id allows system/admin access
+          EXECUTE format('
+            CREATE POLICY entity_isolation_policy ON %I.%I
+            AS RESTRICTIVE
+            USING (
+              current_entity_id() IS NULL
+              OR %I = current_entity_id()
+            )
+            WITH CHECK (
+              current_entity_id() IS NULL
+              OR %I = current_entity_id()
+            )
+          ', schema_name, table_name, entity_column_name, entity_column_name);
+          RAISE NOTICE '[Entity RLS] Applied PERMISSIVE RESTRICTIVE to %.% (direct column: %, NULL allowed)', schema_name, table_name, entity_column_name;
+        END IF;
+      END IF;
+
+      -- Create indexes for efficient entity filtering
+      IF room_column_name IS NOT NULL THEN
+        EXECUTE format('CREATE INDEX IF NOT EXISTS idx_%I_room ON %I.%I(%I)',
+          table_name, schema_name, table_name, room_column_name);
+      END IF;
+
+      IF entity_column_name IS NOT NULL THEN
+        EXECUTE format('CREATE INDEX IF NOT EXISTS idx_%I_entity ON %I.%I(%I)',
+          table_name, schema_name, table_name, entity_column_name);
+      END IF;
+    END;
+    $$ LANGUAGE plpgsql;
+  `);
+  logger7.info("[Entity RLS] Created add_entity_isolation() function");
+  await db.execute(sql24`
+    CREATE OR REPLACE FUNCTION apply_entity_rls_to_all_tables() RETURNS void AS $$
+    DECLARE
+      tbl record;
+      require_entity_for_table boolean;
+    BEGIN
+      FOR tbl IN
+        SELECT schemaname, tablename
+        FROM pg_tables
+        WHERE schemaname = 'public'
+          AND tablename NOT IN (
+            'servers',              -- Server RLS table
+            'users',                -- Authentication table (no entity isolation needed)
+            'entity_mappings',      -- Mapping table (no entity isolation needed)
+            'drizzle_migrations',   -- Migration tracking
+            '__drizzle_migrations'  -- Migration tracking
+          )
+      LOOP
+        BEGIN
+          -- Apply STRICT mode (require_entity=true) to sensitive user-facing tables
+          -- These tables MUST have entity context set to access data
+          -- STRICT tables: memories, logs, components, tasks (user data requiring isolation)
+          -- NOTE: Excluded tables:
+          --   - 'participants': Adding participants is a privileged operation during initialization
+          IF tbl.tablename IN ('memories', 'logs', 'components', 'tasks') THEN
+            require_entity_for_table := true;
+          ELSE
+            -- PERMISSIVE mode (require_entity=false) for system/privileged tables
+            -- This includes: participants, rooms, channels, entities, etc.
+            require_entity_for_table := false;
+          END IF;
+
+          PERFORM add_entity_isolation(tbl.schemaname, tbl.tablename, require_entity_for_table);
+        EXCEPTION WHEN OTHERS THEN
+          RAISE WARNING '[Entity RLS] Failed to apply to %.%: %', tbl.schemaname, tbl.tablename, SQLERRM;
+        END;
+      END LOOP;
+    END;
+    $$ LANGUAGE plpgsql;
+  `);
+  logger7.info("[Entity RLS] Created apply_entity_rls_to_all_tables() function");
+  logger7.info("[Entity RLS] Entity RLS functions installed successfully");
+}
+async function applyEntityRLSToAllTables(adapter) {
+  const db = adapter.db;
+  try {
+    await db.execute(sql24`SELECT apply_entity_rls_to_all_tables()`);
+    logger7.info("[Entity RLS] Applied entity RLS to all eligible tables");
+  } catch (error) {
+    logger7.warn("[Entity RLS] Failed to apply entity RLS to some tables:", String(error));
+  }
+}
+var init_rls = () => {};
+
 // src/migration-service.ts
 var exports_migration_service = {};
 __export(exports_migration_service, {
   DatabaseMigrationService: () => DatabaseMigrationService
 });
-import { logger as logger6 } from "@elizaos/core";
+import { logger as logger8 } from "@elizaos/core";
 
 class DatabaseMigrationService {
   db = null;
@@ -19612,22 +20984,26 @@ class DatabaseMigrationService {
   constructor() {}
   async initializeWithDatabase(db) {
     this.db = db;
+    await migrateToEntityRLS({ db });
     this.migrator = new RuntimeMigrator(db);
     await this.migrator.initialize();
-    logger6.info("DatabaseMigrationService initialized with database and runtime migrator");
+    logger8.info({ src: "plugin:sql" }, "DatabaseMigrationService initialized");
   }
   discoverAndRegisterPluginSchemas(plugins) {
     for (const plugin of plugins) {
       if (plugin.schema) {
         this.registeredSchemas.set(plugin.name, plugin.schema);
-        logger6.info(`Registered schema for plugin: ${plugin.name}`);
       }
     }
-    logger6.info(`Discovered ${this.registeredSchemas.size} plugin schemas out of ${plugins.length} plugins`);
+    logger8.info({
+      src: "plugin:sql",
+      schemasDiscovered: this.registeredSchemas.size,
+      totalPlugins: plugins.length
+    }, "Plugin schemas discovered");
   }
   registerSchema(pluginName, schema) {
     this.registeredSchemas.set(pluginName, schema);
-    logger6.info(`Registered schema for plugin: ${pluginName}`);
+    logger8.debug({ src: "plugin:sql", pluginName }, "Schema registered");
   }
   async runAllPluginMigrations(options) {
     if (!this.db || !this.migrator) {
@@ -19639,12 +21015,12 @@ class DatabaseMigrationService {
       force: options?.force ?? false,
       dryRun: options?.dryRun ?? false
     };
-    logger6.info("[DatabaseMigrationService] Starting migrations");
-    logger6.info(`[DatabaseMigrationService] Environment: ${isProduction ? "PRODUCTION" : "DEVELOPMENT"}`);
-    logger6.info(`[DatabaseMigrationService] Plugins to migrate: ${this.registeredSchemas.size}`);
-    if (migrationOptions.dryRun) {
-      logger6.info("[DatabaseMigrationService] DRY RUN mode - no changes will be applied");
-    }
+    logger8.info({
+      src: "plugin:sql",
+      environment: isProduction ? "PRODUCTION" : "DEVELOPMENT",
+      pluginCount: this.registeredSchemas.size,
+      dryRun: migrationOptions.dryRun
+    }, "Starting migrations");
     let successCount = 0;
     let failureCount = 0;
     const errors = [];
@@ -19652,27 +21028,37 @@ class DatabaseMigrationService {
       try {
         await this.migrator.migrate(pluginName, schema, migrationOptions);
         successCount++;
-        logger6.info(`[DatabaseMigrationService] ✅ Completed: ${pluginName}`);
+        logger8.info({ src: "plugin:sql", pluginName }, "Migration completed");
       } catch (error) {
         failureCount++;
         const errorMessage = error.message;
         errors.push({ pluginName, error });
         if (errorMessage.includes("Destructive migration blocked")) {
-          logger6.error(`[DatabaseMigrationService] ❌ Blocked: ${pluginName} (destructive changes detected)`);
-          if (!migrationOptions.force && process.env.ELIZA_ALLOW_DESTRUCTIVE_MIGRATIONS !== "true") {
-            logger6.error("[DatabaseMigrationService] To allow destructive migrations:");
-            logger6.error("[DatabaseMigrationService]   - Set ELIZA_ALLOW_DESTRUCTIVE_MIGRATIONS=true");
-            logger6.error("[DatabaseMigrationService]   - Or pass { force: true } to this method");
-          }
+          logger8.error({ src: "plugin:sql", pluginName }, "Migration blocked - destructive changes detected. Set ELIZA_ALLOW_DESTRUCTIVE_MIGRATIONS=true or use force option");
         } else {
-          logger6.error(`[DatabaseMigrationService] ❌ Failed: ${pluginName}`, JSON.stringify(error));
+          logger8.error({ src: "plugin:sql", pluginName, error: errorMessage }, "Migration failed");
         }
       }
     }
     if (failureCount === 0) {
-      logger6.info(`[DatabaseMigrationService] All ${successCount} migrations completed successfully`);
+      logger8.info({ src: "plugin:sql", successCount }, "All migrations completed successfully");
+      const dataIsolationEnabled = process.env.ENABLE_DATA_ISOLATION === "true";
+      if (dataIsolationEnabled) {
+        try {
+          logger8.info({ src: "plugin:sql" }, "Re-applying Row Level Security...");
+          await installRLSFunctions({ db: this.db });
+          await applyRLSToNewTables({ db: this.db });
+          await applyEntityRLSToAllTables({ db: this.db });
+          logger8.info({ src: "plugin:sql" }, "RLS re-applied successfully");
+        } catch (rlsError) {
+          const errorMsg = rlsError instanceof Error ? rlsError.message : String(rlsError);
+          logger8.warn({ src: "plugin:sql", error: errorMsg }, "Failed to re-apply RLS (this is OK if server_id columns are not yet in schemas)");
+        }
+      } else {
+        logger8.info({ src: "plugin:sql" }, "Skipping RLS re-application (ENABLE_DATA_ISOLATION is not true)");
+      }
     } else {
-      logger6.error(`[DatabaseMigrationService] Migrations failed: ${failureCount} failed, ${successCount} succeeded`);
+      logger8.error({ src: "plugin:sql", failureCount, successCount }, "Some migrations failed");
       const errorSummary = errors.map((e) => `${e.pluginName}: ${e.error.message}`).join(`
   `);
       throw new Error(`${failureCount} migration(s) failed:
@@ -19685,38 +21071,40 @@ class DatabaseMigrationService {
 }
 var init_migration_service = __esm(() => {
   init_runtime_migrator2();
+  init_migrations();
+  init_rls();
 });
 
 // src/index.browser.ts
 import {
-  logger as logger9
+  logger as logger11
 } from "@elizaos/core/browser";
 
 // src/pglite/adapter.ts
-import { logger as logger8 } from "@elizaos/core";
+import { logger as logger10 } from "@elizaos/core";
 import { drizzle } from "drizzle-orm/pglite";
 
 // src/base.ts
 import {
   ChannelType,
   DatabaseAdapter,
-  logger as logger7
+  logger as logger9
 } from "@elizaos/core";
 import {
   and,
   cosineDistance,
   count,
   desc,
-  eq,
+  eq as eq2,
   gte,
   inArray,
   lt,
   lte,
   or,
-  sql as sql23
+  sql as sql25
 } from "drizzle-orm";
 
-// node_modules/uuid/dist/esm-browser/stringify.js
+// ../../node_modules/uuid/dist/stringify.js
 var byteToHex = [];
 for (let i = 0;i < 256; ++i) {
   byteToHex.push((i + 256).toString(16).slice(1));
@@ -19725,7 +21113,7 @@ function unsafeStringify(arr, offset = 0) {
   return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
 }
 
-// node_modules/uuid/dist/esm-browser/rng.js
+// ../../node_modules/uuid/dist/rng.js
 var getRandomValues;
 var rnds8 = new Uint8Array(16);
 function rng() {
@@ -19738,15 +21126,12 @@ function rng() {
   return getRandomValues(rnds8);
 }
 
-// node_modules/uuid/dist/esm-browser/native.js
+// ../../node_modules/uuid/dist/native.js
 var randomUUID = typeof crypto !== "undefined" && crypto.randomUUID && crypto.randomUUID.bind(crypto);
 var native_default = { randomUUID };
 
-// node_modules/uuid/dist/esm-browser/v4.js
-function v4(options, buf, offset) {
-  if (native_default.randomUUID && !buf && !options) {
-    return native_default.randomUUID();
-  }
+// ../../node_modules/uuid/dist/v4.js
+function _v4(options, buf, offset) {
   options = options || {};
   const rnds = options.random ?? options.rng?.() ?? rng();
   if (rnds.length < 16) {
@@ -19766,6 +21151,12 @@ function v4(options, buf, offset) {
   }
   return unsafeStringify(rnds);
 }
+function v4(options, buf, offset) {
+  if (native_default.randomUUID && !buf && !options) {
+    return native_default.randomUUID();
+  }
+  return _v4(options, buf, offset);
+}
 var v4_default = v4;
 // src/schema/embedding.ts
 import { sql as sql5 } from "drizzle-orm";
@@ -19773,6 +21164,7 @@ import { check as check2, foreignKey as foreignKey2, index as index2, pgTable as
 import { VECTOR_DIMS } from "@elizaos/core";
 
 // src/schema/memory.ts
+init_agent();
 import { relations, sql as sql4 } from "drizzle-orm";
 import {
   boolean as boolean2,
@@ -19786,30 +21178,8 @@ import {
   uuid as uuid4
 } from "drizzle-orm/pg-core";
 
-// src/schema/agent.ts
-import { sql } from "drizzle-orm";
-import { boolean, jsonb, pgTable, text, timestamp, uuid } from "drizzle-orm/pg-core";
-var agentTable = pgTable("agents", {
-  id: uuid("id").primaryKey().defaultRandom(),
-  enabled: boolean("enabled").default(true).notNull(),
-  owner_id: uuid("owner_id"),
-  createdAt: timestamp("created_at", { withTimezone: true }).default(sql`now()`).notNull(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).default(sql`now()`).notNull(),
-  name: text("name").notNull(),
-  username: text("username"),
-  system: text("system").default(""),
-  bio: jsonb("bio").$type().default(sql`'[]'::jsonb`),
-  messageExamples: jsonb("message_examples").$type().default(sql`'[]'::jsonb`).notNull(),
-  postExamples: jsonb("post_examples").$type().default(sql`'[]'::jsonb`).notNull(),
-  topics: jsonb("topics").$type().default(sql`'[]'::jsonb`).notNull(),
-  adjectives: jsonb("adjectives").$type().default(sql`'[]'::jsonb`).notNull(),
-  knowledge: jsonb("knowledge").$type().default(sql`'[]'::jsonb`).notNull(),
-  plugins: jsonb("plugins").$type().default(sql`'[]'::jsonb`).notNull(),
-  settings: jsonb("settings").$type().default(sql`'{}'::jsonb`).notNull(),
-  style: jsonb("style").$type().default(sql`'{}'::jsonb`).notNull()
-});
-
 // src/schema/entity.ts
+init_agent();
 import { sql as sql2 } from "drizzle-orm";
 import { jsonb as jsonb2, pgTable as pgTable2, text as text2, timestamp as timestamp2, unique, uuid as uuid2 } from "drizzle-orm/pg-core";
 var entityTable = pgTable2("entities", {
@@ -19827,6 +21197,7 @@ var entityTable = pgTable2("entities", {
 });
 
 // src/schema/room.ts
+init_agent();
 import { sql as sql3 } from "drizzle-orm";
 import { jsonb as jsonb3, pgTable as pgTable3, text as text3, timestamp as timestamp3, uuid as uuid3 } from "drizzle-orm/pg-core";
 var roomTable = pgTable3("rooms", {
@@ -19836,12 +21207,12 @@ var roomTable = pgTable3("rooms", {
   }),
   source: text3("source").notNull(),
   type: text3("type").notNull(),
-  serverId: text3("serverId"),
+  messageServerId: uuid3("message_server_id"),
   worldId: uuid3("worldId"),
   name: text3("name"),
   metadata: jsonb3("metadata"),
-  channelId: text3("channelId"),
-  createdAt: timestamp3("createdAt").default(sql3`now()`).notNull()
+  channelId: text3("channel_id"),
+  createdAt: timestamp3("created_at").default(sql3`now()`).notNull()
 });
 
 // src/schema/memory.ts
@@ -19933,17 +21304,18 @@ var embeddingTable = pgTable5("embeddings", {
 ]);
 
 // src/schema/index.ts
+init_agent();
 var exports_schema = {};
 __export(exports_schema, {
   worldTable: () => worldTable,
   taskTable: () => taskTable,
-  serverAgentsTable: () => serverAgentsTable,
+  serverTable: () => serverTable,
   roomTable: () => roomTable,
   relationshipTable: () => relationshipTable,
   participantTable: () => participantTable,
-  ownersTable: () => ownersTable,
   messageTable: () => messageTable,
   messageServerTable: () => messageServerTable,
+  messageServerAgentsTable: () => messageServerAgentsTable,
   memoryTable: () => memoryTable,
   logTable: () => logTable,
   entityTable: () => entityTable,
@@ -19956,6 +21328,7 @@ __export(exports_schema, {
 });
 
 // src/schema/cache.ts
+init_agent();
 import { sql as sql6 } from "drizzle-orm";
 import { jsonb as jsonb5, pgTable as pgTable6, text as text5, primaryKey, timestamp as timestamp6, uuid as uuid6 } from "drizzle-orm/pg-core";
 var cacheTable = pgTable6("cache", {
@@ -19964,14 +21337,14 @@ var cacheTable = pgTable6("cache", {
   value: jsonb5("value").notNull(),
   createdAt: timestamp6("created_at", { withTimezone: true }).default(sql6`now()`).notNull(),
   expiresAt: timestamp6("expires_at", { withTimezone: true })
-}, (table) => ({
-  pk: primaryKey({ columns: [table.key, table.agentId] })
-}));
+}, (table) => [primaryKey({ columns: [table.key, table.agentId] })]);
 // src/schema/component.ts
+init_agent();
 import { sql as sql8 } from "drizzle-orm";
 import { jsonb as jsonb7, pgTable as pgTable8, text as text7, timestamp as timestamp8, uuid as uuid8 } from "drizzle-orm/pg-core";
 
 // src/schema/world.ts
+init_agent();
 import { sql as sql7 } from "drizzle-orm";
 import { jsonb as jsonb6, pgTable as pgTable7, text as text6, timestamp as timestamp7, uuid as uuid7 } from "drizzle-orm/pg-core";
 var worldTable = pgTable7("worlds", {
@@ -19979,8 +21352,8 @@ var worldTable = pgTable7("worlds", {
   agentId: uuid7("agentId").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
   name: text6("name").notNull(),
   metadata: jsonb6("metadata"),
-  serverId: text6("serverId").notNull().default("local"),
-  createdAt: timestamp7("createdAt").default(sql7`now()`).notNull()
+  messageServerId: uuid7("message_server_id"),
+  createdAt: timestamp7("created_at").default(sql7`now()`).notNull()
 });
 
 // src/schema/component.ts
@@ -20017,15 +21390,12 @@ var logTable = pgTable9("logs", {
     foreignColumns: [entityTable.id]
   }).onDelete("cascade")
 ]);
-// src/schema/owners.ts
-import { sql as sql10 } from "drizzle-orm";
-import { pgTable as pgTable10, timestamp as timestamp10, uuid as uuid10 } from "drizzle-orm/pg-core";
-var ownersTable = pgTable10("owners", {
-  id: uuid10("id").primaryKey(),
-  createdAt: timestamp10("created_at", { withTimezone: true }).default(sql10`now()`).notNull(),
-  updatedAt: timestamp10("updated_at", { withTimezone: true }).default(sql10`now()`).notNull()
-});
+
+// src/schema/index.ts
+init_server();
+
 // src/schema/participant.ts
+init_agent();
 import { sql as sql11 } from "drizzle-orm";
 import { foreignKey as foreignKey4, index as index3, pgTable as pgTable11, text as text9, timestamp as timestamp11, uuid as uuid11 } from "drizzle-orm/pg-core";
 var participantTable = pgTable11("participants", {
@@ -20056,6 +21426,7 @@ var participantTable = pgTable11("participants", {
   }).onDelete("cascade")
 ]);
 // src/schema/relationship.ts
+init_agent();
 import { sql as sql12 } from "drizzle-orm";
 import {
   foreignKey as foreignKey5,
@@ -20090,6 +21461,7 @@ var relationshipTable = pgTable12("relationships", {
   }).onDelete("cascade")
 ]);
 // src/schema/tasks.ts
+init_agent();
 import { jsonb as jsonb10, pgTable as pgTable13, text as text11, timestamp as timestamp13, uuid as uuid13 } from "drizzle-orm/pg-core";
 import { sql as sql13 } from "drizzle-orm";
 var taskTable = pgTable13("tasks", {
@@ -20099,7 +21471,7 @@ var taskTable = pgTable13("tasks", {
   roomId: uuid13("roomId"),
   worldId: uuid13("worldId"),
   entityId: uuid13("entityId"),
-  agentId: uuid13("agent_id").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
+  agentId: uuid13("agentId").notNull().references(() => agentTable.id, { onDelete: "cascade" }),
   tags: text11("tags").array().default(sql13`'{}'::text[]`),
   metadata: jsonb10("metadata").default(sql13`'{}'::jsonb`),
   createdAt: timestamp13("created_at", { withTimezone: true }).defaultNow(),
@@ -20122,7 +21494,7 @@ import { pgTable as pgTable15, text as text13, jsonb as jsonb12, timestamp as ti
 import { sql as sql15 } from "drizzle-orm";
 var channelTable = pgTable15("channels", {
   id: text13("id").primaryKey(),
-  messageServerId: uuid15("server_id").notNull().references(() => messageServerTable.id, { onDelete: "cascade" }),
+  messageServerId: uuid15("message_server_id").notNull().references(() => messageServerTable.id, { onDelete: "cascade" }),
   name: text13("name").notNull(),
   type: text13("type").notNull(),
   sourceType: text13("source_type"),
@@ -20154,18 +21526,15 @@ var messageTable = pgTable16("central_messages", {
 import { pgTable as pgTable17, text as text15, primaryKey as primaryKey2 } from "drizzle-orm/pg-core";
 var channelParticipantsTable = pgTable17("channel_participants", {
   channelId: text15("channel_id").notNull().references(() => channelTable.id, { onDelete: "cascade" }),
-  userId: text15("user_id").notNull()
-}, (table) => ({
-  pk: primaryKey2({ columns: [table.channelId, table.userId] })
-}));
-// src/schema/serverAgent.ts
+  entityId: text15("entity_id").notNull()
+}, (table) => [primaryKey2({ columns: [table.channelId, table.entityId] })]);
+// src/schema/messageServerAgent.ts
 import { pgTable as pgTable18, uuid as uuid16, primaryKey as primaryKey3 } from "drizzle-orm/pg-core";
-var serverAgentsTable = pgTable18("server_agents", {
-  serverId: uuid16("server_id").notNull().references(() => messageServerTable.id, { onDelete: "cascade" }),
+init_agent();
+var messageServerAgentsTable = pgTable18("message_server_agents", {
+  messageServerId: uuid16("message_server_id").notNull().references(() => messageServerTable.id, { onDelete: "cascade" }),
   agentId: uuid16("agent_id").notNull().references(() => agentTable.id, { onDelete: "cascade" })
-}, (table) => ({
-  pk: primaryKey3({ columns: [table.serverId, table.agentId] })
-}));
+}, (table) => [primaryKey3({ columns: [table.messageServerId, table.agentId] })]);
 // src/base.ts
 class BaseDrizzleAdapter extends DatabaseAdapter {
   maxRetries = 3;
@@ -20227,10 +21596,19 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
           const backoffDelay = Math.min(this.baseDelay * 2 ** (attempt - 1), this.maxDelay);
           const jitter = Math.random() * this.jitterMax;
           const delay = backoffDelay + jitter;
-          logger7.warn(`Database operation failed (attempt ${attempt}/${this.maxRetries}): ${error instanceof Error ? error.message : String(error)}, nextRetryIn: ${(delay / 1000).toFixed(1)}s`);
+          logger9.warn({
+            src: "plugin:sql",
+            attempt,
+            maxRetries: this.maxRetries,
+            error: error instanceof Error ? error.message : String(error)
+          }, "Database operation failed, retrying");
           await new Promise((resolve) => setTimeout(resolve, delay));
         } else {
-          logger7.error(`Max retry attempts reached: ${error instanceof Error ? error.message : String(error)}, totalAttempts: ${attempt}`);
+          logger9.error({
+            src: "plugin:sql",
+            totalAttempts: attempt,
+            error: error instanceof Error ? error.message : String(error)
+          }, "Max retry attempts reached");
           throw error instanceof Error ? error : new Error(String(error));
         }
       }
@@ -20239,7 +21617,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
   }
   async ensureEmbeddingDimension(dimension) {
     return this.withDatabase(async () => {
-      const existingMemory = await this.db.select().from(memoryTable).innerJoin(embeddingTable, eq(embeddingTable.memoryId, memoryTable.id)).where(eq(memoryTable.agentId, this.agentId)).limit(1);
+      const existingMemory = await this.db.select().from(memoryTable).innerJoin(embeddingTable, eq2(embeddingTable.memoryId, memoryTable.id)).where(eq2(memoryTable.agentId, this.agentId)).limit(1);
       if (existingMemory.length > 0) {
         Object.entries(DIMENSION_MAP).find(([_, colName]) => existingMemory[0].embeddings[colName] !== null);
       }
@@ -20248,7 +21626,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
   }
   async getAgent(agentId) {
     return this.withDatabase(async () => {
-      const rows = await this.db.select().from(agentTable).where(eq(agentTable.id, agentId)).limit(1);
+      const rows = await this.db.select().from(agentTable).where(eq2(agentTable.id, agentId)).limit(1);
       if (rows.length === 0)
         return null;
       const row = rows[0];
@@ -20282,9 +21660,9 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
     return this.withDatabase(async () => {
       try {
         if (agent.id) {
-          const existing = await this.db.select({ id: agentTable.id }).from(agentTable).where(eq(agentTable.id, agent.id)).limit(1);
+          const existing = await this.db.select({ id: agentTable.id }).from(agentTable).where(eq2(agentTable.id, agent.id)).limit(1);
           if (existing.length > 0) {
-            logger7.warn(`Attempted to create an agent with a duplicate ID. ID: ${agent.id}`);
+            logger9.warn({ src: "plugin:sql", agentId: agent.id }, "Attempted to create agent with duplicate ID");
             return false;
           }
         }
@@ -20295,10 +21673,13 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
             updatedAt: new Date(agent.updatedAt || Date.now())
           });
         });
-        logger7.debug(`Agent created successfully: ${agent.id}`);
         return true;
       } catch (error) {
-        logger7.error(`Error creating agent: ${error instanceof Error ? error.message : String(error)}, agentId: ${agent.id}`);
+        logger9.error({
+          src: "plugin:sql",
+          agentId: agent.id,
+          error: error instanceof Error ? error.message : String(error)
+        }, "Failed to create agent");
         return false;
       }
     });
@@ -20330,18 +21711,21 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
           } else {
             updateData.updatedAt = new Date;
           }
-          await tx.update(agentTable).set(updateData).where(eq(agentTable.id, agentId));
+          await tx.update(agentTable).set(updateData).where(eq2(agentTable.id, agentId));
         });
-        logger7.debug(`Agent updated successfully: ${agentId}`);
         return true;
       } catch (error) {
-        logger7.error(`Error updating agent: ${error instanceof Error ? error.message : String(error)}, agentId: ${agentId}`);
+        logger9.error({
+          src: "plugin:sql",
+          agentId,
+          error: error instanceof Error ? error.message : String(error)
+        }, "Failed to update agent");
         return false;
       }
     });
   }
   async mergeAgentSettings(tx, agentId, updatedSettings) {
-    const currentAgent = await tx.select({ settings: agentTable.settings }).from(agentTable).where(eq(agentTable.id, agentId)).limit(1);
+    const currentAgent = await tx.select({ settings: agentTable.settings }).from(agentTable).where(eq2(agentTable.id, agentId)).limit(1);
     const currentSettings = currentAgent.length > 0 && currentAgent[0].settings ? currentAgent[0].settings : {};
     const deepMerge = (target, source) => {
       if (source === null) {
@@ -20377,22 +21761,20 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
     return finalSettings === undefined ? {} : finalSettings;
   }
   async deleteAgent(agentId) {
-    logger7.debug(`[DB] Deleting agent with ID: ${agentId}`);
     return this.withDatabase(async () => {
       try {
-        const result = await this.db.delete(agentTable).where(eq(agentTable.id, agentId)).returning();
+        const result = await this.db.delete(agentTable).where(eq2(agentTable.id, agentId)).returning();
         if (result.length === 0) {
-          logger7.warn(`[DB] Agent ${agentId} not found`);
+          logger9.warn({ src: "plugin:sql", agentId }, "Agent not found for deletion");
           return false;
         }
-        logger7.success(`[DB] Agent ${agentId} and all related data successfully deleted via cascade`);
         return true;
       } catch (error) {
-        logger7.error(`[DB] Failed to delete agent ${agentId}: ${error instanceof Error ? error.message : String(error)}`);
-        if (error instanceof Error) {
-          logger7.error(`[DB] Error details: ${error.name} - ${error.message}`);
-          logger7.error(`[DB] Stack trace: ${error.stack}`);
-        }
+        logger9.error({
+          src: "plugin:sql",
+          agentId,
+          error: error instanceof Error ? error.message : String(error)
+        }, "Failed to delete agent");
         throw error;
       }
     });
@@ -20403,7 +21785,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
         const result = await this.db.select({ count: count() }).from(agentTable);
         return result[0]?.count || 0;
       } catch (error) {
-        logger7.error(`Error counting agents: ${error instanceof Error ? error.message : String(error)}`);
+        logger9.error({ src: "plugin:sql", error: error instanceof Error ? error.message : String(error) }, "Failed to count agents");
         return 0;
       }
     });
@@ -20412,9 +21794,8 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
     return this.withDatabase(async () => {
       try {
         await this.db.delete(agentTable);
-        logger7.success("Successfully cleaned up agent table");
       } catch (error) {
-        logger7.error(`Error cleaning up agent table: ${error instanceof Error ? error.message : String(error)}`);
+        logger9.error({ src: "plugin:sql", error: error instanceof Error ? error.message : String(error) }, "Failed to clean up agent table");
         throw error;
       }
     });
@@ -20424,7 +21805,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
       const result = await this.db.select({
         entity: entityTable,
         components: componentTable
-      }).from(entityTable).leftJoin(componentTable, eq(componentTable.entityId, entityTable.id)).where(inArray(entityTable.id, entityIds));
+      }).from(entityTable).leftJoin(componentTable, eq2(componentTable.entityId, entityTable.id)).where(inArray(entityTable.id, entityIds));
       if (result.length === 0)
         return [];
       const entities = {};
@@ -20450,11 +21831,11 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
       const query = this.db.select({
         entity: entityTable,
         ...includeComponents && { components: componentTable }
-      }).from(participantTable).leftJoin(entityTable, and(eq(participantTable.entityId, entityTable.id), eq(entityTable.agentId, this.agentId)));
+      }).from(participantTable).leftJoin(entityTable, and(eq2(participantTable.entityId, entityTable.id), eq2(entityTable.agentId, this.agentId)));
       if (includeComponents) {
-        query.leftJoin(componentTable, eq(componentTable.entityId, entityTable.id));
+        query.leftJoin(componentTable, eq2(componentTable.entityId, entityTable.id));
       }
-      const result = await query.where(eq(participantTable.roomId, roomId));
+      const result = await query.where(eq2(participantTable.roomId, roomId));
       const entitiesByIdMap = new Map;
       for (const row of result) {
         if (!row.entity)
@@ -20493,21 +21874,21 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
             metadata: entity.metadata || {}
           }));
           await tx.insert(entityTable).values(normalizedEntities);
-          logger7.debug(`${entities.length} Entities created successfully`);
           return true;
         });
       } catch (error) {
-        logger7.error(`Error creating entities, entityId: ${entities[0].id}, (metadata?.)name: ${entities[0].metadata?.name}`, error instanceof Error ? error.message : String(error));
-        if (error instanceof Error && error.stack) {
-          logger7.trace("Stack trace:", error.stack);
-        }
+        logger9.error({
+          src: "plugin:sql",
+          entityId: entities[0]?.id,
+          error: error instanceof Error ? error.message : String(error)
+        }, "Failed to create entities");
         return false;
       }
     });
   }
   async ensureEntityExists(entity) {
     if (!entity.id) {
-      logger7.error("Entity ID is required for ensureEntityExists");
+      logger9.error({ src: "plugin:sql" }, "Entity ID is required for ensureEntityExists");
       return false;
     }
     try {
@@ -20517,7 +21898,11 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
       }
       return true;
     } catch (error) {
-      logger7.error(`Error ensuring entity exists: ${error instanceof Error ? error.message : String(error)}, entityId: ${entity.id}`);
+      logger9.error({
+        src: "plugin:sql",
+        entityId: entity.id,
+        error: error instanceof Error ? error.message : String(error)
+      }, "Failed to ensure entity exists");
       return false;
     }
   }
@@ -20531,25 +21916,25 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
         names: this.normalizeEntityNames(entity.names),
         metadata: entity.metadata || {}
       };
-      await this.db.update(entityTable).set(normalizedEntity).where(eq(entityTable.id, entity.id));
+      await this.db.update(entityTable).set(normalizedEntity).where(eq2(entityTable.id, entity.id));
     });
   }
   async deleteEntity(entityId) {
     return this.withDatabase(async () => {
       await this.db.transaction(async (tx) => {
-        await tx.delete(componentTable).where(or(eq(componentTable.entityId, entityId), eq(componentTable.sourceEntityId, entityId)));
-        await tx.delete(entityTable).where(eq(entityTable.id, entityId));
+        await tx.delete(componentTable).where(or(eq2(componentTable.entityId, entityId), eq2(componentTable.sourceEntityId, entityId)));
+        await tx.delete(entityTable).where(eq2(entityTable.id, entityId));
       });
     });
   }
   async getEntitiesByNames(params) {
     return this.withDatabase(async () => {
       const { names, agentId } = params;
-      const nameConditions = names.map((name) => sql23`${name} = ANY(${entityTable.names})`);
-      const query = sql23`
+      const nameConditions = names.map((name) => sql25`${name} = ANY(${entityTable.names})`);
+      const query = sql25`
         SELECT * FROM ${entityTable}
         WHERE ${entityTable.agentId} = ${agentId}
-        AND (${sql23.join(nameConditions, sql23` OR `)})
+        AND (${sql25.join(nameConditions, sql25` OR `)})
       `;
       const result = await this.db.execute(query);
       return result.rows.map((row) => ({
@@ -20564,7 +21949,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
     return this.withDatabase(async () => {
       const { query, agentId, limit = 10 } = params;
       if (!query || query.trim() === "") {
-        const result2 = await this.db.select().from(entityTable).where(eq(entityTable.agentId, agentId)).limit(limit);
+        const result2 = await this.db.select().from(entityTable).where(eq2(entityTable.agentId, agentId)).limit(limit);
         return result2.map((row) => ({
           id: row.id,
           agentId: row.agentId,
@@ -20572,7 +21957,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
           metadata: row.metadata || {}
         }));
       }
-      const searchQuery = sql23`
+      const searchQuery = sql25`
         SELECT * FROM ${entityTable}
         WHERE ${entityTable.agentId} = ${agentId}
         AND EXISTS (
@@ -20592,12 +21977,12 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
   }
   async getComponent(entityId, type, worldId, sourceEntityId) {
     return this.withDatabase(async () => {
-      const conditions = [eq(componentTable.entityId, entityId), eq(componentTable.type, type)];
+      const conditions = [eq2(componentTable.entityId, entityId), eq2(componentTable.type, type)];
       if (worldId) {
-        conditions.push(eq(componentTable.worldId, worldId));
+        conditions.push(eq2(componentTable.worldId, worldId));
       }
       if (sourceEntityId) {
-        conditions.push(eq(componentTable.sourceEntityId, sourceEntityId));
+        conditions.push(eq2(componentTable.sourceEntityId, sourceEntityId));
       }
       const result = await this.db.select().from(componentTable).where(and(...conditions));
       if (result.length === 0)
@@ -20618,12 +22003,12 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
   }
   async getComponents(entityId, worldId, sourceEntityId) {
     return this.withDatabase(async () => {
-      const conditions = [eq(componentTable.entityId, entityId)];
+      const conditions = [eq2(componentTable.entityId, entityId)];
       if (worldId) {
-        conditions.push(eq(componentTable.worldId, worldId));
+        conditions.push(eq2(componentTable.worldId, worldId));
       }
       if (sourceEntityId) {
-        conditions.push(eq(componentTable.sourceEntityId, sourceEntityId));
+        conditions.push(eq2(componentTable.sourceEntityId, sourceEntityId));
       }
       const result = await this.db.select({
         id: componentTable.id,
@@ -20667,7 +22052,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
         await this.db.update(componentTable).set({
           ...component,
           updatedAt: new Date
-        }).where(eq(componentTable.id, component.id));
+        }).where(eq2(componentTable.id, component.id));
       } catch (e) {
         console.error("updateComponent error", e);
       }
@@ -20675,7 +22060,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
   }
   async deleteComponent(componentId) {
     return this.withDatabase(async () => {
-      await this.db.delete(componentTable).where(eq(componentTable.id, componentId));
+      await this.db.delete(componentTable).where(eq2(componentTable.id, componentId));
     });
   }
   async getMemories(params) {
@@ -20685,30 +22070,27 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
     if (offset !== undefined && offset < 0) {
       throw new Error("offset must be a non-negative number");
     }
-    return this.withDatabase(async () => {
-      const conditions = [eq(memoryTable.type, tableName)];
+    return this.withEntityContext(entityId ?? null, async (tx) => {
+      const conditions = [eq2(memoryTable.type, tableName)];
       if (start) {
         conditions.push(gte(memoryTable.createdAt, new Date(start)));
       }
-      if (entityId) {
-        conditions.push(eq(memoryTable.entityId, entityId));
-      }
       if (roomId) {
-        conditions.push(eq(memoryTable.roomId, roomId));
+        conditions.push(eq2(memoryTable.roomId, roomId));
       }
       if (worldId) {
-        conditions.push(eq(memoryTable.worldId, worldId));
+        conditions.push(eq2(memoryTable.worldId, worldId));
       }
       if (end) {
         conditions.push(lte(memoryTable.createdAt, new Date(end)));
       }
       if (unique3) {
-        conditions.push(eq(memoryTable.unique, true));
+        conditions.push(eq2(memoryTable.unique, true));
       }
       if (agentId) {
-        conditions.push(eq(memoryTable.agentId, agentId));
+        conditions.push(eq2(memoryTable.agentId, agentId));
       }
-      const baseQuery = this.db.select({
+      const baseQuery = tx.select({
         memory: {
           id: memoryTable.id,
           type: memoryTable.type,
@@ -20721,7 +22103,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
           metadata: memoryTable.metadata
         },
         embedding: embeddingTable[this.embeddingDimension]
-      }).from(memoryTable).leftJoin(embeddingTable, eq(embeddingTable.memoryId, memoryTable.id)).where(and(...conditions)).orderBy(desc(memoryTable.createdAt));
+      }).from(memoryTable).leftJoin(embeddingTable, eq2(embeddingTable.memoryId, memoryTable.id)).where(and(...conditions)).orderBy(desc(memoryTable.createdAt));
       const rows = await (async () => {
         if (params.count && offset !== undefined && offset > 0) {
           return baseQuery.limit(params.count).offset(offset);
@@ -20752,10 +22134,10 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
       if (params.roomIds.length === 0)
         return [];
       const conditions = [
-        eq(memoryTable.type, params.tableName),
+        eq2(memoryTable.type, params.tableName),
         inArray(memoryTable.roomId, params.roomIds)
       ];
-      conditions.push(eq(memoryTable.agentId, this.agentId));
+      conditions.push(eq2(memoryTable.agentId, this.agentId));
       const query = this.db.select({
         id: memoryTable.id,
         type: memoryTable.type,
@@ -20785,7 +22167,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
       const result = await this.db.select({
         memory: memoryTable,
         embedding: embeddingTable[this.embeddingDimension]
-      }).from(memoryTable).leftJoin(embeddingTable, eq(memoryTable.id, embeddingTable.memoryId)).where(eq(memoryTable.id, id)).limit(1);
+      }).from(memoryTable).leftJoin(embeddingTable, eq2(memoryTable.id, embeddingTable.memoryId)).where(eq2(memoryTable.id, id)).limit(1);
       if (result.length === 0)
         return null;
       const row = result[0];
@@ -20808,12 +22190,12 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
         return [];
       const conditions = [inArray(memoryTable.id, memoryIds)];
       if (tableName) {
-        conditions.push(eq(memoryTable.type, tableName));
+        conditions.push(eq2(memoryTable.type, tableName));
       }
       const rows = await this.db.select({
         memory: memoryTable,
         embedding: embeddingTable[this.embeddingDimension]
-      }).from(memoryTable).leftJoin(embeddingTable, eq(embeddingTable.memoryId, memoryTable.id)).where(and(...conditions)).orderBy(desc(memoryTable.createdAt));
+      }).from(memoryTable).leftJoin(embeddingTable, eq2(embeddingTable.memoryId, memoryTable.id)).where(and(...conditions)).orderBy(desc(memoryTable.createdAt));
       return rows.map((row) => ({
         id: row.memory.id,
         createdAt: row.memory.createdAt.getTime(),
@@ -20830,7 +22212,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
   async getCachedEmbeddings(opts) {
     return this.withDatabase(async () => {
       try {
-        const results = await this.db.execute(sql23`
+        const results = await this.db.execute(sql25`
                     WITH content_text AS (
                         SELECT
                             m.id,
@@ -20870,7 +22252,12 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
           levenshtein_score: Number(row.levenshtein_score)
         })).filter((row) => Array.isArray(row.embedding));
       } catch (error) {
-        logger7.error(`Error in getCachedEmbeddings: ${error instanceof Error ? error.message : String(error)}, tableName: ${opts.query_table_name}, fieldName: ${opts.query_field_name}`);
+        logger9.error({
+          src: "plugin:sql",
+          tableName: opts.query_table_name,
+          fieldName: opts.query_field_name,
+          error: error instanceof Error ? error.message : String(error)
+        }, "Failed to get cached embeddings");
         if (error instanceof Error && error.message === "levenshtein argument exceeds maximum length of 255 characters") {
           return [];
         }
@@ -20883,16 +22270,22 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
       try {
         const sanitizedBody = this.sanitizeJsonObject(params.body);
         const jsonString = JSON.stringify(sanitizedBody);
-        await this.db.transaction(async (tx) => {
+        await this.withEntityContext(params.entityId, async (tx) => {
           await tx.insert(logTable).values({
-            body: sql23`${jsonString}::jsonb`,
+            body: sql25`${jsonString}::jsonb`,
             entityId: params.entityId,
             roomId: params.roomId,
             type: params.type
           });
         });
       } catch (error) {
-        logger7.error(`Failed to create log entry: ${error instanceof Error ? error.message : String(error)}, type: ${params.type}, roomId: ${params.roomId}, entityId: ${params.entityId}`);
+        logger9.error({
+          src: "plugin:sql",
+          type: params.type,
+          roomId: params.roomId,
+          entityId: params.entityId,
+          error: error instanceof Error ? error.message : String(error)
+        }, "Failed to create log entry");
         throw error;
       }
     });
@@ -20925,8 +22318,8 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
   }
   async getLogs(params) {
     const { entityId, roomId, type, count: count2, offset } = params;
-    return this.withDatabase(async () => {
-      const result = await this.db.select().from(logTable).where(and(eq(logTable.entityId, entityId), roomId ? eq(logTable.roomId, roomId) : undefined, type ? eq(logTable.type, type) : undefined)).orderBy(desc(logTable.createdAt)).limit(count2 ?? 10).offset(offset ?? 0);
+    return this.withEntityContext(entityId ?? null, async (tx) => {
+      const result = await tx.select().from(logTable).where(and(roomId ? eq2(logTable.roomId, roomId) : undefined, type ? eq2(logTable.type, type) : undefined)).orderBy(desc(logTable.createdAt)).limit(count2 ?? 10).offset(offset ?? 0);
       const logs = result.map((log2) => ({
         ...log2,
         id: log2.id,
@@ -20944,15 +22337,15 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
     const limit = Math.min(Math.max(params.limit ?? 20, 1), 100);
     const fromDate = typeof params.from === "number" ? new Date(params.from) : undefined;
     const toDate = typeof params.to === "number" ? new Date(params.to) : undefined;
-    return this.withDatabase(async () => {
+    return this.withEntityContext(params.entityId ?? null, async (tx) => {
       const runMap = new Map;
       const conditions = [
-        eq(logTable.type, "run_event"),
-        sql23`${logTable.body} ? 'runId'`,
-        eq(roomTable.agentId, this.agentId)
+        eq2(logTable.type, "run_event"),
+        sql25`${logTable.body} ? 'runId'`,
+        eq2(roomTable.agentId, this.agentId)
       ];
       if (params.roomId) {
-        conditions.push(eq(logTable.roomId, params.roomId));
+        conditions.push(eq2(logTable.roomId, params.roomId));
       }
       if (fromDate) {
         conditions.push(gte(logTable.createdAt, fromDate));
@@ -20962,15 +22355,15 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
       }
       const whereClause = and(...conditions);
       const eventLimit = Math.max(limit * 20, 200);
-      const runEventRows = await this.db.select({
-        runId: sql23`(${logTable.body} ->> 'runId')`,
-        status: sql23`(${logTable.body} ->> 'status')`,
-        messageId: sql23`(${logTable.body} ->> 'messageId')`,
+      const runEventRows = await tx.select({
+        runId: sql25`(${logTable.body} ->> 'runId')`,
+        status: sql25`(${logTable.body} ->> 'status')`,
+        messageId: sql25`(${logTable.body} ->> 'messageId')`,
         rawBody: logTable.body,
         createdAt: logTable.createdAt,
         roomId: logTable.roomId,
         entityId: logTable.entityId
-      }).from(logTable).innerJoin(roomTable, eq(roomTable.id, logTable.roomId)).where(whereClause).orderBy(desc(logTable.createdAt)).limit(eventLimit);
+      }).from(logTable).innerJoin(roomTable, eq2(roomTable.id, logTable.roomId)).where(whereClause).orderBy(desc(logTable.createdAt)).limit(eventLimit);
       for (const row of runEventRows) {
         const runId = row.runId;
         if (!runId)
@@ -21039,8 +22432,8 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
       }
       const runIds = limitedRuns.map((run) => run.runId).filter(Boolean);
       if (runIds.length > 0) {
-        const runIdArray = sql23`array[${sql23.join(runIds.map((id) => sql23`${id}`), sql23`, `)}]::text[]`;
-        const actionSummary = await this.db.execute(sql23`
+        const runIdArray = sql25`array[${sql25.join(runIds.map((id) => sql25`${id}`), sql25`, `)}]::text[]`;
+        const actionSummary = await this.db.execute(sql25`
           SELECT
             body->>'runId' as "runId",
             COUNT(*)::int as "actions",
@@ -21060,7 +22453,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
           counts.errors += Number(row.errors ?? 0);
           counts.modelCalls += Number(row.modelCalls ?? 0);
         }
-        const evaluatorSummary = await this.db.execute(sql23`
+        const evaluatorSummary = await this.db.execute(sql25`
           SELECT
             body->>'runId' as "runId",
             COUNT(*)::int as "evaluators"
@@ -21076,7 +22469,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
             continue;
           counts.evaluators += Number(row.evaluators ?? 0);
         }
-        const genericSummary = await this.db.execute(sql23`
+        const genericSummary = await this.db.execute(sql25`
           SELECT
             body->>'runId' as "runId",
             COUNT(*) FILTER (WHERE type LIKE 'useModel:%')::int as "modelLogs",
@@ -21112,7 +22505,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
   }
   async deleteLog(logId) {
     return this.withDatabase(async () => {
-      await this.db.delete(logTable).where(eq(logTable.id, logId));
+      await this.db.delete(logTable).where(eq2(logTable.id, logId));
     });
   }
   async searchMemories(params) {
@@ -21129,20 +22522,20 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
   async searchMemoriesByEmbedding(embedding, params) {
     return this.withDatabase(async () => {
       const cleanVector = embedding.map((n) => Number.isFinite(n) ? Number(n.toFixed(6)) : 0);
-      const similarity = sql23`1 - (${cosineDistance(embeddingTable[this.embeddingDimension], cleanVector)})`;
-      const conditions = [eq(memoryTable.type, params.tableName)];
+      const similarity = sql25`1 - (${cosineDistance(embeddingTable[this.embeddingDimension], cleanVector)})`;
+      const conditions = [eq2(memoryTable.type, params.tableName)];
       if (params.unique) {
-        conditions.push(eq(memoryTable.unique, true));
+        conditions.push(eq2(memoryTable.unique, true));
       }
-      conditions.push(eq(memoryTable.agentId, this.agentId));
+      conditions.push(eq2(memoryTable.agentId, this.agentId));
       if (params.roomId) {
-        conditions.push(eq(memoryTable.roomId, params.roomId));
+        conditions.push(eq2(memoryTable.roomId, params.roomId));
       }
       if (params.worldId) {
-        conditions.push(eq(memoryTable.worldId, params.worldId));
+        conditions.push(eq2(memoryTable.worldId, params.worldId));
       }
       if (params.entityId) {
-        conditions.push(eq(memoryTable.entityId, params.entityId));
+        conditions.push(eq2(memoryTable.entityId, params.entityId));
       }
       if (params.match_threshold) {
         conditions.push(gte(similarity, params.match_threshold));
@@ -21151,7 +22544,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
         memory: memoryTable,
         similarity,
         embedding: embeddingTable[this.embeddingDimension]
-      }).from(embeddingTable).innerJoin(memoryTable, eq(memoryTable.id, embeddingTable.memoryId)).where(and(...conditions)).orderBy(desc(similarity)).limit(params.count ?? 10);
+      }).from(embeddingTable).innerJoin(memoryTable, eq2(memoryTable.id, embeddingTable.memoryId)).where(and(...conditions)).orderBy(desc(similarity)).limit(params.count ?? 10);
       return results.map((row) => ({
         id: row.memory.id,
         type: row.memory.type,
@@ -21169,11 +22562,9 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
     });
   }
   async createMemory(memory, tableName) {
-    logger7.debug(`DrizzleAdapter createMemory: memoryId: ${memory.id}, embeddingLength: ${memory.embedding?.length}, contentLength: ${memory.content?.text?.length}`);
     const memoryId = memory.id ?? v4_default();
     const existing = await this.getMemoryById(memoryId);
     if (existing) {
-      logger7.debug(`Memory already exists, skipping creation: ${memoryId}`);
       return memoryId;
     }
     if (memory.unique === undefined) {
@@ -21192,13 +22583,13 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
     }
     const contentToInsert = typeof memory.content === "string" ? memory.content : JSON.stringify(memory.content ?? {});
     const metadataToInsert = typeof memory.metadata === "string" ? memory.metadata : JSON.stringify(memory.metadata ?? {});
-    await this.db.transaction(async (tx) => {
+    await this.withEntityContext(memory.entityId, async (tx) => {
       await tx.insert(memoryTable).values([
         {
           id: memoryId,
           type: tableName,
-          content: sql23`${contentToInsert}::jsonb`,
-          metadata: sql23`${metadataToInsert}::jsonb`,
+          content: sql25`${contentToInsert}::jsonb`,
+          metadata: sql25`${metadataToInsert}::jsonb`,
           entityId: memory.entityId,
           roomId: memory.roomId,
           worldId: memory.worldId,
@@ -21223,28 +22614,27 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
   async updateMemory(memory) {
     return this.withDatabase(async () => {
       try {
-        logger7.debug(`Updating memory: memoryId: ${memory.id}, hasEmbedding: ${!!memory.embedding}`);
         await this.db.transaction(async (tx) => {
           if (memory.content) {
             const contentToUpdate = typeof memory.content === "string" ? memory.content : JSON.stringify(memory.content ?? {});
             const metadataToUpdate = typeof memory.metadata === "string" ? memory.metadata : JSON.stringify(memory.metadata ?? {});
             await tx.update(memoryTable).set({
-              content: sql23`${contentToUpdate}::jsonb`,
-              ...memory.metadata && { metadata: sql23`${metadataToUpdate}::jsonb` }
-            }).where(eq(memoryTable.id, memory.id));
+              content: sql25`${contentToUpdate}::jsonb`,
+              ...memory.metadata && { metadata: sql25`${metadataToUpdate}::jsonb` }
+            }).where(eq2(memoryTable.id, memory.id));
           } else if (memory.metadata) {
             const metadataToUpdate = typeof memory.metadata === "string" ? memory.metadata : JSON.stringify(memory.metadata ?? {});
             await tx.update(memoryTable).set({
-              metadata: sql23`${metadataToUpdate}::jsonb`
-            }).where(eq(memoryTable.id, memory.id));
+              metadata: sql25`${metadataToUpdate}::jsonb`
+            }).where(eq2(memoryTable.id, memory.id));
           }
           if (memory.embedding && Array.isArray(memory.embedding)) {
             const cleanVector = memory.embedding.map((n) => Number.isFinite(n) ? Number(n.toFixed(6)) : 0);
-            const existingEmbedding = await tx.select({ id: embeddingTable.id }).from(embeddingTable).where(eq(embeddingTable.memoryId, memory.id)).limit(1);
+            const existingEmbedding = await tx.select({ id: embeddingTable.id }).from(embeddingTable).where(eq2(embeddingTable.memoryId, memory.id)).limit(1);
             if (existingEmbedding.length > 0) {
               const updateValues = {};
               updateValues[this.embeddingDimension] = cleanVector;
-              await tx.update(embeddingTable).set(updateValues).where(eq(embeddingTable.memoryId, memory.id));
+              await tx.update(embeddingTable).set(updateValues).where(eq2(embeddingTable.memoryId, memory.id));
             } else {
               const embeddingValues = {
                 id: v4_default(),
@@ -21255,10 +22645,13 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
             }
           }
         });
-        logger7.debug(`Memory updated successfully: ${memory.id}`);
         return true;
       } catch (error) {
-        logger7.error(`Error updating memory: ${error instanceof Error ? error.message : String(error)}, memoryId: ${memory.id}`);
+        logger9.error({
+          src: "plugin:sql",
+          memoryId: memory.id,
+          error: error instanceof Error ? error.message : String(error)
+        }, "Failed to update memory");
         return false;
       }
     });
@@ -21267,10 +22660,9 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
     return this.withDatabase(async () => {
       await this.db.transaction(async (tx) => {
         await this.deleteMemoryFragments(tx, memoryId);
-        await tx.delete(embeddingTable).where(eq(embeddingTable.memoryId, memoryId));
-        await tx.delete(memoryTable).where(eq(memoryTable.id, memoryId));
+        await tx.delete(embeddingTable).where(eq2(embeddingTable.memoryId, memoryId));
+        await tx.delete(memoryTable).where(eq2(memoryTable.id, memoryId));
       });
-      logger7.debug(`Memory and related fragments removed successfully: ${memoryId}`);
     });
   }
   async deleteManyMemories(memoryIds) {
@@ -21289,7 +22681,6 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
           await tx.delete(memoryTable).where(inArray(memoryTable.id, batch));
         }
       });
-      logger7.debug(`Batch memory deletion completed successfully: ${memoryIds.length}`);
     });
   }
   async deleteMemoryFragments(tx, documentId) {
@@ -21298,40 +22689,38 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
       const fragmentIds = fragmentsToDelete.map((f) => f.id);
       await tx.delete(embeddingTable).where(inArray(embeddingTable.memoryId, fragmentIds));
       await tx.delete(memoryTable).where(inArray(memoryTable.id, fragmentIds));
-      logger7.debug(`Deleted related fragments: documentId: ${documentId}, fragmentCount: ${fragmentsToDelete.length}`);
     }
   }
   async getMemoryFragments(tx, documentId) {
-    const fragments = await tx.select({ id: memoryTable.id }).from(memoryTable).where(and(eq(memoryTable.agentId, this.agentId), sql23`${memoryTable.metadata}->>'documentId' = ${documentId}`));
+    const fragments = await tx.select({ id: memoryTable.id }).from(memoryTable).where(and(eq2(memoryTable.agentId, this.agentId), sql25`${memoryTable.metadata}->>'documentId' = ${documentId}`));
     return fragments.map((f) => ({ id: f.id }));
   }
   async deleteAllMemories(roomId, tableName) {
     return this.withDatabase(async () => {
       await this.db.transaction(async (tx) => {
-        const rows = await tx.select({ id: memoryTable.id }).from(memoryTable).where(and(eq(memoryTable.roomId, roomId), eq(memoryTable.type, tableName)));
+        const rows = await tx.select({ id: memoryTable.id }).from(memoryTable).where(and(eq2(memoryTable.roomId, roomId), eq2(memoryTable.type, tableName)));
         const ids = rows.map((r) => r.id);
-        logger7.debug(`[deleteAllMemories] memory IDs to delete: roomId: ${roomId}, tableName: ${tableName}, ids: ${JSON.stringify(ids)}`);
+        logger9.debug({ src: "plugin:sql", roomId, tableName, memoryCount: ids.length }, "Deleting all memories");
         if (ids.length === 0) {
           return;
         }
         await Promise.all(ids.map(async (memoryId) => {
           await this.deleteMemoryFragments(tx, memoryId);
-          await tx.delete(embeddingTable).where(eq(embeddingTable.memoryId, memoryId));
+          await tx.delete(embeddingTable).where(eq2(embeddingTable.memoryId, memoryId));
         }));
-        await tx.delete(memoryTable).where(and(eq(memoryTable.roomId, roomId), eq(memoryTable.type, tableName)));
+        await tx.delete(memoryTable).where(and(eq2(memoryTable.roomId, roomId), eq2(memoryTable.type, tableName)));
       });
-      logger7.debug(`All memories removed successfully: roomId: ${roomId}, tableName: ${tableName}`);
     });
   }
   async countMemories(roomId, unique3 = true, tableName = "") {
     if (!tableName)
       throw new Error("tableName is required");
     return this.withDatabase(async () => {
-      const conditions = [eq(memoryTable.roomId, roomId), eq(memoryTable.type, tableName)];
+      const conditions = [eq2(memoryTable.roomId, roomId), eq2(memoryTable.type, tableName)];
       if (unique3) {
-        conditions.push(eq(memoryTable.unique, true));
+        conditions.push(eq2(memoryTable.unique, true));
       }
-      const result = await this.db.select({ count: sql23`count(*)` }).from(memoryTable).where(and(...conditions));
+      const result = await this.db.select({ count: sql25`count(*)` }).from(memoryTable).where(and(...conditions));
       return Number(result[0]?.count ?? 0);
     });
   }
@@ -21342,18 +22731,19 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
         name: roomTable.name,
         channelId: roomTable.channelId,
         agentId: roomTable.agentId,
-        serverId: roomTable.serverId,
+        messageServerId: roomTable.messageServerId,
         worldId: roomTable.worldId,
         type: roomTable.type,
         source: roomTable.source,
         metadata: roomTable.metadata
-      }).from(roomTable).where(and(inArray(roomTable.id, roomIds), eq(roomTable.agentId, this.agentId)));
+      }).from(roomTable).where(and(inArray(roomTable.id, roomIds), eq2(roomTable.agentId, this.agentId)));
       const rooms = result.map((room) => ({
         ...room,
         id: room.id,
         name: room.name ?? undefined,
         agentId: room.agentId,
-        serverId: room.serverId,
+        messageServerId: room.messageServerId,
+        serverId: room.messageServerId,
         worldId: room.worldId,
         channelId: room.channelId,
         type: room.type,
@@ -21364,13 +22754,14 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
   }
   async getRoomsByWorld(worldId) {
     return this.withDatabase(async () => {
-      const result = await this.db.select().from(roomTable).where(eq(roomTable.worldId, worldId));
+      const result = await this.db.select().from(roomTable).where(eq2(roomTable.worldId, worldId));
       const rooms = result.map((room) => ({
         ...room,
         id: room.id,
         name: room.name ?? undefined,
         agentId: room.agentId,
-        serverId: room.serverId,
+        messageServerId: room.messageServerId,
+        serverId: room.messageServerId,
         worldId: room.worldId,
         channelId: room.channelId,
         type: room.type,
@@ -21381,7 +22772,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
   }
   async updateRoom(room) {
     return this.withDatabase(async () => {
-      await this.db.update(roomTable).set({ ...room, agentId: this.agentId }).where(eq(roomTable.id, room.id));
+      await this.db.update(roomTable).set({ ...room, agentId: this.agentId }).where(eq2(roomTable.id, room.id));
     });
   }
   async createRooms(rooms) {
@@ -21401,19 +22792,19 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
       throw new Error("Room ID is required");
     return this.withDatabase(async () => {
       await this.db.transaction(async (tx) => {
-        await tx.delete(roomTable).where(eq(roomTable.id, roomId));
+        await tx.delete(roomTable).where(eq2(roomTable.id, roomId));
       });
     });
   }
   async getRoomsForParticipant(entityId) {
     return this.withDatabase(async () => {
-      const result = await this.db.select({ roomId: participantTable.roomId }).from(participantTable).innerJoin(roomTable, eq(participantTable.roomId, roomTable.id)).where(and(eq(participantTable.entityId, entityId), eq(roomTable.agentId, this.agentId)));
+      const result = await this.db.select({ roomId: participantTable.roomId }).from(participantTable).innerJoin(roomTable, eq2(participantTable.roomId, roomTable.id)).where(and(eq2(participantTable.entityId, entityId), eq2(roomTable.agentId, this.agentId)));
       return result.map((row) => row.roomId);
     });
   }
   async getRoomsForParticipants(entityIds) {
     return this.withDatabase(async () => {
-      const result = await this.db.selectDistinct({ roomId: participantTable.roomId }).from(participantTable).innerJoin(roomTable, eq(participantTable.roomId, roomTable.id)).where(and(inArray(participantTable.entityId, entityIds), eq(roomTable.agentId, this.agentId)));
+      const result = await this.db.selectDistinct({ roomId: participantTable.roomId }).from(participantTable).innerJoin(roomTable, eq2(participantTable.roomId, roomTable.id)).where(and(inArray(participantTable.entityId, entityIds), eq2(roomTable.agentId, this.agentId)));
       return result.map((row) => row.roomId);
     });
   }
@@ -21427,7 +22818,13 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
         }).onConflictDoNothing();
         return true;
       } catch (error) {
-        logger7.error(`Error adding participant to room: ${error instanceof Error ? error.message : String(error)}, entityId: ${entityId}, roomId: ${roomId}, agentId: ${this.agentId}`);
+        logger9.error({
+          src: "plugin:sql",
+          entityId,
+          roomId,
+          agentId: this.agentId,
+          error: error instanceof Error ? error.message : String(error)
+        }, "Failed to add participant to room");
         return false;
       }
     });
@@ -21441,10 +22838,14 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
           agentId: this.agentId
         }));
         await this.db.insert(participantTable).values(values).onConflictDoNothing().execute();
-        logger7.debug(`${entityIds.length} Entities linked successfully`);
         return true;
       } catch (error) {
-        logger7.error(`Error adding participants to room: ${error instanceof Error ? error.message : String(error)}, entityIdSample: ${entityIds[0]}, roomId: ${roomId}, agentId: ${this.agentId}`);
+        logger9.error({
+          src: "plugin:sql",
+          roomId,
+          agentId: this.agentId,
+          error: error instanceof Error ? error.message : String(error)
+        }, "Failed to add participants to room");
         return false;
       }
     });
@@ -21453,13 +22854,17 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
     return this.withDatabase(async () => {
       try {
         const result = await this.db.transaction(async (tx) => {
-          return await tx.delete(participantTable).where(and(eq(participantTable.entityId, entityId), eq(participantTable.roomId, roomId))).returning();
+          return await tx.delete(participantTable).where(and(eq2(participantTable.entityId, entityId), eq2(participantTable.roomId, roomId))).returning();
         });
         const removed = result.length > 0;
-        logger7.debug(`Participant ${removed ? "removed" : "not found"}: entityId: ${entityId}, roomId: ${roomId}, removed: ${removed}`);
         return removed;
       } catch (error) {
-        logger7.error(`Error removing participant from room: ${error instanceof Error ? error.message : String(error)}, entityId: ${entityId}, roomId: ${roomId}`);
+        logger9.error({
+          src: "plugin:sql",
+          entityId,
+          roomId,
+          error: error instanceof Error ? error.message : String(error)
+        }, "Failed to remove participant from room");
         return false;
       }
     });
@@ -21470,7 +22875,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
         id: participantTable.id,
         entityId: participantTable.entityId,
         roomId: participantTable.roomId
-      }).from(participantTable).where(eq(participantTable.entityId, entityId));
+      }).from(participantTable).where(eq2(participantTable.entityId, entityId));
       const entities = await this.getEntitiesByIds([entityId]);
       if (!entities || !entities.length) {
         return [];
@@ -21483,13 +22888,19 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
   }
   async getParticipantsForRoom(roomId) {
     return this.withDatabase(async () => {
-      const result = await this.db.select({ entityId: participantTable.entityId }).from(participantTable).where(eq(participantTable.roomId, roomId));
+      const result = await this.db.select({ entityId: participantTable.entityId }).from(participantTable).where(eq2(participantTable.roomId, roomId));
       return result.map((row) => row.entityId);
     });
   }
+  async isRoomParticipant(roomId, entityId) {
+    return this.withDatabase(async () => {
+      const result = await this.db.select().from(participantTable).where(and(eq2(participantTable.roomId, roomId), eq2(participantTable.entityId, entityId))).limit(1);
+      return result.length > 0;
+    });
+  }
   async getParticipantUserState(roomId, entityId) {
     return this.withDatabase(async () => {
-      const result = await this.db.select({ roomState: participantTable.roomState }).from(participantTable).where(and(eq(participantTable.roomId, roomId), eq(participantTable.entityId, entityId), eq(participantTable.agentId, this.agentId))).limit(1);
+      const result = await this.db.select({ roomState: participantTable.roomState }).from(participantTable).where(and(eq2(participantTable.roomId, roomId), eq2(participantTable.entityId, entityId), eq2(participantTable.agentId, this.agentId))).limit(1);
       return result[0]?.roomState ?? null;
     });
   }
@@ -21497,10 +22908,16 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
     return this.withDatabase(async () => {
       try {
         await this.db.transaction(async (tx) => {
-          await tx.update(participantTable).set({ roomState: state }).where(and(eq(participantTable.roomId, roomId), eq(participantTable.entityId, entityId), eq(participantTable.agentId, this.agentId)));
+          await tx.update(participantTable).set({ roomState: state }).where(and(eq2(participantTable.roomId, roomId), eq2(participantTable.entityId, entityId), eq2(participantTable.agentId, this.agentId)));
         });
       } catch (error) {
-        logger7.error(`Error setting participant follow state: roomId: ${roomId}, entityId: ${entityId}, state: ${state}, error: ${error instanceof Error ? error.message : String(error)}`);
+        logger9.error({
+          src: "plugin:sql",
+          roomId,
+          entityId,
+          state,
+          error: error instanceof Error ? error.message : String(error)
+        }, "Failed to set participant follow state");
         throw error;
       }
     });
@@ -21520,7 +22937,12 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
         await this.db.insert(relationshipTable).values(saveParams);
         return true;
       } catch (error) {
-        logger7.error(`Error creating relationship: ${error instanceof Error ? error.message : String(error)}, saveParams: ${JSON.stringify(saveParams)}`);
+        logger9.error({
+          src: "plugin:sql",
+          agentId: this.agentId,
+          error: error instanceof Error ? error.message : String(error),
+          saveParams
+        }, "Error creating relationship");
         return false;
       }
     });
@@ -21531,9 +22953,14 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
         await this.db.update(relationshipTable).set({
           tags: relationship.tags || [],
           metadata: relationship.metadata || {}
-        }).where(eq(relationshipTable.id, relationship.id));
+        }).where(eq2(relationshipTable.id, relationship.id));
       } catch (error) {
-        logger7.error(`Error updating relationship: ${error instanceof Error ? error.message : String(error)}, relationship: ${JSON.stringify(relationship)}`);
+        logger9.error({
+          src: "plugin:sql",
+          agentId: this.agentId,
+          error: error instanceof Error ? error.message : String(error),
+          relationshipId: relationship.id
+        }, "Error updating relationship");
         throw error;
       }
     });
@@ -21541,7 +22968,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
   async getRelationship(params) {
     return this.withDatabase(async () => {
       const { sourceEntityId, targetEntityId } = params;
-      const result = await this.db.select().from(relationshipTable).where(and(eq(relationshipTable.sourceEntityId, sourceEntityId), eq(relationshipTable.targetEntityId, targetEntityId)));
+      const result = await this.db.select().from(relationshipTable).where(and(eq2(relationshipTable.sourceEntityId, sourceEntityId), eq2(relationshipTable.targetEntityId, targetEntityId)));
       if (result.length === 0)
         return null;
       const relationship = result[0];
@@ -21562,13 +22989,13 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
       const { entityId, tags } = params;
       let query;
       if (tags && tags.length > 0) {
-        query = sql23`
+        query = sql25`
           SELECT * FROM ${relationshipTable}
           WHERE (${relationshipTable.sourceEntityId} = ${entityId} OR ${relationshipTable.targetEntityId} = ${entityId})
-          AND ${relationshipTable.tags} && CAST(ARRAY[${sql23.join(tags, sql23`, `)}] AS text[])
+          AND ${relationshipTable.tags} && CAST(ARRAY[${sql25.join(tags, sql25`, `)}] AS text[])
         `;
       } else {
-        query = sql23`
+        query = sql25`
           SELECT * FROM ${relationshipTable}
           WHERE ${relationshipTable.sourceEntityId} = ${entityId} OR ${relationshipTable.targetEntityId} = ${entityId}
         `;
@@ -21577,25 +23004,30 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
       return result.rows.map((relationship) => ({
         ...relationship,
         id: relationship.id,
-        sourceEntityId: relationship.sourceEntityId,
-        targetEntityId: relationship.targetEntityId,
-        agentId: relationship.agentId,
+        sourceEntityId: relationship.source_entity_id || relationship.sourceEntityId,
+        targetEntityId: relationship.target_entity_id || relationship.targetEntityId,
+        agentId: relationship.agent_id || relationship.agentId,
         tags: relationship.tags ?? [],
         metadata: relationship.metadata ?? {},
-        createdAt: relationship.createdAt ? relationship.createdAt instanceof Date ? relationship.createdAt.toISOString() : new Date(relationship.createdAt).toISOString() : new Date().toISOString()
+        createdAt: relationship.created_at || relationship.createdAt ? (relationship.created_at || relationship.createdAt) instanceof Date ? (relationship.created_at || relationship.createdAt).toISOString() : new Date(relationship.created_at || relationship.createdAt).toISOString() : new Date().toISOString()
       }));
     });
   }
   async getCache(key) {
     return this.withDatabase(async () => {
       try {
-        const result = await this.db.select({ value: cacheTable.value }).from(cacheTable).where(and(eq(cacheTable.agentId, this.agentId), eq(cacheTable.key, key))).limit(1);
+        const result = await this.db.select({ value: cacheTable.value }).from(cacheTable).where(and(eq2(cacheTable.agentId, this.agentId), eq2(cacheTable.key, key))).limit(1);
         if (result && result.length > 0 && result[0]) {
           return result[0].value;
         }
         return;
       } catch (error) {
-        logger7.error(`Error fetching cache: ${error instanceof Error ? error.message : String(error)}, key: ${key}, agentId: ${this.agentId}`);
+        logger9.error({
+          src: "plugin:sql",
+          agentId: this.agentId,
+          error: error instanceof Error ? error.message : String(error),
+          key
+        }, "Error fetching cache");
         return;
       }
     });
@@ -21615,7 +23047,12 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
         });
         return true;
       } catch (error) {
-        logger7.error(`Error setting cache: ${error instanceof Error ? error.message : String(error)}, key: ${key}, agentId: ${this.agentId}`);
+        logger9.error({
+          src: "plugin:sql",
+          agentId: this.agentId,
+          error: error instanceof Error ? error.message : String(error),
+          key
+        }, "Error setting cache");
         return false;
       }
     });
@@ -21624,11 +23061,16 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
     return this.withDatabase(async () => {
       try {
         await this.db.transaction(async (tx) => {
-          await tx.delete(cacheTable).where(and(eq(cacheTable.agentId, this.agentId), eq(cacheTable.key, key)));
+          await tx.delete(cacheTable).where(and(eq2(cacheTable.agentId, this.agentId), eq2(cacheTable.key, key)));
         });
         return true;
       } catch (error) {
-        logger7.error(`Error deleting cache: ${error instanceof Error ? error.message : String(error)}, key: ${key}, agentId: ${this.agentId}`);
+        logger9.error({
+          src: "plugin:sql",
+          agentId: this.agentId,
+          error: error instanceof Error ? error.message : String(error),
+          key
+        }, "Error deleting cache");
         return false;
       }
     });
@@ -21646,24 +23088,24 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
   }
   async getWorld(id) {
     return this.withDatabase(async () => {
-      const result = await this.db.select().from(worldTable).where(eq(worldTable.id, id));
+      const result = await this.db.select().from(worldTable).where(eq2(worldTable.id, id));
       return result.length > 0 ? result[0] : null;
     });
   }
   async getAllWorlds() {
     return this.withDatabase(async () => {
-      const result = await this.db.select().from(worldTable).where(eq(worldTable.agentId, this.agentId));
+      const result = await this.db.select().from(worldTable).where(eq2(worldTable.agentId, this.agentId));
       return result;
     });
   }
   async updateWorld(world) {
     return this.withDatabase(async () => {
-      await this.db.update(worldTable).set(world).where(eq(worldTable.id, world.id));
+      await this.db.update(worldTable).set(world).where(eq2(worldTable.id, world.id));
     });
   }
   async removeWorld(id) {
     return this.withDatabase(async () => {
-      await this.db.delete(worldTable).where(eq(worldTable.id, id));
+      await this.db.delete(worldTable).where(eq2(worldTable.id, id));
     });
   }
   async createTask(task) {
@@ -21694,8 +23136,8 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
   async getTasks(params) {
     return this.withRetry(async () => {
       return this.withDatabase(async () => {
-        const result = await this.db.select().from(taskTable).where(and(eq(taskTable.agentId, this.agentId), ...params.roomId ? [eq(taskTable.roomId, params.roomId)] : [], ...params.tags && params.tags.length > 0 ? [
-          sql23`${taskTable.tags} @> ARRAY[${sql23.raw(params.tags.map((t) => `'${t.replace(/'/g, "''")}'`).join(", "))}]::text[]`
+        const result = await this.db.select().from(taskTable).where(and(eq2(taskTable.agentId, this.agentId), ...params.roomId ? [eq2(taskTable.roomId, params.roomId)] : [], ...params.tags && params.tags.length > 0 ? [
+          sql25`${taskTable.tags} @> ARRAY[${sql25.raw(params.tags.map((t) => `'${t.replace(/'/g, "''")}'`).join(", "))}]::text[]`
         ] : []));
         return result.map((row) => ({
           id: row.id,
@@ -21712,7 +23154,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
   async getTasksByName(name) {
     return this.withRetry(async () => {
       return this.withDatabase(async () => {
-        const result = await this.db.select().from(taskTable).where(and(eq(taskTable.name, name), eq(taskTable.agentId, this.agentId)));
+        const result = await this.db.select().from(taskTable).where(and(eq2(taskTable.name, name), eq2(taskTable.agentId, this.agentId)));
         return result.map((row) => ({
           id: row.id,
           name: row.name,
@@ -21728,7 +23170,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
   async getTask(id) {
     return this.withRetry(async () => {
       return this.withDatabase(async () => {
-        const result = await this.db.select().from(taskTable).where(and(eq(taskTable.id, id), eq(taskTable.agentId, this.agentId))).limit(1);
+        const result = await this.db.select().from(taskTable).where(and(eq2(taskTable.id, id), eq2(taskTable.agentId, this.agentId))).limit(1);
         if (result.length === 0) {
           return null;
         }
@@ -21763,18 +23205,18 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
         if (task.metadata !== undefined) {
           updateValues.metadata = task.metadata;
         }
-        await this.db.update(taskTable).set(updateValues).where(and(eq(taskTable.id, id), eq(taskTable.agentId, this.agentId)));
+        await this.db.update(taskTable).set(updateValues).where(and(eq2(taskTable.id, id), eq2(taskTable.agentId, this.agentId)));
       });
     });
   }
   async deleteTask(id) {
     return this.withDatabase(async () => {
-      await this.db.delete(taskTable).where(eq(taskTable.id, id));
+      await this.db.delete(taskTable).where(eq2(taskTable.id, id));
     });
   }
   async getMemoriesByWorldId(params) {
     return this.withDatabase(async () => {
-      const rooms = await this.db.select({ id: roomTable.id }).from(roomTable).where(and(eq(roomTable.worldId, params.worldId), eq(roomTable.agentId, this.agentId)));
+      const rooms = await this.db.select({ id: roomTable.id }).from(roomTable).where(and(eq2(roomTable.worldId, params.worldId), eq2(roomTable.agentId, this.agentId)));
       if (rooms.length === 0) {
         return [];
       }
@@ -21789,27 +23231,27 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
   }
   async deleteRoomsByWorldId(worldId) {
     return this.withDatabase(async () => {
-      const rooms = await this.db.select({ id: roomTable.id }).from(roomTable).where(and(eq(roomTable.worldId, worldId), eq(roomTable.agentId, this.agentId)));
+      const rooms = await this.db.select({ id: roomTable.id }).from(roomTable).where(and(eq2(roomTable.worldId, worldId), eq2(roomTable.agentId, this.agentId)));
       if (rooms.length === 0) {
-        logger7.debug(`No rooms found for worldId ${worldId} and agentId ${this.agentId} to delete.`);
         return;
       }
       const roomIds = rooms.map((room) => room.id);
       if (roomIds.length > 0) {
         await this.db.delete(logTable).where(inArray(logTable.roomId, roomIds));
-        logger7.debug(`Deleted logs for ${roomIds.length} rooms in world ${worldId}.`);
         await this.db.delete(participantTable).where(inArray(participantTable.roomId, roomIds));
-        logger7.debug(`Deleted participants for ${roomIds.length} rooms in world ${worldId}.`);
         const memoriesInRooms = await this.db.select({ id: memoryTable.id }).from(memoryTable).where(inArray(memoryTable.roomId, roomIds));
         const memoryIdsInRooms = memoriesInRooms.map((m) => m.id);
         if (memoryIdsInRooms.length > 0) {
           await this.db.delete(embeddingTable).where(inArray(embeddingTable.memoryId, memoryIdsInRooms));
-          logger7.debug(`Deleted embeddings for ${memoryIdsInRooms.length} memories in world ${worldId}.`);
           await this.db.delete(memoryTable).where(inArray(memoryTable.id, memoryIdsInRooms));
-          logger7.debug(`Deleted ${memoryIdsInRooms.length} memories in world ${worldId}.`);
         }
         await this.db.delete(roomTable).where(inArray(roomTable.id, roomIds));
-        logger7.debug(`Deleted ${roomIds.length} rooms for worldId ${worldId}.`);
+        logger9.debug({
+          src: "plugin:sql",
+          worldId,
+          roomsDeleted: roomIds.length,
+          memoriesDeleted: memoryIdsInRooms.length
+        }, "World cleanup completed");
       }
     });
   }
@@ -21828,7 +23270,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
       };
       await this.db.insert(messageServerTable).values(serverToInsert).onConflictDoNothing();
       if (data.id) {
-        const existing = await this.db.select().from(messageServerTable).where(eq(messageServerTable.id, data.id)).limit(1);
+        const existing = await this.db.select().from(messageServerTable).where(eq2(messageServerTable.id, data.id)).limit(1);
         if (existing.length > 0) {
           return {
             id: existing[0].id,
@@ -21861,7 +23303,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
   }
   async getMessageServerById(serverId) {
     return this.withDatabase(async () => {
-      const results = await this.db.select().from(messageServerTable).where(eq(messageServerTable.id, serverId)).limit(1);
+      const results = await this.db.select().from(messageServerTable).where(eq2(messageServerTable.id, serverId)).limit(1);
       return results.length > 0 ? {
         id: results[0].id,
         name: results[0].name,
@@ -21873,6 +23315,26 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
       } : null;
     });
   }
+  async getMessageServerByRlsServerId(rlsServerId) {
+    return this.withDatabase(async () => {
+      const results = await this.db.execute(sql25`
+        SELECT id, name, source_type, source_id, metadata, created_at, updated_at
+        FROM message_servers
+        WHERE server_id = ${rlsServerId}
+        LIMIT 1
+      `);
+      const rows = results.rows || results;
+      return rows.length > 0 ? {
+        id: rows[0].id,
+        name: rows[0].name,
+        sourceType: rows[0].source_type,
+        sourceId: rows[0].source_id || undefined,
+        metadata: rows[0].metadata || undefined,
+        createdAt: new Date(rows[0].created_at),
+        updatedAt: new Date(rows[0].updated_at)
+      } : null;
+    });
+  }
   async createChannel(data, participantIds) {
     return this.withDatabase(async () => {
       const newId = data.id || v4_default();
@@ -21892,9 +23354,9 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
       await this.db.transaction(async (tx) => {
         await tx.insert(channelTable).values(channelToInsert);
         if (participantIds && participantIds.length > 0) {
-          const participantValues = participantIds.map((userId) => ({
+          const participantValues = participantIds.map((entityId) => ({
             channelId: newId,
-            userId
+            entityId
           }));
           await tx.insert(channelParticipantsTable).values(participantValues).onConflictDoNothing();
         }
@@ -21902,9 +23364,9 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
       return channelToInsert;
     });
   }
-  async getChannelsForServer(serverId) {
+  async getChannelsForMessageServer(messageServerId) {
     return this.withDatabase(async () => {
-      const results = await this.db.select().from(channelTable).where(eq(channelTable.messageServerId, serverId));
+      const results = await this.db.select().from(channelTable).where(eq2(channelTable.messageServerId, messageServerId));
       return results.map((r) => ({
         id: r.id,
         messageServerId: r.messageServerId,
@@ -21921,7 +23383,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
   }
   async getChannelDetails(channelId) {
     return this.withDatabase(async () => {
-      const results = await this.db.select().from(channelTable).where(eq(channelTable.id, channelId)).limit(1);
+      const results = await this.db.select().from(channelTable).where(eq2(channelTable.id, channelId)).limit(1);
       return results.length > 0 ? {
         id: results[0].id,
         messageServerId: results[0].messageServerId,
@@ -21959,7 +23421,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
   }
   async getMessageById(id) {
     return this.withDatabase(async () => {
-      const rows = await this.db.select().from(messageTable).where(eq(messageTable.id, id)).limit(1);
+      const rows = await this.db.select().from(messageTable).where(eq2(messageTable.id, id)).limit(1);
       return rows?.[0] ?? null;
     });
   }
@@ -21978,7 +23440,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
         inReplyToRootMessageId: patch.inReplyToRootMessageId ?? existing.inReplyToRootMessageId,
         updatedAt
       };
-      await this.db.update(messageTable).set(next).where(eq(messageTable.id, id));
+      await this.db.update(messageTable).set(next).where(eq2(messageTable.id, id));
       return {
         ...existing,
         ...next
@@ -21987,7 +23449,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
   }
   async getMessagesForChannel(channelId, limit = 50, beforeTimestamp) {
     return this.withDatabase(async () => {
-      const conditions = [eq(messageTable.channelId, channelId)];
+      const conditions = [eq2(messageTable.channelId, channelId)];
       if (beforeTimestamp) {
         conditions.push(lt(messageTable.createdAt, beforeTimestamp));
       }
@@ -22010,7 +23472,7 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
   }
   async deleteMessage(messageId) {
     return this.withDatabase(async () => {
-      await this.db.delete(messageTable).where(eq(messageTable.id, messageId));
+      await this.db.delete(messageTable).where(eq2(messageTable.id, messageId));
     });
   }
   async updateChannel(channelId, updates) {
@@ -22022,13 +23484,13 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
           updateData.name = updates.name;
         if (updates.metadata !== undefined)
           updateData.metadata = updates.metadata;
-        await tx.update(channelTable).set(updateData).where(eq(channelTable.id, channelId));
+        await tx.update(channelTable).set(updateData).where(eq2(channelTable.id, channelId));
         if (updates.participantCentralUserIds !== undefined) {
-          await tx.delete(channelParticipantsTable).where(eq(channelParticipantsTable.channelId, channelId));
+          await tx.delete(channelParticipantsTable).where(eq2(channelParticipantsTable.channelId, channelId));
           if (updates.participantCentralUserIds.length > 0) {
-            const participantValues = updates.participantCentralUserIds.map((userId) => ({
+            const participantValues = updates.participantCentralUserIds.map((entityId) => ({
               channelId,
-              userId
+              entityId
             }));
             await tx.insert(channelParticipantsTable).values(participantValues).onConflictDoNothing();
           }
@@ -22044,53 +23506,59 @@ class BaseDrizzleAdapter extends DatabaseAdapter {
   async deleteChannel(channelId) {
     return this.withDatabase(async () => {
       await this.db.transaction(async (tx) => {
-        await tx.delete(messageTable).where(eq(messageTable.channelId, channelId));
-        await tx.delete(channelParticipantsTable).where(eq(channelParticipantsTable.channelId, channelId));
-        await tx.delete(channelTable).where(eq(channelTable.id, channelId));
+        await tx.delete(messageTable).where(eq2(messageTable.channelId, channelId));
+        await tx.delete(channelParticipantsTable).where(eq2(channelParticipantsTable.channelId, channelId));
+        await tx.delete(channelTable).where(eq2(channelTable.id, channelId));
       });
     });
   }
-  async addChannelParticipants(channelId, userIds) {
+  async addChannelParticipants(channelId, entityIds) {
     return this.withDatabase(async () => {
-      if (!userIds || userIds.length === 0)
+      if (!entityIds || entityIds.length === 0)
         return;
-      const participantValues = userIds.map((userId) => ({
+      const participantValues = entityIds.map((entityId) => ({
         channelId,
-        userId
+        entityId
       }));
       await this.db.insert(channelParticipantsTable).values(participantValues).onConflictDoNothing();
     });
   }
   async getChannelParticipants(channelId) {
     return this.withDatabase(async () => {
-      const results = await this.db.select({ userId: channelParticipantsTable.userId }).from(channelParticipantsTable).where(eq(channelParticipantsTable.channelId, channelId));
-      return results.map((r) => r.userId);
+      const results = await this.db.select({ entityId: channelParticipantsTable.entityId }).from(channelParticipantsTable).where(eq2(channelParticipantsTable.channelId, channelId));
+      return results.map((r) => r.entityId);
+    });
+  }
+  async isChannelParticipant(channelId, entityId) {
+    return this.withDatabase(async () => {
+      const result = await this.db.select().from(channelParticipantsTable).where(and(eq2(channelParticipantsTable.channelId, channelId), eq2(channelParticipantsTable.entityId, entityId))).limit(1);
+      return result.length > 0;
     });
   }
-  async addAgentToServer(serverId, agentId) {
+  async addAgentToMessageServer(messageServerId, agentId) {
     return this.withDatabase(async () => {
-      await this.db.insert(serverAgentsTable).values({
-        serverId,
+      await this.db.insert(messageServerAgentsTable).values({
+        messageServerId,
         agentId
       }).onConflictDoNothing();
     });
   }
-  async getAgentsForServer(serverId) {
+  async getAgentsForMessageServer(messageServerId) {
     return this.withDatabase(async () => {
-      const results = await this.db.select({ agentId: serverAgentsTable.agentId }).from(serverAgentsTable).where(eq(serverAgentsTable.serverId, serverId));
+      const results = await this.db.select({ agentId: messageServerAgentsTable.agentId }).from(messageServerAgentsTable).where(eq2(messageServerAgentsTable.messageServerId, messageServerId));
       return results.map((r) => r.agentId);
     });
   }
-  async removeAgentFromServer(serverId, agentId) {
+  async removeAgentFromMessageServer(messageServerId, agentId) {
     return this.withDatabase(async () => {
-      await this.db.delete(serverAgentsTable).where(and(eq(serverAgentsTable.serverId, serverId), eq(serverAgentsTable.agentId, agentId)));
+      await this.db.delete(messageServerAgentsTable).where(and(eq2(messageServerAgentsTable.messageServerId, messageServerId), eq2(messageServerAgentsTable.agentId, agentId)));
     });
   }
   async findOrCreateDmChannel(user1Id, user2Id, messageServerId) {
     return this.withDatabase(async () => {
       const ids = [user1Id, user2Id].sort();
       const dmChannelName = `DM-${ids[0]}-${ids[1]}`;
-      const existingChannels = await this.db.select().from(channelTable).where(and(eq(channelTable.type, ChannelType.DM), eq(channelTable.name, dmChannelName), eq(channelTable.messageServerId, messageServerId))).limit(1);
+      const existingChannels = await this.db.select().from(channelTable).where(and(eq2(channelTable.type, ChannelType.DM), eq2(channelTable.name, dmChannelName), eq2(channelTable.messageServerId, messageServerId))).limit(1);
       if (existingChannels.length > 0) {
         return {
           id: existingChannels[0].id,
@@ -22124,11 +23592,14 @@ class PgliteDatabaseAdapter extends BaseDrizzleAdapter {
     this.manager = manager;
     this.db = drizzle(this.manager.getConnection());
   }
+  async withEntityContext(_entityId, callback) {
+    return this.db.transaction(callback);
+  }
   async getEntityByIds(entityIds) {
     return this.getEntitiesByIds(entityIds);
   }
   async getMemoriesByServerId(_params) {
-    logger8.warn("getMemoriesByServerId called but not implemented - returning empty array");
+    logger10.warn({ src: "plugin:sql" }, "getMemoriesByServerId called but not implemented");
     return [];
   }
   async ensureAgentExists(agent) {
@@ -22153,13 +23624,13 @@ class PgliteDatabaseAdapter extends BaseDrizzleAdapter {
   }
   async withDatabase(operation) {
     if (this.manager.isShuttingDown()) {
-      logger8.warn("Database is shutting down");
+      logger10.warn({ src: "plugin:sql" }, "Database is shutting down");
       return null;
     }
     return operation();
   }
   async init() {
-    logger8.debug("PGliteDatabaseAdapter initialized, skipping automatic migrations.");
+    logger10.debug({ src: "plugin:sql" }, "PGliteDatabaseAdapter initialized");
   }
   async isReady() {
     return !this.manager.isShuttingDown();
@@ -22223,17 +23694,17 @@ var plugin = {
   priority: 0,
   schema: exports_schema,
   init: async (_config, runtime) => {
-    logger9.info("plugin-sql (browser) init starting...");
+    logger11.info({ src: "plugin:sql" }, "plugin-sql (browser) init starting");
     try {
       const isReady = await runtime.isReady();
       if (isReady) {
-        logger9.info("Database adapter already registered, skipping creation");
+        logger11.info({ src: "plugin:sql" }, "Database adapter already registered, skipping creation");
         return;
       }
     } catch (error) {}
     const dbAdapter = createDatabaseAdapter({}, runtime.agentId);
     runtime.registerDatabaseAdapter(dbAdapter);
-    logger9.info("Browser database adapter (PGlite) created and registered");
+    logger11.info({ src: "plugin:sql" }, "Browser database adapter (PGlite) created and registered");
   }
 };
 var index_browser_default = plugin;
@@ -22244,5 +23715,5 @@ export {
   DatabaseMigrationService
 };
 
-//# debugId=5D30F97F3F7F064964756E2164756E21
+//# debugId=A4CD118ECB5E333164756E2164756E21
 //# sourceMappingURL=index.browser.js.map