@elizaos/core 1.6.5-alpha.14 → 1.6.5-alpha.16

package/dist/node/index.node.js

@@ -9894,6 +9894,530 @@ var require_picocolors = __commonJS((exports, module) => {
   module.exports.createColors = createColors;
 });
 
+// ../../node_modules/fast-redact/lib/validator.js
+var require_validator = __commonJS((exports, module) => {
+  module.exports = validator2;
+  function validator2(opts = {}) {
+    const {
+      ERR_PATHS_MUST_BE_STRINGS = () => "fast-redact - Paths must be (non-empty) strings",
+      ERR_INVALID_PATH = (s) => `fast-redact – Invalid path (${s})`
+    } = opts;
+    return function validate({ paths }) {
+      paths.forEach((s) => {
+        if (typeof s !== "string") {
+          throw Error(ERR_PATHS_MUST_BE_STRINGS());
+        }
+        try {
+          if (/〇/.test(s))
+            throw Error();
+          const expr = (s[0] === "[" ? "" : ".") + s.replace(/^\*/, "〇").replace(/\.\*/g, ".〇").replace(/\[\*\]/g, "[〇]");
+          if (/\n|\r|;/.test(expr))
+            throw Error();
+          if (/\/\*/.test(expr))
+            throw Error();
+          Function(`
+            'use strict'
+            const o = new Proxy({}, { get: () => o, set: () => { throw Error() } });
+            const 〇 = null;
+            o${expr}
+            if ([o${expr}].length !== 1) throw Error()`)();
+        } catch (e) {
+          throw Error(ERR_INVALID_PATH(s));
+        }
+      });
+    };
+  }
+});
+
+// ../../node_modules/fast-redact/lib/rx.js
+var require_rx = __commonJS((exports, module) => {
+  module.exports = /[^.[\]]+|\[((?:.)*?)\]/g;
+});
+
+// ../../node_modules/fast-redact/lib/parse.js
+var require_parse4 = __commonJS((exports, module) => {
+  var rx = require_rx();
+  module.exports = parse4;
+  function parse4({ paths }) {
+    const wildcards = [];
+    var wcLen = 0;
+    const secret = paths.reduce(function(o, strPath, ix) {
+      var path = strPath.match(rx).map((p) => p.replace(/'|"|`/g, ""));
+      const leadingBracket = strPath[0] === "[";
+      path = path.map((p) => {
+        if (p[0] === "[")
+          return p.substr(1, p.length - 2);
+        else
+          return p;
+      });
+      const star = path.indexOf("*");
+      if (star > -1) {
+        const before = path.slice(0, star);
+        const beforeStr = before.join(".");
+        const after = path.slice(star + 1, path.length);
+        const nested = after.length > 0;
+        wcLen++;
+        wildcards.push({
+          before,
+          beforeStr,
+          after,
+          nested
+        });
+      } else {
+        o[strPath] = {
+          path,
+          val: undefined,
+          precensored: false,
+          circle: "",
+          escPath: JSON.stringify(strPath),
+          leadingBracket
+        };
+      }
+      return o;
+    }, {});
+    return { wildcards, wcLen, secret };
+  }
+});
+
+// ../../node_modules/fast-redact/lib/redactor.js
+var require_redactor = __commonJS((exports, module) => {
+  var rx = require_rx();
+  module.exports = redactor;
+  function redactor({ secret, serialize: serialize3, wcLen, strict, isCensorFct, censorFctTakesPath }, state) {
+    const redact = Function("o", `
+    if (typeof o !== 'object' || o == null) {
+      ${strictImpl(strict, serialize3)}
+    }
+    const { censor, secret } = this
+    const originalSecret = {}
+    const secretKeys = Object.keys(secret)
+    for (var i = 0; i < secretKeys.length; i++) {
+      originalSecret[secretKeys[i]] = secret[secretKeys[i]]
+    }
+
+    ${redactTmpl(secret, isCensorFct, censorFctTakesPath)}
+    this.compileRestore()
+    ${dynamicRedactTmpl(wcLen > 0, isCensorFct, censorFctTakesPath)}
+    this.secret = originalSecret
+    ${resultTmpl(serialize3)}
+  `).bind(state);
+    redact.state = state;
+    if (serialize3 === false) {
+      redact.restore = (o) => state.restore(o);
+    }
+    return redact;
+  }
+  function redactTmpl(secret, isCensorFct, censorFctTakesPath) {
+    return Object.keys(secret).map((path) => {
+      const { escPath, leadingBracket, path: arrPath } = secret[path];
+      const skip = leadingBracket ? 1 : 0;
+      const delim = leadingBracket ? "" : ".";
+      const hops = [];
+      var match;
+      while ((match = rx.exec(path)) !== null) {
+        const [, ix] = match;
+        const { index, input } = match;
+        if (index > skip)
+          hops.push(input.substring(0, index - (ix ? 0 : 1)));
+      }
+      var existence = hops.map((p) => `o${delim}${p}`).join(" && ");
+      if (existence.length === 0)
+        existence += `o${delim}${path} != null`;
+      else
+        existence += ` && o${delim}${path} != null`;
+      const circularDetection = `
+      switch (true) {
+        ${hops.reverse().map((p) => `
+          case o${delim}${p} === censor:
+            secret[${escPath}].circle = ${JSON.stringify(p)}
+            break
+        `).join(`
+`)}
+      }
+    `;
+      const censorArgs = censorFctTakesPath ? `val, ${JSON.stringify(arrPath)}` : `val`;
+      return `
+      if (${existence}) {
+        const val = o${delim}${path}
+        if (val === censor) {
+          secret[${escPath}].precensored = true
+        } else {
+          secret[${escPath}].val = val
+          o${delim}${path} = ${isCensorFct ? `censor(${censorArgs})` : "censor"}
+          ${circularDetection}
+        }
+      }
+    `;
+    }).join(`
+`);
+  }
+  function dynamicRedactTmpl(hasWildcards, isCensorFct, censorFctTakesPath) {
+    return hasWildcards === true ? `
+    {
+      const { wildcards, wcLen, groupRedact, nestedRedact } = this
+      for (var i = 0; i < wcLen; i++) {
+        const { before, beforeStr, after, nested } = wildcards[i]
+        if (nested === true) {
+          secret[beforeStr] = secret[beforeStr] || []
+          nestedRedact(secret[beforeStr], o, before, after, censor, ${isCensorFct}, ${censorFctTakesPath})
+        } else secret[beforeStr] = groupRedact(o, before, censor, ${isCensorFct}, ${censorFctTakesPath})
+      }
+    }
+  ` : "";
+  }
+  function resultTmpl(serialize3) {
+    return serialize3 === false ? `return o` : `
+    var s = this.serialize(o)
+    this.restore(o)
+    return s
+  `;
+  }
+  function strictImpl(strict, serialize3) {
+    return strict === true ? `throw Error('fast-redact: primitives cannot be redacted')` : serialize3 === false ? `return o` : `return this.serialize(o)`;
+  }
+});
+
+// ../../node_modules/fast-redact/lib/modifiers.js
+var require_modifiers = __commonJS((exports, module) => {
+  module.exports = {
+    groupRedact,
+    groupRestore,
+    nestedRedact,
+    nestedRestore
+  };
+  function groupRestore({ keys: keys2, values, target }) {
+    if (target == null || typeof target === "string")
+      return;
+    const length = keys2.length;
+    for (var i = 0;i < length; i++) {
+      const k = keys2[i];
+      target[k] = values[i];
+    }
+  }
+  function groupRedact(o, path, censor, isCensorFct, censorFctTakesPath) {
+    const target = get(o, path);
+    if (target == null || typeof target === "string")
+      return { keys: null, values: null, target, flat: true };
+    const keys2 = Object.keys(target);
+    const keysLength = keys2.length;
+    const pathLength = path.length;
+    const pathWithKey = censorFctTakesPath ? [...path] : undefined;
+    const values = new Array(keysLength);
+    for (var i = 0;i < keysLength; i++) {
+      const key = keys2[i];
+      values[i] = target[key];
+      if (censorFctTakesPath) {
+        pathWithKey[pathLength] = key;
+        target[key] = censor(target[key], pathWithKey);
+      } else if (isCensorFct) {
+        target[key] = censor(target[key]);
+      } else {
+        target[key] = censor;
+      }
+    }
+    return { keys: keys2, values, target, flat: true };
+  }
+  function nestedRestore(instructions) {
+    for (let i = 0;i < instructions.length; i++) {
+      const { target, path, value } = instructions[i];
+      let current = target;
+      for (let i2 = path.length - 1;i2 > 0; i2--) {
+        current = current[path[i2]];
+      }
+      current[path[0]] = value;
+    }
+  }
+  function nestedRedact(store, o, path, ns, censor, isCensorFct, censorFctTakesPath) {
+    const target = get(o, path);
+    if (target == null)
+      return;
+    const keys2 = Object.keys(target);
+    const keysLength = keys2.length;
+    for (var i = 0;i < keysLength; i++) {
+      const key = keys2[i];
+      specialSet(store, target, key, path, ns, censor, isCensorFct, censorFctTakesPath);
+    }
+    return store;
+  }
+  function has(obj, prop) {
+    return obj !== undefined && obj !== null ? "hasOwn" in Object ? Object.hasOwn(obj, prop) : Object.prototype.hasOwnProperty.call(obj, prop) : false;
+  }
+  function specialSet(store, o, k, path, afterPath, censor, isCensorFct, censorFctTakesPath) {
+    const afterPathLen = afterPath.length;
+    const lastPathIndex = afterPathLen - 1;
+    const originalKey = k;
+    var i = -1;
+    var n;
+    var nv;
+    var ov;
+    var oov = null;
+    var wc = null;
+    var kIsWc;
+    var wcov;
+    var consecutive = false;
+    var level = 0;
+    var depth = 0;
+    var redactPathCurrent = tree();
+    ov = n = o[k];
+    if (typeof n !== "object")
+      return;
+    while (n != null && ++i < afterPathLen) {
+      depth += 1;
+      k = afterPath[i];
+      oov = ov;
+      if (k !== "*" && !wc && !(typeof n === "object" && (k in n))) {
+        break;
+      }
+      if (k === "*") {
+        if (wc === "*") {
+          consecutive = true;
+        }
+        wc = k;
+        if (i !== lastPathIndex) {
+          continue;
+        }
+      }
+      if (wc) {
+        const wcKeys = Object.keys(n);
+        for (var j = 0;j < wcKeys.length; j++) {
+          const wck = wcKeys[j];
+          wcov = n[wck];
+          kIsWc = k === "*";
+          if (consecutive) {
+            redactPathCurrent = node(redactPathCurrent, wck, depth);
+            level = i;
+            ov = iterateNthLevel(wcov, level - 1, k, path, afterPath, censor, isCensorFct, censorFctTakesPath, originalKey, n, nv, ov, kIsWc, wck, i, lastPathIndex, redactPathCurrent, store, o[originalKey], depth + 1);
+          } else {
+            if (kIsWc || typeof wcov === "object" && wcov !== null && k in wcov) {
+              if (kIsWc) {
+                ov = wcov;
+              } else {
+                ov = wcov[k];
+              }
+              nv = i !== lastPathIndex ? ov : isCensorFct ? censorFctTakesPath ? censor(ov, [...path, originalKey, ...afterPath]) : censor(ov) : censor;
+              if (kIsWc) {
+                const rv = restoreInstr(node(redactPathCurrent, wck, depth), ov, o[originalKey]);
+                store.push(rv);
+                n[wck] = nv;
+              } else {
+                if (wcov[k] === nv) {} else if (nv === undefined && censor !== undefined || has(wcov, k) && nv === ov) {
+                  redactPathCurrent = node(redactPathCurrent, wck, depth);
+                } else {
+                  redactPathCurrent = node(redactPathCurrent, wck, depth);
+                  const rv = restoreInstr(node(redactPathCurrent, k, depth + 1), ov, o[originalKey]);
+                  store.push(rv);
+                  wcov[k] = nv;
+                }
+              }
+            }
+          }
+        }
+        wc = null;
+      } else {
+        ov = n[k];
+        redactPathCurrent = node(redactPathCurrent, k, depth);
+        nv = i !== lastPathIndex ? ov : isCensorFct ? censorFctTakesPath ? censor(ov, [...path, originalKey, ...afterPath]) : censor(ov) : censor;
+        if (has(n, k) && nv === ov || nv === undefined && censor !== undefined) {} else {
+          const rv = restoreInstr(redactPathCurrent, ov, o[originalKey]);
+          store.push(rv);
+          n[k] = nv;
+        }
+        n = n[k];
+      }
+      if (typeof n !== "object")
+        break;
+      if (ov === oov || typeof ov === "undefined") {}
+    }
+  }
+  function get(o, p) {
+    var i = -1;
+    var l = p.length;
+    var n = o;
+    while (n != null && ++i < l) {
+      n = n[p[i]];
+    }
+    return n;
+  }
+  function iterateNthLevel(wcov, level, k, path, afterPath, censor, isCensorFct, censorFctTakesPath, originalKey, n, nv, ov, kIsWc, wck, i, lastPathIndex, redactPathCurrent, store, parent, depth) {
+    if (level === 0) {
+      if (kIsWc || typeof wcov === "object" && wcov !== null && k in wcov) {
+        if (kIsWc) {
+          ov = wcov;
+        } else {
+          ov = wcov[k];
+        }
+        nv = i !== lastPathIndex ? ov : isCensorFct ? censorFctTakesPath ? censor(ov, [...path, originalKey, ...afterPath]) : censor(ov) : censor;
+        if (kIsWc) {
+          const rv = restoreInstr(redactPathCurrent, ov, parent);
+          store.push(rv);
+          n[wck] = nv;
+        } else {
+          if (wcov[k] === nv) {} else if (nv === undefined && censor !== undefined || has(wcov, k) && nv === ov) {} else {
+            const rv = restoreInstr(node(redactPathCurrent, k, depth + 1), ov, parent);
+            store.push(rv);
+            wcov[k] = nv;
+          }
+        }
+      }
+    }
+    for (const key in wcov) {
+      if (typeof wcov[key] === "object") {
+        redactPathCurrent = node(redactPathCurrent, key, depth);
+        iterateNthLevel(wcov[key], level - 1, k, path, afterPath, censor, isCensorFct, censorFctTakesPath, originalKey, n, nv, ov, kIsWc, wck, i, lastPathIndex, redactPathCurrent, store, parent, depth + 1);
+      }
+    }
+  }
+  function tree() {
+    return { parent: null, key: null, children: [], depth: 0 };
+  }
+  function node(parent, key, depth) {
+    if (parent.depth === depth) {
+      return node(parent.parent, key, depth);
+    }
+    var child = {
+      parent,
+      key,
+      depth,
+      children: []
+    };
+    parent.children.push(child);
+    return child;
+  }
+  function restoreInstr(node2, value, target) {
+    let current = node2;
+    const path = [];
+    do {
+      path.push(current.key);
+      current = current.parent;
+    } while (current.parent != null);
+    return { path, value, target };
+  }
+});
+
+// ../../node_modules/fast-redact/lib/restorer.js
+var require_restorer = __commonJS((exports, module) => {
+  var { groupRestore, nestedRestore } = require_modifiers();
+  module.exports = restorer;
+  function restorer() {
+    return function compileRestore() {
+      if (this.restore) {
+        this.restore.state.secret = this.secret;
+        return;
+      }
+      const { secret, wcLen } = this;
+      const paths = Object.keys(secret);
+      const resetters = resetTmpl(secret, paths);
+      const hasWildcards = wcLen > 0;
+      const state = hasWildcards ? { secret, groupRestore, nestedRestore } : { secret };
+      this.restore = Function("o", restoreTmpl(resetters, paths, hasWildcards)).bind(state);
+      this.restore.state = state;
+    };
+  }
+  function resetTmpl(secret, paths) {
+    return paths.map((path) => {
+      const { circle, escPath, leadingBracket } = secret[path];
+      const delim = leadingBracket ? "" : ".";
+      const reset = circle ? `o.${circle} = secret[${escPath}].val` : `o${delim}${path} = secret[${escPath}].val`;
+      const clear = `secret[${escPath}].val = undefined`;
+      return `
+      if (secret[${escPath}].val !== undefined) {
+        try { ${reset} } catch (e) {}
+        ${clear}
+      }
+    `;
+    }).join("");
+  }
+  function restoreTmpl(resetters, paths, hasWildcards) {
+    const dynamicReset = hasWildcards === true ? `
+    const keys = Object.keys(secret)
+    const len = keys.length
+    for (var i = len - 1; i >= ${paths.length}; i--) {
+      const k = keys[i]
+      const o = secret[k]
+      if (o) {
+        if (o.flat === true) this.groupRestore(o)
+        else this.nestedRestore(o)
+        secret[k] = null
+      }
+    }
+  ` : "";
+    return `
+    const secret = this.secret
+    ${dynamicReset}
+    ${resetters}
+    return o
+  `;
+  }
+});
+
+// ../../node_modules/fast-redact/lib/state.js
+var require_state = __commonJS((exports, module) => {
+  module.exports = state;
+  function state(o) {
+    const {
+      secret,
+      censor,
+      compileRestore,
+      serialize: serialize3,
+      groupRedact,
+      nestedRedact,
+      wildcards,
+      wcLen
+    } = o;
+    const builder = [{ secret, censor, compileRestore }];
+    if (serialize3 !== false)
+      builder.push({ serialize: serialize3 });
+    if (wcLen > 0)
+      builder.push({ groupRedact, nestedRedact, wildcards, wcLen });
+    return Object.assign(...builder);
+  }
+});
+
+// ../../node_modules/fast-redact/index.js
+var require_fast_redact = __commonJS((exports, module) => {
+  var validator2 = require_validator();
+  var parse4 = require_parse4();
+  var redactor = require_redactor();
+  var restorer = require_restorer();
+  var { groupRedact, nestedRedact } = require_modifiers();
+  var state = require_state();
+  var rx = require_rx();
+  var validate5 = validator2();
+  var noop = (o) => o;
+  noop.restore = noop;
+  var DEFAULT_CENSOR = "[REDACTED]";
+  fastRedact.rx = rx;
+  fastRedact.validator = validator2;
+  module.exports = fastRedact;
+  function fastRedact(opts = {}) {
+    const paths = Array.from(new Set(opts.paths || []));
+    const serialize3 = "serialize" in opts ? opts.serialize === false ? opts.serialize : typeof opts.serialize === "function" ? opts.serialize : JSON.stringify : JSON.stringify;
+    const remove = opts.remove;
+    if (remove === true && serialize3 !== JSON.stringify) {
+      throw Error("fast-redact – remove option may only be set when serializer is JSON.stringify");
+    }
+    const censor = remove === true ? undefined : ("censor" in opts) ? opts.censor : DEFAULT_CENSOR;
+    const isCensorFct = typeof censor === "function";
+    const censorFctTakesPath = isCensorFct && censor.length > 1;
+    if (paths.length === 0)
+      return serialize3 || noop;
+    validate5({ paths, serialize: serialize3, censor });
+    const { wildcards, wcLen, secret } = parse4({ paths, censor });
+    const compileRestore = restorer();
+    const strict = "strict" in opts ? opts.strict : true;
+    return redactor({ secret, wcLen, serialize: serialize3, strict, isCensorFct, censorFctTakesPath }, state({
+      secret,
+      censor,
+      compileRestore,
+      serialize: serialize3,
+      groupRedact,
+      nestedRedact,
+      wildcards,
+      wcLen
+    }));
+  }
+});
+
 // ../../node_modules/randombytes/index.js
 var require_randombytes = __commonJS((exports, module) => {
   module.exports = __require("crypto").randomBytes;
@@ -11605,31 +12129,31 @@ var require_pbkdf2 = __commonJS((exports) => {
 
 // ../../node_modules/browserify-cipher/index.js
 var require_browserify_cipher = __commonJS((exports) => {
-  var crypto = __require("crypto");
-  exports.createCipher = exports.Cipher = crypto.createCipher;
-  exports.createCipheriv = exports.Cipheriv = crypto.createCipheriv;
-  exports.createDecipher = exports.Decipher = crypto.createDecipher;
-  exports.createDecipheriv = exports.Decipheriv = crypto.createDecipheriv;
-  exports.listCiphers = exports.getCiphers = crypto.getCiphers;
+  var crypto2 = __require("crypto");
+  exports.createCipher = exports.Cipher = crypto2.createCipher;
+  exports.createCipheriv = exports.Cipheriv = crypto2.createCipheriv;
+  exports.createDecipher = exports.Decipher = crypto2.createDecipher;
+  exports.createDecipheriv = exports.Decipheriv = crypto2.createDecipheriv;
+  exports.listCiphers = exports.getCiphers = crypto2.getCiphers;
 });
 
 // ../../node_modules/diffie-hellman/index.js
 var require_diffie_hellman = __commonJS((exports) => {
-  var crypto = __require("crypto");
-  exports.DiffieHellmanGroup = crypto.DiffieHellmanGroup;
-  exports.createDiffieHellmanGroup = crypto.createDiffieHellmanGroup;
-  exports.getDiffieHellman = crypto.getDiffieHellman;
-  exports.createDiffieHellman = crypto.createDiffieHellman;
-  exports.DiffieHellman = crypto.DiffieHellman;
+  var crypto2 = __require("crypto");
+  exports.DiffieHellmanGroup = crypto2.DiffieHellmanGroup;
+  exports.createDiffieHellmanGroup = crypto2.createDiffieHellmanGroup;
+  exports.getDiffieHellman = crypto2.getDiffieHellman;
+  exports.createDiffieHellman = crypto2.createDiffieHellman;
+  exports.DiffieHellman = crypto2.DiffieHellman;
 });
 
 // ../../node_modules/browserify-sign/index.js
 var require_browserify_sign = __commonJS((exports) => {
-  var crypto = __require("crypto");
-  exports.createSign = crypto.createSign;
-  exports.Sign = crypto.Sign;
-  exports.createVerify = crypto.createVerify;
-  exports.Verify = crypto.Verify;
+  var crypto2 = __require("crypto");
+  exports.createSign = crypto2.createSign;
+  exports.Sign = crypto2.Sign;
+  exports.createVerify = crypto2.createVerify;
+  exports.Verify = crypto2.Verify;
 });
 
 // ../../node_modules/elliptic/package.json
@@ -14736,15 +15260,15 @@ var require_brorand = __commonJS((exports, module) => {
     }
   } else {
     try {
-      crypto = __require("crypto");
-      if (typeof crypto.randomBytes !== "function")
+      crypto2 = __require("crypto");
+      if (typeof crypto2.randomBytes !== "function")
         throw new Error("Not supported");
       Rand.prototype._rand = function _rand(n) {
-        return crypto.randomBytes(n);
+        return crypto2.randomBytes(n);
       };
     } catch (e) {}
   }
-  var crypto;
+  var crypto2;
 });
 
 // ../../node_modules/elliptic/lib/elliptic/curve/base.js
@@ -21360,12 +21884,12 @@ var require_evp_bytestokey = __commonJS((exports, module) => {
 
 // ../../node_modules/browserify-aes/index.js
 var require_browserify_aes = __commonJS((exports) => {
-  var crypto = __require("crypto");
-  exports.createCipher = exports.Cipher = crypto.createCipher;
-  exports.createCipheriv = exports.Cipheriv = crypto.createCipheriv;
-  exports.createDecipher = exports.Decipher = crypto.createDecipher;
-  exports.createDecipheriv = exports.Decipheriv = crypto.createDecipheriv;
-  exports.listCiphers = exports.getCiphers = crypto.getCiphers;
+  var crypto2 = __require("crypto");
+  exports.createCipher = exports.Cipher = crypto2.createCipher;
+  exports.createCipheriv = exports.Cipheriv = crypto2.createCipheriv;
+  exports.createDecipher = exports.Decipher = crypto2.createDecipher;
+  exports.createDecipheriv = exports.Decipheriv = crypto2.createDecipheriv;
+  exports.listCiphers = exports.getCiphers = crypto2.getCiphers;
 });
 
 // ../../node_modules/parse-asn1/fixProc.js
@@ -24708,21 +25232,21 @@ var require_browser2 = __commonJS((exports) => {
 
 // ../../node_modules/public-encrypt/index.js
 var require_public_encrypt = __commonJS((exports) => {
-  var crypto = __require("crypto");
-  if (typeof crypto.publicEncrypt !== "function") {
-    crypto = require_browser2();
+  var crypto2 = __require("crypto");
+  if (typeof crypto2.publicEncrypt !== "function") {
+    crypto2 = require_browser2();
   }
-  exports.publicEncrypt = crypto.publicEncrypt;
-  exports.privateDecrypt = crypto.privateDecrypt;
-  if (typeof crypto.privateEncrypt !== "function") {
+  exports.publicEncrypt = crypto2.publicEncrypt;
+  exports.privateDecrypt = crypto2.privateDecrypt;
+  if (typeof crypto2.privateEncrypt !== "function") {
     exports.privateEncrypt = require_browser2().privateEncrypt;
   } else {
-    exports.privateEncrypt = crypto.privateEncrypt;
+    exports.privateEncrypt = crypto2.privateEncrypt;
   }
-  if (typeof crypto.publicDecrypt !== "function") {
+  if (typeof crypto2.publicDecrypt !== "function") {
     exports.publicDecrypt = require_browser2().publicDecrypt;
   } else {
-    exports.publicDecrypt = crypto.publicDecrypt;
+    exports.publicDecrypt = crypto2.publicDecrypt;
   }
 });
 
@@ -24732,7 +25256,7 @@ var require_browser3 = __commonJS((exports) => {
   var randombytes = require_randombytes();
   var Buffer2 = safeBuffer.Buffer;
   var kBufferMaxLength = safeBuffer.kMaxLength;
-  var crypto = global.crypto || global.msCrypto;
+  var crypto2 = global.crypto || global.msCrypto;
   var kMaxUint32 = Math.pow(2, 32) - 1;
   function assertOffset(offset, length) {
     if (typeof offset !== "number" || offset !== offset) {
@@ -24756,7 +25280,7 @@ var require_browser3 = __commonJS((exports) => {
       throw new RangeError("buffer too small");
     }
   }
-  if (crypto && crypto.getRandomValues || true) {
+  if (crypto2 && crypto2.getRandomValues || true) {
     exports.randomFill = randomFill;
     exports.randomFillSync = randomFillSync2;
   } else {}
@@ -24814,10 +25338,10 @@ var require_browser3 = __commonJS((exports) => {
 
 // ../../node_modules/randomfill/index.js
 var require_randomfill = __commonJS((exports, module) => {
-  var crypto = __require("crypto");
-  if (typeof crypto.randomFill === "function" && typeof crypto.randomFillSync === "function") {
-    exports.randomFill = crypto.randomFill;
-    exports.randomFillSync = crypto.randomFillSync;
+  var crypto2 = __require("crypto");
+  if (typeof crypto2.randomFill === "function" && typeof crypto2.randomFillSync === "function") {
+    exports.randomFill = crypto2.randomFill;
+    exports.randomFillSync = crypto2.randomFillSync;
   } else {
     module.exports = require_browser3();
   }
@@ -42500,6 +43024,7 @@ var console_styles = Object.freeze(styles_raw);
 var dist_default = Log;
 
 // src/logger.ts
+var import_fast_redact = __toESM(require_fast_redact(), 1);
 var __loggerTestHooks = {
   __noop: () => {}
 };
@@ -42553,6 +43078,37 @@ function parseBooleanFromText(value) {
   const normalized = value.toLowerCase().trim();
   return normalized === "true" || normalized === "1" || normalized === "yes" || normalized === "on";
 }
+function formatExtraValue(value) {
+  if (value === null)
+    return "null";
+  if (value === undefined)
+    return "undefined";
+  if (typeof value === "string")
+    return value;
+  if (typeof value === "number" || typeof value === "boolean")
+    return String(value);
+  if (value instanceof Error)
+    return value.message;
+  return safeStringify(value);
+}
+function formatPrettyLog(context, message, isJsonMode) {
+  if (isJsonMode) {
+    return message;
+  }
+  const src = context.src;
+  const srcPart = src ? `[${src.toUpperCase()}] ` : "";
+  const excludeKeys = ["src", "agentId", "agentName"];
+  const extraPairs = [];
+  for (const [key, value] of Object.entries(context)) {
+    if (excludeKeys.includes(key))
+      continue;
+    if (value === undefined)
+      continue;
+    extraPairs.push(`${key}=${formatExtraValue(value)}`);
+  }
+  const extrasPart = extraPairs.length > 0 ? ` (${extraPairs.join(", ")})` : "";
+  return `${srcPart}${message}${extrasPart}`;
+}
 var DEFAULT_LOG_LEVEL = "info";
 var effectiveLogLevel = getEnv3("LOG_LEVEL") || DEFAULT_LOG_LEVEL;
 var customLevels = {
@@ -42568,6 +43124,46 @@ var customLevels = {
 };
 var raw = parseBooleanFromText(getEnv3("LOG_JSON_FORMAT"));
 var showTimestamps = parseBooleanFromText(getEnv3("LOG_TIMESTAMPS") ?? "true");
+var serverId = getEnv3("SERVER_ID") || (typeof crypto !== "undefined" && crypto.randomUUID ? crypto.randomUUID().slice(0, 8) : Math.random().toString(36).slice(2, 10));
+var redact = import_fast_redact.default({
+  paths: [
+    "password",
+    "passwd",
+    "secret",
+    "token",
+    "apiKey",
+    "api_key",
+    "apiSecret",
+    "api_secret",
+    "authorization",
+    "auth",
+    "credential",
+    "credentials",
+    "privateKey",
+    "private_key",
+    "accessToken",
+    "access_token",
+    "refreshToken",
+    "refresh_token",
+    "cookie",
+    "session",
+    "jwt",
+    "bearer",
+    "*.password",
+    "*.secret",
+    "*.token",
+    "*.apiKey",
+    "*.api_key",
+    "*.authorization",
+    "*.credential",
+    "*.credentials",
+    "*.privateKey",
+    "*.accessToken",
+    "*.refreshToken"
+  ],
+  serialize: false,
+  censor: "[REDACTED]"
+});
 function createInMemoryDestination(maxLogs = 100) {
   const logs = [];
   return {
@@ -42716,24 +43312,31 @@ function sealAdze(base) {
   const metaBase = { ...base };
   delete metaBase.namespace;
   delete metaBase.namespaces;
-  if (raw) {
-    if (!metaBase.name) {
-      metaBase.name = "elizaos";
-    }
-    if (!metaBase.hostname) {
-      let hostname = "unknown";
-      if (typeof process !== "undefined" && process.platform) {
-        try {
-          const os = __require("os");
-          hostname = os.hostname();
-        } catch {
-          hostname = "localhost";
-        }
-      } else if (typeof window !== "undefined" && window.location) {
-        hostname = window.location.hostname || "browser";
+  if (!metaBase.name) {
+    metaBase.name = "elizaos";
+  }
+  if (!metaBase.pid && typeof process !== "undefined" && process.pid) {
+    metaBase.pid = process.pid;
+  }
+  if (!metaBase.environment && typeof process !== "undefined" && process.env) {
+    metaBase.environment = "development";
+  }
+  if (!metaBase.serverId) {
+    metaBase.serverId = serverId;
+  }
+  if (raw && !metaBase.hostname) {
+    let hostname = "unknown";
+    if (typeof process !== "undefined" && process.platform) {
+      try {
+        const os = __require("os");
+        hostname = os.hostname();
+      } catch {
+        hostname = "localhost";
       }
-      metaBase.hostname = hostname;
+    } else if (typeof window !== "undefined" && window.location) {
+      hostname = window.location.hostname || "browser";
     }
+    metaBase.hostname = hostname;
   }
   const globalConfig = {
     activeLevel: getAdzeActiveLevel(),
@@ -42788,6 +43391,15 @@ function createLogger(bindings = false) {
         console[consoleMethod](message);
       }
     };
+    const safeRedact2 = (obj) => {
+      try {
+        const copy = { ...obj };
+        redact(copy);
+        return copy;
+      } catch {
+        return obj;
+      }
+    };
     const adaptArgs2 = (obj, msg, ...args) => {
       if (typeof obj === "string") {
         return msg !== undefined ? [obj, msg, ...args] : [obj, ...args];
@@ -42795,10 +43407,13 @@ function createLogger(bindings = false) {
       if (obj instanceof Error) {
         return msg !== undefined ? [obj.message, msg, ...args] : [obj.message, ...args];
       }
+      const redactedObj = safeRedact2(obj);
       if (msg !== undefined) {
-        return [msg, obj, ...args];
+        const formatted2 = formatPrettyLog(redactedObj, msg, false);
+        return [formatted2, ...args];
       }
-      return [obj, ...args];
+      const formatted = formatPrettyLog(redactedObj, "", false);
+      return formatted ? [formatted, ...args] : [...args];
     };
     return {
       level: currentLevel2,
@@ -42867,6 +43482,15 @@ function createLogger(bindings = false) {
       console.log(`[${method.toUpperCase()}]`, ...args);
     }
   };
+  const safeRedact = (obj) => {
+    try {
+      const copy = { ...obj };
+      redact(copy);
+      return copy;
+    } catch {
+      return obj;
+    }
+  };
   const adaptArgs = (obj, msg, ...args) => {
     if (typeof obj === "string") {
       return msg !== undefined ? [obj, msg, ...args] : [obj, ...args];
@@ -42874,10 +43498,19 @@ function createLogger(bindings = false) {
     if (obj instanceof Error) {
       return msg !== undefined ? [obj.message, { error: obj }, msg, ...args] : [obj.message, { error: obj }, ...args];
     }
+    const redactedObj = safeRedact(obj);
     if (msg !== undefined) {
-      return [msg, obj, ...args];
+      if (!raw) {
+        const formatted = formatPrettyLog(redactedObj, msg, raw);
+        return [formatted, ...args];
+      }
+      return [msg, redactedObj, ...args];
     }
-    return [obj, ...args];
+    if (!raw) {
+      const formatted = formatPrettyLog(redactedObj, "", raw);
+      return formatted ? [formatted, ...args] : [...args];
+    }
+    return [redactedObj, ...args];
   };
   const trace = (obj, msg, ...args) => invoke("verbose", ...adaptArgs(obj, msg, ...args));
   const debug = (obj, msg, ...args) => invoke("debug", ...adaptArgs(obj, msg, ...args));
@@ -42986,7 +43619,7 @@ var formatPosts = ({
     const messageStrings = roomMessages.filter((message) => message.entityId).map((message) => {
       const entity = entities.find((entity2) => entity2.id === message.entityId);
       if (!entity) {
-        logger_default.warn({ entityId: message.entityId }, "core::prompts:formatPosts - no entity for");
+        logger_default.warn({ src: "core:utils", entityId: message.entityId }, "No entity found for message");
       }
       const userName = entity?.names[0] || "Unknown User";
       const displayName = entity?.names[0] || "unknown";
@@ -43071,7 +43704,6 @@ function parseKeyValueXml(text) {
   let xmlContent;
   if (xmlBlockMatch) {
     xmlContent = xmlBlockMatch[1];
-    logger_default.debug("Found response XML block");
   } else {
     const findFirstXmlBlock = (input) => {
       let i = 0;
@@ -43144,12 +43776,10 @@ function parseKeyValueXml(text) {
     };
     const fb = findFirstXmlBlock(text);
     if (!fb) {
-      logger_default.warn("Could not find XML block in text");
-      logger_default.debug({ textPreview: text.substring(0, 200) + "..." }, "Text content");
+      logger_default.warn({ src: "core:utils" }, "Could not find XML block in text");
       return null;
     }
     xmlContent = fb.content;
-    logger_default.debug(`Found XML block with tag: ${fb.tag}`);
   }
   const result = {};
   const extractDirectChildren = (input) => {
@@ -43234,8 +43864,7 @@ function parseKeyValueXml(text) {
     }
   }
   if (Object.keys(result).length === 0) {
-    logger_default.warn("No key-value pairs extracted from XML content");
-    logger_default.debug({ xmlPreview: xmlContent.substring(0, 200) + "..." }, "XML content was");
+    logger_default.warn({ src: "core:utils" }, "No key-value pairs extracted from XML content");
     return null;
   }
   return result;
@@ -43286,17 +43915,12 @@ function truncateToCompleteSentence(text, maxLength) {
   return `${hardTruncated}...`;
 }
 async function splitChunks(content, chunkSize = 512, bleed = 20) {
-  logger_default.debug("[splitChunks] Starting text split");
   const characterstoTokens = 3.5;
   const textSplitter = new RecursiveCharacterTextSplitter({
     chunkSize: Number(Math.floor(chunkSize * characterstoTokens)),
     chunkOverlap: Number(Math.floor(bleed * characterstoTokens))
   });
   const chunks = await textSplitter.splitText(content);
-  logger_default.debug({
-    numberOfChunks: chunks.length,
-    averageChunkSize: chunks.reduce((acc, chunk) => acc + chunk.length, 0) / chunks.length
-  }, "[splitChunks] Split complete");
   return chunks;
 }
 async function trimTokens(prompt, maxTokens, runtime) {
@@ -44373,8 +44997,8 @@ Here are the actions taken by the assistant to fulfill the request:
 `;
 
 // src/roles.ts
-async function getUserServerRole(runtime, entityId, serverId) {
-  const worldId = createUniqueUuid(runtime, serverId);
+async function getUserServerRole(runtime, entityId, serverId2) {
+  const worldId = createUniqueUuid(runtime, serverId2);
   const world = await runtime.getWorld(worldId);
   if (!world || !world.metadata?.roles) {
     return "NONE" /* NONE */;
@@ -44389,12 +45013,12 @@ async function getUserServerRole(runtime, entityId, serverId) {
 }
 async function findWorldsForOwner(runtime, entityId) {
   if (!entityId) {
-    logger.error("User ID is required to find server");
+    logger.error({ src: "core:roles", agentId: runtime.agentId }, "User ID is required to find server");
     return null;
   }
   const worlds = await runtime.getAllWorlds();
   if (!worlds || worlds.length === 0) {
-    logger.info("No worlds found for this agent");
+    logger.debug({ src: "core:roles", agentId: runtime.agentId }, "No worlds found for agent");
     return null;
   }
   const ownerWorlds = [];
@@ -44511,7 +45135,7 @@ class DefaultMessageService {
     let timeoutId = undefined;
     const responseId = v4_default();
     try {
-      runtime.logger.info(`[MessageService] Message received from ${message.entityId} in room ${message.roomId}`);
+      runtime.logger.info({ src: "service:message", agentId: runtime.agentId, entityId: message.entityId, roomId: message.roomId }, "Message received");
       if (!latestResponseIds.has(runtime.agentId)) {
         latestResponseIds.set(runtime.agentId, new Map);
       }
@@ -44520,7 +45144,7 @@ class DefaultMessageService {
         throw new Error("Agent responses map not found");
       const previousResponseId = agentResponses.get(message.roomId);
       if (previousResponseId) {
-        logger.warn(`[MessageService] Updating response ID for room ${message.roomId} from ${previousResponseId} to ${responseId}`);
+        logger.debug({ src: "service:message", roomId: message.roomId, previousResponseId, responseId }, "Updating response ID");
       }
       agentResponses.set(message.roomId, responseId);
       const runId = runtime.startRun(message.roomId);
@@ -44560,7 +45184,7 @@ class DefaultMessageService {
       return result;
     } catch (error) {
       clearTimeout(timeoutId);
-      runtime.logger.error({ error }, "[MessageService] Error in handleMessage:");
+      runtime.logger.error({ src: "service:message", agentId: runtime.agentId, error }, "Error in handleMessage");
       throw error;
     }
   }
@@ -44570,7 +45194,7 @@ class DefaultMessageService {
       if (!agentResponses)
         throw new Error("Agent responses map not found");
       if (message.entityId === runtime.agentId) {
-        runtime.logger.debug(`[MessageService] Skipping message from self (${runtime.agentId})`);
+        runtime.logger.debug({ src: "service:message", agentId: runtime.agentId }, "Skipping message from self");
         await this.emitRunEnded(runtime, runId, message, startTime, "self");
         return {
           didRespond: false,
@@ -44580,13 +45204,13 @@ class DefaultMessageService {
           mode: "none"
         };
       }
-      runtime.logger.debug(`[MessageService] Processing message: ${truncateToCompleteSentence(message.content.text || "", 50)}...`);
-      runtime.logger.debug("[MessageService] Saving message to memory and queueing embeddings");
+      runtime.logger.debug({ src: "service:message", messagePreview: truncateToCompleteSentence(message.content.text || "", 50) }, "Processing message");
+      runtime.logger.debug({ src: "service:message" }, "Saving message to memory");
       let memoryToQueue;
       if (message.id) {
         const existingMemory = await runtime.getMemoryById(message.id);
         if (existingMemory) {
-          runtime.logger.debug("[MessageService] Memory already exists, skipping creation");
+          runtime.logger.debug({ src: "service:message" }, "Memory already exists, skipping creation");
           memoryToQueue = existingMemory;
         } else {
           const createdMemoryId = await runtime.createMemory(message, "messages");
@@ -44602,7 +45226,7 @@ class DefaultMessageService {
       const agentUserState = await runtime.getParticipantUserState(message.roomId, runtime.agentId);
       const defLllmOff = parseBooleanFromText2(runtime.getSetting("BOOTSTRAP_DEFLLMOFF"));
       if (defLllmOff && agentUserState === null) {
-        runtime.logger.debug("[MessageService] LLM is off by default");
+        runtime.logger.debug({ src: "service:message" }, "LLM is off by default");
         await this.emitRunEnded(runtime, runId, message, startTime, "off");
         return {
           didRespond: false,
@@ -44613,7 +45237,7 @@ class DefaultMessageService {
         };
       }
       if (agentUserState === "MUTED" && !message.content.text?.toLowerCase().includes(runtime.character.name.toLowerCase())) {
-        runtime.logger.debug(`[MessageService] Ignoring muted room ${message.roomId}`);
+        runtime.logger.debug({ src: "service:message", roomId: message.roomId }, "Ignoring muted room");
         await this.emitRunEnded(runtime, runId, message, startTime, "muted");
         return {
           didRespond: false,
@@ -44633,24 +45257,23 @@ class DefaultMessageService {
         }
       }
       const responseDecision = this.shouldRespond(runtime, message, room ?? undefined, mentionContext);
-      runtime.logger.debug(`[MessageService] Response decision: ${JSON.stringify(responseDecision)}`);
+      runtime.logger.debug({ src: "service:message", responseDecision }, "Response decision");
       let shouldRespondToMessage = true;
       if (responseDecision.skipEvaluation) {
-        runtime.logger.debug(`[MessageService] Skipping evaluation for ${runtime.character.name} (${responseDecision.reason})`);
+        runtime.logger.debug({ src: "service:message", agentName: runtime.character.name, reason: responseDecision.reason }, "Skipping LLM evaluation");
         shouldRespondToMessage = responseDecision.shouldRespond;
       } else {
         const shouldRespondPrompt = composePromptFromState({
           state,
           template: runtime.character.templates?.shouldRespondTemplate || shouldRespondTemplate
         });
-        runtime.logger.debug(`[MessageService] Using LLM evaluation for ${runtime.character.name} (${responseDecision.reason})`);
+        runtime.logger.debug({ src: "service:message", agentName: runtime.character.name, reason: responseDecision.reason }, "Using LLM evaluation");
         const response = await runtime.useModel(ModelType.TEXT_SMALL, {
           prompt: shouldRespondPrompt
         });
-        runtime.logger.debug(`[MessageService] LLM evaluation result:
-${response}`);
+        runtime.logger.debug({ src: "service:message", response }, "LLM evaluation result");
         const responseObject = parseKeyValueXml(response);
-        runtime.logger.debug({ responseObject }, "[MessageService] Parsed evaluation result:");
+        runtime.logger.debug({ src: "service:message", responseObject }, "Parsed evaluation result");
         const nonResponseActions = ["IGNORE", "NONE"];
         shouldRespondToMessage = responseObject?.action && !nonResponseActions.includes(responseObject.action.toUpperCase());
       }
@@ -44665,7 +45288,7 @@ ${response}`);
         mode = result.mode;
         const currentResponseId = agentResponses.get(message.roomId);
         if (currentResponseId !== responseId) {
-          runtime.logger.info(`Response discarded - newer message being processed for agent: ${runtime.agentId}, room: ${message.roomId}`);
+          runtime.logger.info({ src: "service:message", agentId: runtime.agentId, roomId: message.roomId }, "Response discarded - newer message being processed");
           return {
             didRespond: false,
             responseContent: null,
@@ -44683,14 +45306,14 @@ ${response}`);
         if (responseContent) {
           if (mode === "simple") {
             if (responseContent.providers && responseContent.providers.length > 0) {
-              runtime.logger.debug({ providers: responseContent.providers }, "[MessageService] Simple response used providers");
+              runtime.logger.debug({ src: "service:message", providers: responseContent.providers }, "Simple response used providers");
             }
             if (callback) {
               await callback(responseContent);
             }
           } else if (mode === "actions") {
             await runtime.processActions(message, responseMessages, state, async (content) => {
-              runtime.logger.debug({ content }, "action callback");
+              runtime.logger.debug({ src: "service:message", content }, "Action callback");
               responseContent.actionCallbacks = content;
               if (callback) {
                 return callback(content);
@@ -44700,11 +45323,11 @@ ${response}`);
           }
         }
       } else {
-        runtime.logger.debug("[MessageService] Agent decided not to respond (shouldRespond is false).");
+        runtime.logger.debug({ src: "service:message" }, "Agent decided not to respond");
         const currentResponseId = agentResponses.get(message.roomId);
         const keepResp = parseBooleanFromText2(runtime.getSetting("BOOTSTRAP_KEEP_RESP"));
         if (currentResponseId !== responseId && !keepResp) {
-          runtime.logger.info(`Ignore response discarded - newer message being processed for agent: ${runtime.agentId}, room: ${message.roomId}`);
+          runtime.logger.info({ src: "service:message", agentId: runtime.agentId, roomId: message.roomId }, "Ignore response discarded - newer message being processed");
           await this.emitRunEnded(runtime, runId, message, startTime, "replaced");
           return {
             didRespond: false,
@@ -44715,7 +45338,7 @@ ${response}`);
           };
         }
         if (!message.id) {
-          runtime.logger.error("[MessageService] Message ID is missing, cannot create ignore response.");
+          runtime.logger.error({ src: "service:message", agentId: runtime.agentId }, "Message ID is missing, cannot create ignore response");
           await this.emitRunEnded(runtime, runId, message, startTime, "noMessageId");
           return {
             didRespond: false,
@@ -44743,14 +45366,14 @@ ${response}`);
           createdAt: Date.now()
         };
         await runtime.createMemory(ignoreMemory, "messages");
-        runtime.logger.debug("[MessageService] Saved ignore response to memory", `memoryId: ${ignoreMemory.id}`);
+        runtime.logger.debug({ src: "service:message", memoryId: ignoreMemory.id }, "Saved ignore response to memory");
       }
       agentResponses.delete(message.roomId);
       if (agentResponses.size === 0) {
         latestResponseIds.delete(runtime.agentId);
       }
       await runtime.evaluate(message, state, shouldRespondToMessage, async (content) => {
-        runtime.logger.debug({ content }, "evaluate callback");
+        runtime.logger.debug({ src: "service:message", content }, "Evaluate callback");
         if (responseContent) {
           responseContent.evalCallbacks = content;
         }
@@ -44823,7 +45446,7 @@ ${response}`);
         mode
       };
     } catch (error) {
-      console.error("error is", error);
+      runtime.logger.error({ src: "service:message", agentId: runtime.agentId, error }, "Error processing message");
       await runtime.emitEvent("RUN_ENDED" /* RUN_ENDED */, {
         runtime,
         runId,
@@ -44884,7 +45507,7 @@ ${response}`);
     if (!attachments || attachments.length === 0) {
       return [];
     }
-    runtime.logger.debug(`[MessageService] Processing ${attachments.length} attachment(s)`);
+    runtime.logger.debug({ src: "service:message", count: attachments.length }, "Processing attachments");
     const processedAttachments = [];
     for (const attachment of attachments) {
       try {
@@ -44892,7 +45515,7 @@ ${response}`);
         const isRemote = /^(http|https):\/\//.test(attachment.url);
         const url = isRemote ? attachment.url : getLocalServerUrl(attachment.url);
         if (attachment.contentType === "image" /* IMAGE */ && !attachment.description) {
-          runtime.logger.debug(`[MessageService] Generating description for image: ${attachment.url}`);
+          runtime.logger.debug({ src: "service:message", imageUrl: attachment.url }, "Generating image description");
           let imageUrl = url;
           if (!isRemote) {
             const res = await fetch(url);
@@ -44914,7 +45537,7 @@ ${response}`);
                 processedAttachment.description = parsedXml.description || "";
                 processedAttachment.title = parsedXml.title || "Image";
                 processedAttachment.text = parsedXml.text || parsedXml.description || "";
-                runtime.logger.debug(`[MessageService] Generated description: ${processedAttachment.description?.substring(0, 100)}...`);
+                runtime.logger.debug({ src: "service:message", descriptionPreview: processedAttachment.description?.substring(0, 100) }, "Generated image description");
               } else {
                 const responseStr = response;
                 const titleMatch = responseStr.match(/<title>([^<]+)<\/title>/);
@@ -44924,21 +45547,21 @@ ${response}`);
                   processedAttachment.title = titleMatch?.[1] || "Image";
                   processedAttachment.description = descMatch?.[1] || "";
                   processedAttachment.text = textMatch?.[1] || descMatch?.[1] || "";
-                  runtime.logger.debug(`[MessageService] Used fallback XML parsing - description: ${processedAttachment.description?.substring(0, 100)}...`);
+                  runtime.logger.debug({ src: "service:message", descriptionPreview: processedAttachment.description?.substring(0, 100) }, "Used fallback XML parsing for description");
                 } else {
-                  runtime.logger.warn(`[MessageService] Failed to parse XML response for image description`);
+                  runtime.logger.warn({ src: "service:message" }, "Failed to parse XML response for image description");
                 }
               }
             } else if (response && typeof response === "object" && "description" in response) {
               processedAttachment.description = response.description;
               processedAttachment.title = response.title || "Image";
               processedAttachment.text = response.description;
-              runtime.logger.debug(`[MessageService] Generated description: ${processedAttachment.description?.substring(0, 100)}...`);
+              runtime.logger.debug({ src: "service:message", descriptionPreview: processedAttachment.description?.substring(0, 100) }, "Generated image description");
             } else {
-              runtime.logger.warn(`[MessageService] Unexpected response format for image description`);
+              runtime.logger.warn({ src: "service:message" }, "Unexpected response format for image description");
             }
           } catch (error) {
-            runtime.logger.error({ error }, `[MessageService] Error generating image description:`);
+            runtime.logger.error({ src: "service:message", error }, "Error generating image description");
           }
         } else if (attachment.contentType === "document" /* DOCUMENT */ && !attachment.text) {
           const res = await fetch(url);
@@ -44947,18 +45570,18 @@ ${response}`);
           const contentType = res.headers.get("content-type") || "";
           const isPlainText = contentType.startsWith("text/plain");
           if (isPlainText) {
-            runtime.logger.debug(`[MessageService] Processing plain text document: ${attachment.url}`);
+            runtime.logger.debug({ src: "service:message", documentUrl: attachment.url }, "Processing plain text document");
             const textContent = await res.text();
             processedAttachment.text = textContent;
             processedAttachment.title = processedAttachment.title || "Text File";
-            runtime.logger.debug(`[MessageService] Extracted text content (first 100 chars): ${processedAttachment.text?.substring(0, 100)}...`);
+            runtime.logger.debug({ src: "service:message", textPreview: processedAttachment.text?.substring(0, 100) }, "Extracted text content");
           } else {
-            runtime.logger.warn(`[MessageService] Skipping non-plain-text document: ${contentType}`);
+            runtime.logger.warn({ src: "service:message", contentType }, "Skipping non-plain-text document");
           }
         }
         processedAttachments.push(processedAttachment);
       } catch (error) {
-        runtime.logger.error({ error, attachmentUrl: attachment.url }, `[MessageService] Failed to process attachment ${attachment.url}:`);
+        runtime.logger.error({ src: "service:message", error, attachmentUrl: attachment.url }, "Failed to process attachment");
         processedAttachments.push(attachment);
       }
     }
@@ -44967,7 +45590,7 @@ ${response}`);
   async runSingleShotCore(runtime, message, state, opts) {
     state = await runtime.composeState(message, ["ACTIONS"]);
     if (!state.values?.actionNames) {
-      runtime.logger.warn("actionNames data missing from state, even though it was requested");
+      runtime.logger.warn({ src: "service:message" }, "actionNames data missing from state");
     }
     const prompt = composePromptFromState({
       state,
@@ -44977,9 +45600,9 @@ ${response}`);
     let retries = 0;
     while (retries < opts.maxRetries && (!responseContent?.thought || !responseContent?.actions)) {
       const response = await runtime.useModel(ModelType.TEXT_LARGE, { prompt });
-      runtime.logger.debug({ response }, "[MessageService] *** Raw LLM Response ***");
+      runtime.logger.debug({ src: "service:message", response }, "Raw LLM response");
       const parsedXml = parseKeyValueXml(response);
-      runtime.logger.debug({ parsedXml }, "[MessageService] *** Parsed XML Content ***");
+      runtime.logger.debug({ src: "service:message", parsedXml }, "Parsed XML content");
       if (parsedXml) {
         responseContent = {
           ...parsedXml,
@@ -44994,7 +45617,7 @@ ${response}`);
       }
       retries++;
       if (!responseContent?.thought || !responseContent?.actions) {
-        runtime.logger.warn({ response, parsedXml, responseContent }, "[MessageService] *** Missing required fields (thought or actions), retrying... ***");
+        runtime.logger.warn({ src: "service:message", retries, maxRetries: opts.maxRetries }, "Missing required fields (thought or actions), retrying");
       }
     }
     if (!responseContent) {
@@ -45037,7 +45660,7 @@ ${response}`);
     let iterationCount = 0;
     while (iterationCount < opts.maxMultiStepIterations) {
       iterationCount++;
-      runtime.logger.debug(`[MultiStep] Starting iteration ${iterationCount}/${opts.maxMultiStepIterations}`);
+      runtime.logger.debug({ src: "service:message", iteration: iterationCount, maxIterations: opts.maxMultiStepIterations }, "Starting multi-step iteration");
       accumulatedState = await runtime.composeState(message, [
         "RECENT_MESSAGES",
         "ACTION_STATE"
@@ -45050,7 +45673,7 @@ ${response}`);
       const stepResultRaw = await runtime.useModel(ModelType.TEXT_LARGE, { prompt });
       const parsedStep = parseKeyValueXml(stepResultRaw);
       if (!parsedStep) {
-        runtime.logger.warn(`[MultiStep] Failed to parse step result at iteration ${iterationCount}`);
+        runtime.logger.warn({ src: "service:message", iteration: iterationCount }, "Failed to parse multi-step result");
         traceActionResult.push({
           data: { actionName: "parse_error" },
           success: false,
@@ -45060,7 +45683,7 @@ ${response}`);
       }
       const { thought, providers = [], action, isFinish } = parsedStep;
       if (isFinish === "true" || isFinish === true) {
-        runtime.logger.info(`[MultiStep] Task marked as complete at iteration ${iterationCount}`);
+        runtime.logger.info({ src: "service:message", agentId: runtime.agentId, iteration: iterationCount }, "Multi-step task completed");
         if (callback) {
           await callback({
             text: "",
@@ -45070,14 +45693,14 @@ ${response}`);
         break;
       }
       if ((!providers || providers.length === 0) && !action) {
-        runtime.logger.warn(`[MultiStep] No providers or action specified at iteration ${iterationCount}, forcing completion`);
+        runtime.logger.warn({ src: "service:message", iteration: iterationCount }, "No providers or action specified, forcing completion");
         break;
       }
       try {
         for (const providerName of providers) {
           const provider = runtime.providers.find((p) => p.name === providerName);
           if (!provider) {
-            runtime.logger.warn(`[MultiStep] Provider not found: ${providerName}`);
+            runtime.logger.warn({ src: "service:message", providerName }, "Provider not found");
             traceActionResult.push({
               data: { actionName: providerName },
               success: false,
@@ -45087,7 +45710,7 @@ ${response}`);
           }
           const providerResult = await provider.get(runtime, message, state);
           if (!providerResult) {
-            runtime.logger.warn(`[MultiStep] Provider returned no result: ${providerName}`);
+            runtime.logger.warn({ src: "service:message", providerName }, "Provider returned no result");
             traceActionResult.push({
               data: { actionName: providerName },
               success: false,
@@ -45140,7 +45763,7 @@ ${response}`);
           });
         }
       } catch (err) {
-        runtime.logger.error({ err }, "[MultiStep] Error executing step");
+        runtime.logger.error({ src: "service:message", agentId: runtime.agentId, error: err }, "Error executing multi-step action");
         traceActionResult.push({
           data: { actionName: action || "unknown" },
           success: false,
@@ -45149,7 +45772,7 @@ ${response}`);
       }
     }
     if (iterationCount >= opts.maxMultiStepIterations) {
-      runtime.logger.warn(`[MultiStep] Reached maximum iterations (${opts.maxMultiStepIterations}), forcing completion`);
+      runtime.logger.warn({ src: "service:message", maxIterations: opts.maxMultiStepIterations }, "Reached maximum iterations, forcing completion");
     }
     accumulatedState = await runtime.composeState(message, [
       "RECENT_MESSAGES",
@@ -45204,25 +45827,25 @@ ${response}`);
   async deleteMessage(runtime, message) {
     try {
       if (!message.id) {
-        runtime.logger.error("[MessageService] Cannot delete memory: message ID is missing");
+        runtime.logger.error({ src: "service:message", agentId: runtime.agentId }, "Cannot delete memory: message ID is missing");
         return;
       }
-      runtime.logger.info("[MessageService] Deleting memory for message", message.id, "from room", message.roomId);
+      runtime.logger.info({ src: "service:message", agentId: runtime.agentId, messageId: message.id, roomId: message.roomId }, "Deleting memory");
       await runtime.deleteMemory(message.id);
-      runtime.logger.debug({ messageId: message.id }, "[MessageService] Successfully deleted memory for message");
+      runtime.logger.debug({ src: "service:message", messageId: message.id }, "Successfully deleted memory");
     } catch (error) {
-      runtime.logger.error({ error }, "[MessageService] Error in deleteMessage:");
+      runtime.logger.error({ src: "service:message", agentId: runtime.agentId, error }, "Error in deleteMessage");
       throw error;
     }
   }
   async clearChannel(runtime, roomId, channelId) {
     try {
-      runtime.logger.info(`[MessageService] Clearing message memories from channel ${channelId} -> room ${roomId}`);
+      runtime.logger.info({ src: "service:message", agentId: runtime.agentId, channelId, roomId }, "Clearing message memories from channel");
       const memories = await runtime.getMemoriesByRoomIds({
         tableName: "messages",
         roomIds: [roomId]
       });
-      runtime.logger.info(`[MessageService] Found ${memories.length} message memories to delete from channel ${channelId}`);
+      runtime.logger.debug({ src: "service:message", channelId, count: memories.length }, "Found message memories to delete");
       let deletedCount = 0;
       for (const memory of memories) {
         if (memory.id) {
@@ -45230,13 +45853,13 @@ ${response}`);
             await runtime.deleteMemory(memory.id);
             deletedCount++;
           } catch (error) {
-            runtime.logger.warn({ error, memoryId: memory.id }, `[MessageService] Failed to delete message memory ${memory.id}:`);
+            runtime.logger.warn({ src: "service:message", error, memoryId: memory.id }, "Failed to delete message memory");
           }
         }
       }
-      runtime.logger.info(`[MessageService] Successfully cleared ${deletedCount}/${memories.length} message memories from channel ${channelId}`);
+      runtime.logger.info({ src: "service:message", agentId: runtime.agentId, channelId, deletedCount, totalCount: memories.length }, "Cleared message memories from channel");
     } catch (error) {
-      runtime.logger.error({ error }, "[MessageService] Error in clearChannel:");
+      runtime.logger.error({ src: "service:message", agentId: runtime.agentId, error }, "Error in clearChannel");
       throw error;
     }
   }
@@ -46115,7 +46738,6 @@ class AgentRuntime {
   initPromise;
   initResolver;
   initRejecter;
-  migratedPlugins = new Set;
   currentRunId;
   currentRoomId;
   currentActionContext;
@@ -46146,7 +46768,7 @@ class AgentRuntime {
         }
       }
     }
-    this.logger.debug(`Success: Agent ID: ${this.agentId}`);
+    this.logger.debug({ src: "agent", agentId: this.agentId, agentName: this.character?.name }, "Initialized");
     this.currentRunId = undefined;
     if (opts.settings?.MAX_WORKING_MEMORY_ENTRIES) {
       this.maxWorkingMemoryEntries = parseInt(opts.settings.MAX_WORKING_MEMORY_ENTRIES, 10) || 50;
@@ -46175,20 +46797,20 @@ class AgentRuntime {
   async registerPlugin(plugin) {
     if (!plugin?.name) {
       const errorMsg = "Plugin or plugin name is undefined";
-      this.logger.error(`*** registerPlugin: ${errorMsg}`);
-      throw new Error(`*** registerPlugin: ${errorMsg}`);
+      this.logger.error({ src: "agent", agentId: this.agentId, error: errorMsg }, "Plugin registration failed");
+      throw new Error(`registerPlugin: ${errorMsg}`);
     }
     const existingPlugin = this.plugins.find((p) => p.name === plugin.name);
     if (existingPlugin) {
-      this.logger.warn(`${this.character.name}(${this.agentId}) - Plugin ${plugin.name} is already registered. Skipping re-registration.`);
+      this.logger.warn({ src: "agent", agentId: this.agentId, plugin: plugin.name }, "Plugin already registered, skipping");
       return;
     }
     this.plugins.push(plugin);
-    this.logger.debug(`Success: Plugin ${plugin.name} added to active plugins for ${this.character.name}(${this.agentId}).`);
+    this.logger.debug({ src: "agent", agentId: this.agentId, plugin: plugin.name }, "Plugin added");
     if (plugin.init) {
       try {
         await plugin.init(plugin.config || {}, this);
-        this.logger.debug(`Success: Plugin ${plugin.name} initialized successfully`);
+        this.logger.debug({ src: "agent", agentId: this.agentId, plugin: plugin.name }, "Plugin initialized");
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         if (errorMessage.includes("API key") || errorMessage.includes("environment variables") || errorMessage.includes("Invalid plugin configuration")) {
@@ -46201,7 +46823,7 @@ class AgentRuntime {
       }
     }
     if (plugin.adapter) {
-      this.logger.debug(`Registering database adapter for plugin ${plugin.name}`);
+      this.logger.debug({ src: "agent", agentId: this.agentId, plugin: plugin.name }, "Registering database adapter");
       this.registerDatabaseAdapter(plugin.adapter);
     }
     if (plugin.actions) {
@@ -46240,14 +46862,13 @@ class AgentRuntime {
     if (plugin.services) {
       for (const service of plugin.services) {
         const serviceType = service.serviceType;
-        const serviceName = service.name || "Unknown";
-        this.logger.debug(`Plugin ${plugin.name} registering service: ${serviceType}`);
+        this.logger.debug({ src: "agent", agentId: this.agentId, plugin: plugin.name, serviceType }, "Registering service");
         if (!this.servicePromises.has(serviceType)) {
           this._createServiceResolver(serviceType);
         }
         this.serviceRegistrationStatus.set(serviceType, "pending");
         this.registerService(service).catch((error) => {
-          this.logger.error(`Plugin ${plugin.name} failed to register service ${serviceType}: ${error instanceof Error ? error.message : String(error)}`);
+          this.logger.error({ src: "agent", agentId: this.agentId, plugin: plugin.name, serviceType, error: error instanceof Error ? error.message : String(error) }, "Service registration failed");
           const handler = this.servicePromiseHandlers.get(serviceType);
           if (handler) {
             const serviceError = new Error(`Service ${serviceType} from plugin ${plugin.name} failed to register: ${error instanceof Error ? error.message : String(error)}`);
@@ -46264,9 +46885,9 @@ class AgentRuntime {
     return this.services;
   }
   async stop() {
-    this.logger.debug(`runtime::stop - character ${this.character.name}`);
-    for (const [serviceName, services] of this.services) {
-      this.logger.debug(`runtime::stop - requesting service stop for ${serviceName}`);
+    this.logger.debug({ src: "agent", agentId: this.agentId }, "Stopping runtime");
+    for (const [serviceType, services] of this.services) {
+      this.logger.debug({ src: "agent", agentId: this.agentId, serviceType }, "Stopping service");
       for (const service of services) {
         await service.stop();
       }
@@ -46284,8 +46905,7 @@ class AgentRuntime {
       }
       await Promise.all(pluginRegistrationPromises);
       if (!this.adapter) {
-        const errorMsg = "Database adapter not initialized. Make sure @elizaos/plugin-sql is included in your plugins.";
-        this.logger.error(errorMsg);
+        this.logger.error({ src: "agent", agentId: this.agentId }, "Database adapter not initialized");
         throw new Error("Database adapter not initialized. The SQL plugin (@elizaos/plugin-sql) is required for agent initialization. Please ensure it is included in your character configuration.");
       }
       if (!await this.adapter.isReady()) {
@@ -46294,11 +46914,11 @@ class AgentRuntime {
       this.messageService = new DefaultMessageService;
       const skipMigrations = options?.skipMigrations ?? false;
       if (skipMigrations) {
-        this.logger.info("Skipping plugin migrations (skipMigrations=true)");
+        this.logger.debug({ src: "agent", agentId: this.agentId }, "Skipping plugin migrations");
       } else {
-        this.logger.info("Running plugin migrations...");
+        this.logger.debug({ src: "agent", agentId: this.agentId }, "Running plugin migrations");
         await this.runPluginMigrations();
-        this.logger.info("Plugin migrations completed.");
+        this.logger.debug({ src: "agent", agentId: this.agentId }, "Plugin migrations completed");
       }
       const existingAgent = await this.ensureAgentExists({
         ...this.character,
@@ -46341,7 +46961,7 @@ class AgentRuntime {
         agentEntity = await this.getEntityById(this.agentId);
         if (!agentEntity)
           throw new Error(`Agent entity not found for ${this.agentId}`);
-        this.logger.debug(`Success: Agent entity created successfully for ${this.character.name}`);
+        this.logger.debug({ src: "agent", agentId: this.agentId }, "Agent entity created");
       }
       const room = await this.getRoom(this.agentId);
       if (!room) {
@@ -46359,14 +46979,13 @@ class AgentRuntime {
       if (!participants.includes(this.agentId)) {
         const added = await this.addParticipant(this.agentId, this.agentId);
         if (!added) {
-          const errorMsg = `Failed to add agent ${this.agentId} as participant to its own room`;
-          throw new Error(errorMsg);
+          throw new Error(`Failed to add agent ${this.agentId} as participant to its own room`);
         }
-        this.logger.debug(`Agent ${this.character.name} linked to its own room successfully`);
+        this.logger.debug({ src: "agent", agentId: this.agentId }, "Agent linked to room");
       }
       const embeddingModel = this.getModel(ModelType.TEXT_EMBEDDING);
       if (!embeddingModel) {
-        this.logger.warn(`[AgentRuntime][${this.character.name}] No TEXT_EMBEDDING model registered. Skipping embedding dimension setup.`);
+        this.logger.warn({ src: "agent", agentId: this.agentId }, "No TEXT_EMBEDDING model registered, skipping embedding setup");
       } else {
         await this.ensureEmbeddingDimension();
       }
@@ -46376,7 +46995,7 @@ class AgentRuntime {
       }
     } catch (error) {
       const errorMsg = error instanceof Error ? error.message : String(error);
-      this.logger.error(`Runtime initialization failed: ${errorMsg}`);
+      this.logger.error({ src: "agent", agentId: this.agentId, error: errorMsg }, "Runtime initialization failed");
       if (this.initRejecter) {
         this.initRejecter(error);
         this.initRejecter = undefined;
@@ -46396,31 +47015,30 @@ class AgentRuntime {
   }
   async runPluginMigrations() {
     if (!this.adapter) {
-      this.logger.warn("Database adapter not found, skipping plugin migrations.");
+      this.logger.warn({ src: "agent", agentId: this.agentId }, "Database adapter not found, skipping plugin migrations");
       return;
     }
     if (typeof this.adapter.runPluginMigrations !== "function") {
-      this.logger.warn("Database adapter does not support plugin migrations.");
+      this.logger.warn({ src: "agent", agentId: this.agentId }, "Database adapter does not support plugin migrations");
       return;
     }
     const pluginsWithSchemas = this.plugins.filter((p) => p.schema).map((p) => ({ name: p.name, schema: p.schema }));
     if (pluginsWithSchemas.length === 0) {
-      this.logger.info("No plugins with schemas found, skipping migrations.");
+      this.logger.debug({ src: "agent", agentId: this.agentId }, "No plugins with schemas, skipping migrations");
       return;
     }
-    this.logger.info(`Found ${pluginsWithSchemas.length} plugins with schemas to migrate.`);
+    this.logger.debug({ src: "agent", agentId: this.agentId, count: pluginsWithSchemas.length }, "Found plugins with schemas");
     try {
       const isProduction = false;
       const forceDestructive = process.env.ELIZA_ALLOW_DESTRUCTIVE_MIGRATIONS === "true";
-      const options = {
+      await this.adapter.runPluginMigrations(pluginsWithSchemas, {
         verbose: !isProduction,
         force: forceDestructive,
         dryRun: false
-      };
-      await this.adapter.runPluginMigrations(pluginsWithSchemas, options);
-      this.logger.info("Plugin migrations completed successfully.");
+      });
+      this.logger.debug({ src: "agent", agentId: this.agentId }, "Plugin migrations completed");
     } catch (error) {
-      this.logger.error(error instanceof Error ? error : new Error(String(error)), "Failed to run plugin migrations");
+      this.logger.error({ src: "agent", agentId: this.agentId, error: error instanceof Error ? error.message : String(error) }, "Plugin migrations failed");
       throw error;
     }
   }
@@ -46457,26 +47075,22 @@ class AgentRuntime {
   }
   registerDatabaseAdapter(adapter) {
     if (this.adapter) {
-      this.logger.warn("Database adapter already registered. Additional adapters will be ignored. This may lead to unexpected behavior.");
+      this.logger.warn({ src: "agent", agentId: this.agentId }, "Database adapter already registered, ignoring");
     } else {
       this.adapter = adapter;
-      this.logger.debug("Success: Database adapter registered successfully.");
+      this.logger.debug({ src: "agent", agentId: this.agentId }, "Database adapter registered");
     }
   }
   registerProvider(provider) {
     this.providers.push(provider);
-    this.logger.debug(`Success: Provider ${provider.name} registered successfully.`);
+    this.logger.debug({ src: "agent", agentId: this.agentId, provider: provider.name }, "Provider registered");
   }
   registerAction(action) {
     if (this.actions.find((a) => a.name === action.name)) {
-      this.logger.warn(`${this.character.name}(${this.agentId}) - Action ${action.name} already exists. Skipping registration.`);
+      this.logger.warn({ src: "agent", agentId: this.agentId, action: action.name }, "Action already registered, skipping");
     } else {
-      try {
-        this.actions.push(action);
-        this.logger.success(`${this.character.name}(${this.agentId}) - Action ${action.name} registered successfully.`);
-      } catch (e) {
-        console.error("Error registering action", e);
-      }
+      this.actions.push(action);
+      this.logger.debug({ src: "agent", agentId: this.agentId, action: action.name }, "Action registered");
     }
   }
   registerEvaluator(evaluator) {
@@ -46487,7 +47101,7 @@ class AgentRuntime {
   }
   updateActionStep(plan, index, stepUpdates) {
     if (!plan.steps || index < 0 || index >= plan.steps.length) {
-      this.logger.warn(`Invalid step index: ${index} for plan with ${plan.steps?.length || 0} steps`);
+      this.logger.warn({ src: "agent", agentId: this.agentId, index, stepsCount: plan.steps?.length || 0 }, "Invalid step index");
       return plan;
     }
     return {
@@ -46526,13 +47140,13 @@ class AgentRuntime {
         return actionString.toLowerCase().replace(/_/g, "");
       };
       if (!response.content?.actions || response.content.actions.length === 0) {
-        this.logger.warn("No action found in the response content.");
+        this.logger.warn({ src: "agent", agentId: this.agentId }, "No action found in response");
         continue;
       }
       const actions = response.content.actions;
       const actionResults = [];
       let accumulatedState = state;
-      this.logger.debug(`Found actions: ${this.actions.map((a) => normalizeAction(a.name))}`);
+      this.logger.trace({ src: "agent", agentId: this.agentId, actions: this.actions.map((a) => normalizeAction(a.name)) }, "Available actions");
       for (const responseAction of actions) {
         if (actionPlan) {
           actionPlan = this.updateActionPlan(actionPlan, { currentStep: actionIndex + 1 });
@@ -46545,34 +47159,31 @@ class AgentRuntime {
           accumulatedState.data.actionPlan = actionPlan;
           accumulatedState.data.actionResults = actionResults;
         }
-        this.logger.debug(`Success: Calling action: ${responseAction}`);
+        this.logger.debug({ src: "agent", agentId: this.agentId, action: responseAction }, "Processing action");
         const normalizedResponseAction = normalizeAction(responseAction);
         let action = this.actions.find((a) => normalizeAction(a.name) === normalizedResponseAction);
         if (!action) {
           action = this.actions.find((a) => normalizeAction(a.name).includes(normalizedResponseAction) || normalizedResponseAction.includes(normalizeAction(a.name)));
         }
-        if (action) {
-          this.logger.debug(`Success: Found action: ${action?.name}`);
-        } else {
-          this.logger.debug("Attempting to find action in similes.");
+        if (!action) {
           for (const _action of this.actions) {
             const exactSimileMatch = _action.similes?.find((simile) => normalizeAction(simile) === normalizedResponseAction);
             if (exactSimileMatch) {
               action = _action;
-              this.logger.debug(`Success: Action found in similes (exact match): ${action.name}`);
+              this.logger.debug({ src: "agent", agentId: this.agentId, action: action.name, match: "simile" }, "Action resolved via simile");
               break;
             }
             const fuzzySimileMatch = _action.similes?.find((simile) => normalizeAction(simile).includes(normalizedResponseAction) || normalizedResponseAction.includes(normalizeAction(simile)));
             if (fuzzySimileMatch) {
               action = _action;
-              this.logger.debug(`Success: Action found in similes (fuzzy match): ${action.name}`);
+              this.logger.debug({ src: "agent", agentId: this.agentId, action: action.name, match: "fuzzy" }, "Action resolved via fuzzy match");
               break;
             }
           }
         }
         if (!action) {
-          const errorMsg = `No action found for: ${responseAction}`;
-          this.logger.error(errorMsg);
+          const errorMsg = `Action not found: ${responseAction}`;
+          this.logger.error({ src: "agent", agentId: this.agentId, action: responseAction }, "Action not found");
           if (actionPlan && actionPlan.steps[actionIndex]) {
             actionPlan = this.updateActionStep(actionPlan, actionIndex, {
               status: "failed",
@@ -46598,7 +47209,7 @@ class AgentRuntime {
           continue;
         }
         if (!action.handler) {
-          this.logger.error(`Action ${action.name} has no handler.`);
+          this.logger.error({ src: "agent", agentId: this.agentId, action: action.name }, "Action has no handler");
           if (actionPlan && actionPlan.steps[actionIndex]) {
             actionPlan = this.updateActionStep(actionPlan, actionIndex, {
               status: "failed",
@@ -46609,7 +47220,7 @@ class AgentRuntime {
           continue;
         }
         try {
-          this.logger.debug(`Executing handler for action: ${action.name}`);
+          this.logger.debug({ src: "agent", agentId: this.agentId, action: action.name }, "Executing action");
           const actionId = v4_default();
           this.currentActionContext = {
             actionName: action.name,
@@ -46634,7 +47245,6 @@ class AgentRuntime {
             };
           }
           try {
-            this.logger.debug(`Creating action start message for: ${action.name}`);
             await this.emitEvent("ACTION_STARTED" /* ACTION_STARTED */, {
               messageId: actionId,
               roomId: message.roomId,
@@ -46651,7 +47261,7 @@ class AgentRuntime {
               }
             });
           } catch (error) {
-            this.logger.error("Failed to create action start message:", String(error));
+            this.logger.error({ src: "agent", agentId: this.agentId, action: action.name, error: String(error) }, "Failed to emit action start event");
           }
           let storedCallbackData = [];
           const storageCallback = async (response2) => {
@@ -46736,8 +47346,7 @@ class AgentRuntime {
               }
             });
           } catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            this.logger.error(`Failed to emit ACTION_COMPLETED event for action ${action.name} (${actionId}): ${errorMessage}`);
+            this.logger.error({ src: "agent", agentId: this.agentId, action: action.name, error: error instanceof Error ? error.message : String(error) }, "Failed to emit ACTION_COMPLETED event");
           }
           if (callback) {
             for (const content of storedCallbackData) {
@@ -46775,13 +47384,7 @@ class AgentRuntime {
             }
           };
           await this.createMemory(actionMemory, "messages");
-          this.logger.debug(`Action ${action.name} completed`, JSON.stringify({
-            isLegacyReturn,
-            result: isLegacyReturn ? result : undefined,
-            hasValues: actionResult ? !!actionResult.values : false,
-            hasData: actionResult ? !!actionResult.data : false,
-            hasText: actionResult ? !!actionResult.text : false
-          }));
+          this.logger.debug({ src: "agent", agentId: this.agentId, action: action.name }, "Action completed");
           await this.adapter.log({
             entityId: message.entityId,
             roomId: message.roomId,
@@ -46808,7 +47411,7 @@ class AgentRuntime {
           this.currentActionContext = undefined;
         } catch (error) {
           const errorMessage = error instanceof Error ? error.message : String(error);
-          this.logger.error(error);
+          this.logger.error({ src: "agent", agentId: this.agentId, action: action.name, error: errorMessage }, "Action execution failed");
           if (actionPlan && actionPlan.steps[actionIndex]) {
             actionPlan = this.updateActionStep(actionPlan, actionIndex, {
               status: "failed",
@@ -46891,7 +47494,7 @@ class AgentRuntime {
           }
           return null;
         } catch (error) {
-          this.logger.error({ error, evaluatorName: evaluator.name }, `Error validating evaluator ${evaluator.name}`);
+          this.logger.error({ src: "agent", agentId: this.agentId, evaluator: evaluator.name, error: error instanceof Error ? error.message : String(error) }, "Evaluator validation failed");
           return null;
         }
       });
@@ -46918,24 +47521,24 @@ class AgentRuntime {
             });
           }
         } catch (error) {
-          this.logger.error({ error, evaluatorName: evaluator.name }, `Error executing evaluator ${evaluator.name}`);
+          this.logger.error({ src: "agent", agentId: this.agentId, evaluator: evaluator.name, error: error instanceof Error ? error.message : String(error) }, "Evaluator execution failed");
         }
       }));
       return evaluators;
     } catch (error) {
-      this.logger.error({ error, messageId: message.id, roomId: message.roomId }, "Error in evaluate method");
+      this.logger.error({ src: "agent", agentId: this.agentId, messageId: message.id, channelId: message.roomId, error: error instanceof Error ? error.message : String(error) }, "Evaluate method failed");
       return [];
     }
   }
   async ensureConnections(entities, rooms, source, world) {
     if (!entities) {
       console.trace();
-      this.logger.error("ensureConnections - no entities");
+      this.logger.error({ src: "agent", agentId: this.agentId }, "ensureConnections called without entities");
       return;
     }
     if (!rooms || rooms.length === 0) {
       console.trace();
-      this.logger.error("ensureConnections - no rooms");
+      this.logger.error({ src: "agent", agentId: this.agentId }, "ensureConnections called without rooms");
       return;
     }
     await this.ensureWorldExists({ ...world, agentId: this.agentId });
@@ -46957,7 +47560,7 @@ class AgentRuntime {
       agentId: this.agentId
     };
     if (roomsToCreate.length) {
-      this.logger.debug("runtime/ensureConnections - create", roomsToCreate.length.toLocaleString(), "rooms");
+      this.logger.debug({ src: "agent", agentId: this.agentId, count: roomsToCreate.length }, "Creating rooms");
       const roomObjsToCreate = rooms.filter((r2) => roomsToCreate.includes(r2.id)).map((r2) => ({ ...r2, ...rf }));
       await this.createRooms(roomObjsToCreate);
     }
@@ -46975,7 +47578,7 @@ class AgentRuntime {
       messageServerId: world.messageServerId
     };
     if (entitiesToCreate.length) {
-      this.logger.debug("runtime/ensureConnections - creating", entitiesToCreate.length.toLocaleString(), "entities...");
+      this.logger.debug({ src: "agent", agentId: this.agentId, count: entitiesToCreate.length }, "Creating entities");
       const ef = {
         ...r,
         ...wf,
@@ -46993,13 +47596,13 @@ class AgentRuntime {
     const entityIdsInFirstRoomFiltered = entityIdsInFirstRoom.filter(Boolean);
     const missingIdsInRoom = entityIds.filter((id) => !entityIdsInFirstRoomFiltered.includes(id));
     if (missingIdsInRoom.length) {
-      this.logger.debug("runtime/ensureConnections - Missing", missingIdsInRoom.length.toLocaleString(), "connections in", firstRoom.id);
+      this.logger.debug({ src: "agent", agentId: this.agentId, count: missingIdsInRoom.length, channelId: firstRoom.id }, "Adding missing participants");
       const batches = chunkArray(missingIdsInRoom, 5000);
       for (const batch of batches) {
         await this.addParticipantsRoom(batch, firstRoom.id);
       }
     }
-    this.logger.success(`Success: Successfully connected world`);
+    this.logger.success({ src: "agent", agentId: this.agentId, worldId: world.id }, "World connected");
   }
   async ensureConnection({
     entityId,
@@ -47037,13 +47640,13 @@ class AgentRuntime {
             agentId: this.agentId
           });
           if (success) {
-            this.logger.debug(`Created new entity ${entityId} for user ${name || userName || "unknown"}`);
+            this.logger.debug({ src: "agent", agentId: this.agentId, entityId, userName: name || userName }, "Entity created");
           } else {
             throw new Error(`Failed to create entity ${entityId}`);
           }
         } catch (error) {
           if (error.message?.includes("duplicate key") || error.code === "23505") {
-            this.logger.debug(`Entity ${entityId} exists in database but not for this agent. This is normal in multi-agent setups.`);
+            this.logger.debug({ src: "agent", agentId: this.agentId, entityId }, "Entity exists in database (multi-agent setup)");
           } else {
             throw error;
           }
@@ -47088,22 +47691,22 @@ class AgentRuntime {
           if (!added) {
             throw new Error(`Failed to add participant ${entityId} to room ${roomId}`);
           }
-          this.logger.debug(`Added participant ${entityId} to room ${roomId} directly`);
+          this.logger.debug({ src: "agent", agentId: this.agentId, entityId, channelId: roomId }, "Participant added");
         } else {
           throw error;
         }
       }
       await this.ensureParticipantInRoom(this.agentId, roomId);
-      this.logger.debug(`Success: Successfully connected entity ${entityId} in room ${roomId}`);
+      this.logger.debug({ src: "agent", agentId: this.agentId, entityId, channelId: roomId }, "Entity connected");
     } catch (error) {
-      this.logger.error(`Failed to ensure connection: ${error instanceof Error ? error.message : String(error)}`);
+      this.logger.error({ src: "agent", agentId: this.agentId, entityId, channelId: roomId, error: error instanceof Error ? error.message : String(error) }, "Connection setup failed");
       throw error;
     }
   }
   async ensureParticipantInRoom(entityId, roomId) {
     const entity = await this.getEntityById(entityId);
     if (!entity && entityId !== this.agentId) {
-      this.logger.warn(`Entity ${entityId} not directly accessible to agent ${this.agentId}. Will attempt to add as participant anyway.`);
+      this.logger.warn({ src: "agent", agentId: this.agentId, entityId }, "Entity not accessible, attempting to add as participant");
     } else if (!entity && entityId === this.agentId) {
       throw new Error(`Agent entity ${entityId} not found, cannot add as participant.`);
     } else if (!entity) {
@@ -47116,9 +47719,9 @@ class AgentRuntime {
         throw new Error(`Failed to add participant ${entityId} to room ${roomId}`);
       }
       if (entityId === this.agentId) {
-        this.logger.debug(`Agent ${this.character.name} linked to room ${roomId} successfully.`);
+        this.logger.debug({ src: "agent", agentId: this.agentId, channelId: roomId }, "Agent linked to room");
       } else {
-        this.logger.debug(`User ${entityId} linked to room ${roomId} successfully.`);
+        this.logger.debug({ src: "agent", agentId: this.agentId, entityId, channelId: roomId }, "User linked to room");
       }
     }
   }
@@ -47143,12 +47746,7 @@ class AgentRuntime {
   async ensureWorldExists({ id, name, messageServerId, metadata }) {
     const world = await this.getWorld(id);
     if (!world) {
-      this.logger.debug("Creating world:", JSON.stringify({
-        id,
-        name,
-        messageServerId,
-        agentId: this.agentId
-      }));
+      this.logger.debug({ src: "agent", agentId: this.agentId, worldId: id, name, messageServerId }, "Creating world");
       await this.adapter.createWorld({
         id,
         name,
@@ -47156,7 +47754,7 @@ class AgentRuntime {
         messageServerId,
         metadata
       });
-      this.logger.debug(`World ${id} created successfully.`);
+      this.logger.debug({ src: "agent", agentId: this.agentId, worldId: id, messageServerId }, "World created");
     }
   }
   async ensureRoomExists({
@@ -47184,7 +47782,7 @@ class AgentRuntime {
         worldId,
         metadata
       });
-      this.logger.debug(`Room ${id} created successfully.`);
+      this.logger.debug({ src: "agent", agentId: this.agentId, channelId: id }, "Room created");
     }
   }
   async composeState(message, includeList = null, onlyInclude = false, skipCache = false) {
@@ -47211,7 +47809,7 @@ class AgentRuntime {
         const result = await provider.get(this, message, cachedState);
         const duration = Date.now() - start;
         if (duration > 100) {
-          this.logger.debug(`${provider.name} Provider took ${duration}ms to respond`);
+          this.logger.debug({ src: "agent", agentId: this.agentId, provider: provider.name, duration }, "Slow provider");
         }
         return {
           ...result,
@@ -47269,7 +47867,7 @@ class AgentRuntime {
   getService(serviceName) {
     const serviceInstances = this.services.get(serviceName);
     if (!serviceInstances || serviceInstances.length === 0) {
-      this.logger.debug(`Service ${serviceName} not found`);
+      this.logger.debug({ src: "agent", agentId: this.agentId, serviceName }, "Service not found");
       return null;
     }
     return serviceInstances[0];
@@ -47280,7 +47878,7 @@ class AgentRuntime {
   getServicesByType(serviceName) {
     const serviceInstances = this.services.get(serviceName);
     if (!serviceInstances || serviceInstances.length === 0) {
-      this.logger.debug(`No services found for type ${serviceName}`);
+      this.logger.debug({ src: "agent", agentId: this.agentId, serviceName }, "No services found for type");
       return [];
     }
     return serviceInstances;
@@ -47319,13 +47917,13 @@ class AgentRuntime {
     const serviceType = serviceDef.serviceType;
     const serviceName = serviceDef.name || "Unknown";
     if (!serviceType) {
-      this.logger.warn(`Service ${serviceName} is missing serviceType. Please define a static serviceType property.`);
+      this.logger.warn({ src: "agent", agentId: this.agentId, serviceName }, "Service missing serviceType property");
       return;
     }
-    this.logger.info(`Registering service: ${serviceType}`);
+    this.logger.debug({ src: "agent", agentId: this.agentId, serviceType }, "Registering service");
     this.serviceRegistrationStatus.set(serviceType, "registering");
     try {
-      this.logger.debug(`Service ${serviceType} waiting for initialization...`);
+      this.logger.debug({ src: "agent", agentId: this.agentId, serviceType }, "Service waiting for init");
       const initTimeout = new Promise((_, reject) => {
         setTimeout(() => {
           reject(new Error(`Service ${serviceType} registration timed out waiting for runtime initialization (30s timeout)`));
@@ -47352,17 +47950,20 @@ class AgentRuntime {
         handler.resolve(serviceInstance);
         this.servicePromiseHandlers.delete(serviceType);
       } else {
-        this.logger.debug(`${this.character.name} - Service ${serviceType} has no servicePromiseHandler`);
+        this.logger.debug({ src: "agent", agentId: this.agentId, serviceType }, "Service has no promise handler");
       }
       if (typeof serviceDef.registerSendHandlers === "function") {
         serviceDef.registerSendHandlers(this, serviceInstance);
       }
       this.serviceRegistrationStatus.set(serviceType, "registered");
-      this.logger.info(`Service ${serviceType} registered successfully`);
+      this.logger.debug({ src: "agent", agentId: this.agentId, serviceType }, "Service registered");
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
       const errorStack = error instanceof Error ? error.stack : undefined;
-      this.logger.error(`Failed to register service ${serviceType}: ${errorMessage}`);
+      this.logger.error({ src: "agent", agentId: this.agentId, serviceType, error: errorMessage }, "Service registration failed");
+      if (errorStack) {
+        this.logger.debug({ src: "agent", agentId: this.agentId, serviceType, stack: errorStack }, "Service error stack");
+      }
       if (error?.message?.includes("timed out waiting for runtime initialization")) {
         this.logger.error(`Service ${serviceType} failed due to runtime initialization timeout. Check if runtime.initialize() is being called and completing successfully.`);
       } else if (error?.message?.includes("Not implemented")) {
@@ -47373,10 +47974,10 @@ class AgentRuntime {
       } else if (error?.message?.includes("Service") && error?.message?.includes("failed to start")) {
         this.logger.error(`Service ${serviceType} (${serviceName}) failed to start. Check service implementation and dependencies.`);
       } else if (error?.message?.includes("does not have a static start method")) {
-        this.logger.error(`Service ${serviceType} (${serviceName}) is missing required static start() method implementation.`);
+        this.logger.error({ src: "agent", agentId: this.agentId, serviceType, serviceName, error: error?.message }, "Service missing required static start() method implementation");
       } else {
         if (errorStack) {
-          this.logger.debug(`Service ${serviceType} (${serviceName}) error stack: ${errorStack}`);
+          this.logger.debug({ src: "agent", agentId: this.agentId, serviceType, serviceName, stack: errorStack }, "Service error stack");
         }
       }
       this.serviceRegistrationStatus.set(serviceType, "failed");
@@ -47440,13 +48041,13 @@ class AgentRuntime {
     if (provider) {
       const modelWithProvider = models.find((m) => m.provider === provider);
       if (modelWithProvider) {
-        this.logger.debug(`[AgentRuntime][${this.character.name}] Using model ${modelKey} from provider ${provider}`);
+        this.logger.debug({ src: "agent", agentId: this.agentId, model: modelKey, provider }, "Using model");
         return modelWithProvider.handler;
       } else {
-        this.logger.warn(`[AgentRuntime][${this.character.name}] No model found for provider ${provider}`);
+        this.logger.warn({ src: "agent", agentId: this.agentId, model: modelKey, provider }, "Model provider not found");
       }
     }
-    this.logger.debug(`[AgentRuntime][${this.character.name}] Using model ${modelKey} from provider ${models[0].provider}`);
+    this.logger.debug({ src: "agent", agentId: this.agentId, model: modelKey, provider: models[0].provider }, "Using model");
     return models[0].handler;
   }
   getModelSettings(modelType) {
@@ -47525,8 +48126,7 @@ class AgentRuntime {
       ModelType.VIDEO
     ];
     if (!binaryModels.includes(modelKey)) {
-      this.logger.debug(`[useModel] ${modelKey} input: ` + JSON.stringify(params, safeReplacer(), 2).replace(/\\n/g, `
-`));
+      this.logger.trace({ src: "agent", agentId: this.agentId, model: modelKey, params }, "Model input");
     } else {
       let sizeInfo = "unknown size";
       if (Buffer.isBuffer(params)) {
@@ -47540,7 +48140,7 @@ class AgentRuntime {
           sizeInfo = `${params.audio.size} bytes`;
         }
       }
-      this.logger.debug(`[useModel] ${modelKey} input: <binary data: ${sizeInfo}>`);
+      this.logger.trace({ src: "agent", agentId: this.agentId, model: modelKey, size: sizeInfo }, "Model input (binary)");
     }
     let modelParams;
     if (params === null || params === undefined || typeof params !== "object" || Array.isArray(params) || BufferUtils.isBuffer(params)) {
@@ -47565,8 +48165,7 @@ class AgentRuntime {
     try {
       const response = await model(this, modelParams);
       const elapsedTime = (typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now()) - startTime;
-      this.logger.debug(`[useModel] ${modelKey} output (took ${Number(elapsedTime.toFixed(2)).toLocaleString()}ms):`, Array.isArray(response) ? `${JSON.stringify(response.slice(0, 5))}...${JSON.stringify(response.slice(-5))} (${response.length} items)` : JSON.stringify(response, safeReplacer(), 2).replace(/\\n/g, `
-`));
+      this.logger.trace({ src: "agent", agentId: this.agentId, model: modelKey, duration: Number(elapsedTime.toFixed(2)) }, "Model output");
       if (modelKey !== ModelType.TEXT_EMBEDDING && promptContent) {
         if (this.currentActionContext) {
           this.currentActionContext.prompts.push({
@@ -47681,36 +48280,33 @@ ${input}`;
         }
         await Promise.all(eventHandlers.map((handler) => handler(paramsWithRuntime)));
       } catch (error) {
-        this.logger.error(`Error during emitEvent for ${eventName} (handler execution): ${error}`);
+        this.logger.error({ src: "agent", agentId: this.agentId, eventName, error: error instanceof Error ? error.message : String(error) }, "Event handler failed");
       }
     }
   }
   async ensureEmbeddingDimension() {
-    this.logger.debug(`[AgentRuntime][${this.character.name}] Starting ensureEmbeddingDimension`);
     if (!this.adapter) {
-      throw new Error(`[AgentRuntime][${this.character.name}] Database adapter not initialized before ensureEmbeddingDimension`);
+      throw new Error("Database adapter not initialized before ensureEmbeddingDimension");
     }
     try {
       const model = this.getModel(ModelType.TEXT_EMBEDDING);
       if (!model) {
-        throw new Error(`[AgentRuntime][${this.character.name}] No TEXT_EMBEDDING model registered`);
+        throw new Error("No TEXT_EMBEDDING model registered");
       }
-      this.logger.debug(`[AgentRuntime][${this.character.name}] Getting embedding dimensions`);
       const embedding = await this.useModel(ModelType.TEXT_EMBEDDING, null);
       if (!embedding || !embedding.length) {
-        throw new Error(`[AgentRuntime][${this.character.name}] Invalid embedding received`);
+        throw new Error("Invalid embedding received");
       }
-      this.logger.debug(`[AgentRuntime][${this.character.name}] Setting embedding dimension: ${embedding.length}`);
       await this.adapter.ensureEmbeddingDimension(embedding.length);
-      this.logger.debug(`[AgentRuntime][${this.character.name}] Successfully set embedding dimension`);
+      this.logger.debug({ src: "agent", agentId: this.agentId, dimension: embedding.length }, "Embedding dimension set");
     } catch (error) {
-      this.logger.debug(`[AgentRuntime][${this.character.name}] Error in ensureEmbeddingDimension: ${error}`);
+      this.logger.error({ src: "agent", agentId: this.agentId, error: error instanceof Error ? error.message : String(error) }, "Embedding dimension setup failed");
       throw error;
     }
   }
   registerTaskWorker(taskHandler) {
     if (this.taskWorkers.has(taskHandler.name)) {
-      this.logger.warn(`Task definition ${taskHandler.name} already registered. Will be overwritten.`);
+      this.logger.warn({ src: "agent", agentId: this.agentId, task: taskHandler.name }, "Task worker already registered, overwriting");
     }
     this.taskWorkers.set(taskHandler.name, taskHandler);
   }
@@ -47772,7 +48368,7 @@ ${input}`;
       if (!refreshedAgent) {
         throw new Error(`Failed to retrieve agent after update: ${agent.id}`);
       }
-      this.logger.debug(`Updated existing agent ${agent.id} on restart (merged ${Object.keys(existingAgent.settings || {}).length} DB settings with ${Object.keys(agent.settings || {}).length} character settings)`);
+      this.logger.debug({ src: "agent", agentId: agent.id }, "Agent updated on restart");
       return refreshedAgent;
     }
     const newAgent = {
@@ -47783,7 +48379,7 @@ ${input}`;
     if (!created) {
       throw new Error(`Failed to create agent: ${agent.id}`);
     }
-    this.logger.debug(`Created new agent ${agent.id}`);
+    this.logger.debug({ src: "agent", agentId: agent.id }, "Agent created");
     return newAgent;
   }
   async getEntityById(entityId) {
@@ -47841,7 +48437,7 @@ ${input}`;
         text: memoryText
       });
     } catch (error) {
-      this.logger.error("Failed to generate embedding:", error);
+      this.logger.error({ src: "agent", agentId: this.agentId, error: error instanceof Error ? error.message : String(error) }, "Embedding generation failed");
       memory.embedding = await this.useModel(ModelType.TEXT_EMBEDDING, null);
     }
     return memory;
@@ -47855,7 +48451,6 @@ ${input}`;
       return;
     }
     if (!memory.content?.text) {
-      this.logger.debug("Skipping embedding generation for memory without text content");
       return;
     }
     await this.emitEvent("EMBEDDING_GENERATION_REQUESTED" /* EMBEDDING_GENERATION_REQUESTED */, {
@@ -47883,7 +48478,7 @@ ${input}`;
         });
         allMemories.push(...memories);
       } catch (error) {
-        this.logger.debug(`Failed to get memories from table ${tableName}: ${error}`);
+        this.logger.debug({ src: "agent", agentId: this.agentId, tableName, error: error instanceof Error ? error.message : String(error) }, "Failed to get memories");
       }
     }
     return allMemories;
@@ -47935,16 +48530,15 @@ ${input}`;
     await this.adapter.deleteManyMemories(memoryIds);
   }
   async clearAllAgentMemories() {
-    this.logger.info(`Clearing all memories for agent ${this.character.name} (${this.agentId})`);
+    this.logger.info({ src: "agent", agentId: this.agentId }, "Clearing all memories");
     const allMemories = await this.getAllMemories();
     const memoryIds = allMemories.map((memory) => memory.id).filter((id) => id !== undefined);
     if (memoryIds.length === 0) {
-      this.logger.info("No memories found to delete");
+      this.logger.debug({ src: "agent", agentId: this.agentId }, "No memories to delete");
       return;
     }
-    this.logger.info(`Found ${memoryIds.length} memories to delete`);
     await this.adapter.deleteManyMemories(memoryIds);
-    this.logger.info(`Successfully cleared all ${memoryIds.length} memories for agent`);
+    this.logger.info({ src: "agent", agentId: this.agentId, count: memoryIds.length }, "Memories cleared");
   }
   async deleteAllMemories(roomId, tableName) {
     await this.adapter.deleteAllMemories(roomId, tableName);
@@ -48117,29 +48711,29 @@ ${input}`;
         message: controlMessage,
         source: "agent"
       });
-      this.logger.debug(`Sent control message: ${action} to room ${roomId}`);
+      this.logger.debug({ src: "agent", agentId: this.agentId, action, channelId: roomId }, "Control message sent");
     } catch (error) {
-      this.logger.error(`Error sending control message: ${error}`);
+      this.logger.error({ src: "agent", agentId: this.agentId, error: error instanceof Error ? error.message : String(error) }, "Control message failed");
     }
   }
   registerSendHandler(source, handler) {
     if (this.sendHandlers.has(source)) {
-      this.logger.warn(`Send handler for source '${source}' already registered. Overwriting.`);
+      this.logger.warn({ src: "agent", agentId: this.agentId, handlerSource: source }, "Send handler already registered, overwriting");
     }
     this.sendHandlers.set(source, handler);
-    this.logger.info(`Registered send handler for source: ${source}`);
+    this.logger.debug({ src: "agent", agentId: this.agentId, handlerSource: source }, "Send handler registered");
   }
   async sendMessageToTarget(target, content) {
     const handler = this.sendHandlers.get(target.source);
     if (!handler) {
       const errorMsg = `No send handler registered for source: ${target.source}`;
-      this.logger.error(errorMsg);
+      this.logger.error({ src: "agent", agentId: this.agentId, handlerSource: target.source }, "Send handler not found");
       throw new Error(errorMsg);
     }
     try {
       await handler(this, target, content);
     } catch (error) {
-      this.logger.error(`Error executing send handler for source ${target.source}:`, error);
+      this.logger.error({ src: "agent", agentId: this.agentId, handlerSource: target.source, error: error instanceof Error ? error.message : String(error) }, "Send handler failed");
       throw error;
     }
   }
@@ -48150,7 +48744,7 @@ ${input}`;
     if (this.adapter && "runMigrations" in this.adapter) {
       await this.adapter.runMigrations(migrationsPaths);
     } else {
-      this.logger.warn("Database adapter does not support migrations.");
+      this.logger.warn({ src: "agent", agentId: this.agentId }, "Database adapter does not support migrations");
     }
   }
   async isReady() {
@@ -48211,8 +48805,8 @@ function getCryptoModule() {
   return require_crypto_browserify();
 }
 function createHash(algorithm) {
-  const crypto = getCryptoModule();
-  const hash = crypto.createHash(algorithm);
+  const crypto2 = getCryptoModule();
+  const hash = crypto2.createHash(algorithm);
   return {
     update(data2) {
       hash.update(data2);
@@ -48227,15 +48821,15 @@ function createCipheriv(algorithm, key, iv) {
   if (algorithm !== "aes-256-cbc") {
     throw new Error(`Unsupported algorithm: ${algorithm}. Only 'aes-256-cbc' is currently supported.`);
   }
-  const crypto = getCryptoModule();
-  return crypto.createCipheriv(algorithm, key, iv);
+  const crypto2 = getCryptoModule();
+  return crypto2.createCipheriv(algorithm, key, iv);
 }
 function createDecipheriv(algorithm, key, iv) {
   if (algorithm !== "aes-256-cbc") {
     throw new Error(`Unsupported algorithm: ${algorithm}. Only 'aes-256-cbc' is currently supported.`);
   }
-  const crypto = getCryptoModule();
-  return crypto.createDecipheriv(algorithm, key, iv);
+  const crypto2 = getCryptoModule();
+  return crypto2.createDecipheriv(algorithm, key, iv);
 }
 
 // src/settings.ts
@@ -48267,7 +48861,7 @@ function getSalt() {
     }
   }
   if (currentEnvSalt === "secretsalt" && !saltErrorLogged) {
-    logger.warn("SECRET_SALT is not set or using default value");
+    logger.warn({ src: "core:settings" }, "SECRET_SALT is not set or using default value");
     saltErrorLogged = true;
   }
   saltCache = {
@@ -48282,15 +48876,12 @@ function clearSaltCache() {
 }
 function encryptStringValue(value, salt) {
   if (value === undefined || value === null) {
-    logger.debug("Attempted to encrypt undefined or null value");
     return value;
   }
   if (typeof value === "boolean" || typeof value === "number") {
-    logger.debug("Value is a boolean or number, returning as is");
     return value;
   }
   if (typeof value !== "string") {
-    logger.debug(`Value is not a string (type: ${typeof value}), returning as is`);
     return value;
   }
   const parts = value.split(":");
@@ -48298,7 +48889,6 @@ function encryptStringValue(value, salt) {
     try {
       const possibleIv = BufferUtils.fromHex(parts[0]);
       if (possibleIv.length === 16) {
-        logger.debug("Value appears to be already encrypted, skipping re-encryption");
         return value;
       }
     } catch (e) {}
@@ -48319,7 +48909,6 @@ function decryptStringValue(value, salt) {
       return value;
     }
     if (typeof value !== "string") {
-      logger.debug(`Value is not a string (type: ${typeof value}), returning as is`);
       return value;
     }
     const parts = value.split(":");
@@ -48329,9 +48918,6 @@ function decryptStringValue(value, salt) {
     const iv = BufferUtils.fromHex(parts[0]);
     const encrypted = parts[1];
     if (iv.length !== 16) {
-      if (iv.length) {
-        logger.debug(`Invalid IV length (${iv.length}) - expected 16 bytes`);
-      }
       return value;
     }
     const key = createHash("sha256").update(salt).digest().slice(0, 32);
@@ -48340,7 +48926,7 @@ function decryptStringValue(value, salt) {
     decrypted += decipher.final("utf8");
     return decrypted;
   } catch (error) {
-    logger.error(`Error decrypting value: ${error}`);
+    logger.error({ src: "core:settings", error }, "Decryption failed");
     return value;
   }
 }
@@ -48372,11 +48958,11 @@ function unsaltWorldSettings(worldSettings, salt) {
   }
   return unsaltedSettings;
 }
-async function updateWorldSettings(runtime, serverId, worldSettings) {
-  const worldId = createUniqueUuid(runtime, serverId);
+async function updateWorldSettings(runtime, serverId2, worldSettings) {
+  const worldId = createUniqueUuid(runtime, serverId2);
   const world = await runtime.getWorld(worldId);
   if (!world) {
-    logger.error(`No world found for server ${serverId}`);
+    logger.error({ src: "core:settings", serverId: serverId2 }, "World not found");
     return false;
   }
   if (!world.metadata) {
@@ -48388,8 +48974,8 @@ async function updateWorldSettings(runtime, serverId, worldSettings) {
   await runtime.updateWorld(world);
   return true;
 }
-async function getWorldSettings(runtime, serverId) {
-  const worldId = createUniqueUuid(runtime, serverId);
+async function getWorldSettings(runtime, serverId2) {
+  const worldId = createUniqueUuid(runtime, serverId2);
   const world = await runtime.getWorld(worldId);
   if (!world || !world.metadata?.settings) {
     return null;
@@ -48400,7 +48986,7 @@ async function getWorldSettings(runtime, serverId) {
 }
 async function initializeOnboarding(runtime, world, config) {
   if (world.metadata?.settings) {
-    logger.info(`Onboarding state already exists for server ${world.messageServerId}`);
+    logger.debug({ src: "core:settings", serverId: world.messageServerId }, "Onboarding state already exists");
     const saltedSettings = world.metadata.settings;
     const salt = getSalt();
     return unsaltWorldSettings(saltedSettings, salt);
@@ -48416,7 +49002,7 @@ async function initializeOnboarding(runtime, world, config) {
   }
   world.metadata.settings = worldSettings;
   await runtime.updateWorld(world);
-  logger.info(`Initialized settings config for server ${world.messageServerId}`);
+  logger.info({ src: "core:settings", serverId: world.messageServerId }, "Settings config initialized");
   return worldSettings;
 }
 function encryptedCharacter(character) {
@@ -48533,30 +49119,30 @@ function isAutoInstallAllowed() {
 async function tryInstallPlugin(pluginName) {
   try {
     if (!isAutoInstallAllowed()) {
-      logger.debug(`Auto-install disabled or not allowed in this environment. Skipping install for ${pluginName}.`);
+      logger.debug({ src: "core:plugin", pluginName }, "Auto-install disabled, skipping");
       return false;
     }
     if (attemptedInstalls.has(pluginName)) {
-      logger.debug(`Auto-install already attempted for ${pluginName}. Skipping.`);
+      logger.debug({ src: "core:plugin", pluginName }, "Auto-install already attempted, skipping");
       return false;
     }
     attemptedInstalls.add(pluginName);
     if (typeof Bun === "undefined" || typeof Bun.spawn !== "function") {
-      logger.warn(`Bun runtime not available. Cannot auto-install ${pluginName}. Please run: bun add ${pluginName}`);
+      logger.warn({ src: "core:plugin", pluginName }, "Bun runtime not available, cannot auto-install");
       return false;
     }
     try {
       const check = Bun.spawn(["bun", "--version"], { stdout: "pipe", stderr: "pipe" });
       const code = await check.exited;
       if (code !== 0) {
-        logger.warn(`Bun not available on PATH. Cannot auto-install ${pluginName}. Please run: bun add ${pluginName}`);
+        logger.warn({ src: "core:plugin", pluginName }, "Bun not available on PATH, cannot auto-install");
         return false;
       }
     } catch {
-      logger.warn(`Bun not available on PATH. Cannot auto-install ${pluginName}. Please run: bun add ${pluginName}`);
+      logger.warn({ src: "core:plugin", pluginName }, "Bun not available on PATH, cannot auto-install");
       return false;
     }
-    logger.info(`Attempting to auto-install missing plugin: ${pluginName}`);
+    logger.info({ src: "core:plugin", pluginName }, "Auto-installing missing plugin");
     const install = Bun.spawn(["bun", "add", pluginName], {
       cwd: process.cwd(),
       env: process.env,
@@ -48565,14 +49151,14 @@ async function tryInstallPlugin(pluginName) {
     });
     const exit = await install.exited;
     if (exit === 0) {
-      logger.info(`Successfully installed ${pluginName}. Retrying import...`);
+      logger.info({ src: "core:plugin", pluginName }, "Plugin installed, retrying import");
       return true;
     }
-    logger.error(`bun add ${pluginName} failed with exit code ${exit}. Please install manually.`);
+    logger.error({ src: "core:plugin", pluginName, exitCode: exit }, "Plugin installation failed");
     return false;
   } catch (e) {
     const message = e instanceof Error ? e.message : String(e);
-    logger.error(`Unexpected error during auto-install of ${pluginName}: ${message}`);
+    logger.error({ src: "core:plugin", pluginName, error: message }, "Unexpected error during auto-install");
     return false;
   }
 }
@@ -48633,7 +49219,7 @@ async function loadAndPreparePlugin(pluginName) {
     try {
       pluginModule = await import(pluginName);
     } catch (error) {
-      logger.warn(`Failed to load plugin ${pluginName}: ${error}`);
+      logger.warn({ src: "core:plugin", pluginName, error }, "Failed to load plugin");
       const attempted = await tryInstallPlugin(pluginName);
       if (!attempted) {
         return null;
@@ -48641,12 +49227,12 @@ async function loadAndPreparePlugin(pluginName) {
       try {
         pluginModule = await import(pluginName);
       } catch (secondError) {
-        logger.error(`Auto-install attempted for ${pluginName} but import still failed: ${secondError}`);
+        logger.error({ src: "core:plugin", pluginName, error: secondError }, "Import failed after auto-install");
         return null;
       }
     }
     if (!pluginModule) {
-      logger.error(`Failed to load module for plugin ${pluginName}.`);
+      logger.error({ src: "core:plugin", pluginName }, "Failed to load plugin module");
       return null;
     }
     const expectedFunctionName = `${pluginName.replace(/^@elizaos\/plugin-/, "").replace(/^@elizaos\//, "").replace(/-./g, (match) => match[1].toUpperCase())}Plugin`;
@@ -48667,14 +49253,14 @@ async function loadAndPreparePlugin(pluginName) {
             return produced;
           }
         } catch (err) {
-          logger.debug(`Factory export threw for ${pluginName}: ${err}`);
+          logger.debug({ src: "core:plugin", pluginName, error: err }, "Factory export threw");
         }
       }
     }
-    logger.warn(`Could not find a valid plugin export in ${pluginName}.`);
+    logger.warn({ src: "core:plugin", pluginName }, "No valid plugin export found");
     return null;
   } catch (error) {
-    logger.error(`Error loading plugin ${pluginName}: ${error}`);
+    logger.error({ src: "core:plugin", pluginName, error }, "Error loading plugin");
     return null;
   }
 }
@@ -48709,7 +49295,7 @@ function resolvePluginDependencies(availablePlugins, isTestMode = false) {
       const normalizedName = normalizePluginName(pluginName);
       const pluginByNormalized = lookupMap.get(normalizedName);
       if (!pluginByNormalized) {
-        logger.warn(`Plugin dependency "${pluginName}" not found and will be skipped.`);
+        logger.warn({ src: "core:plugin", pluginName }, "Plugin dependency not found, skipping");
         return;
       }
       return visit(pluginByNormalized.name);
@@ -48718,7 +49304,7 @@ function resolvePluginDependencies(availablePlugins, isTestMode = false) {
     if (visited.has(canonicalName))
       return;
     if (visiting.has(canonicalName)) {
-      logger.error(`Circular dependency detected involving plugin: ${canonicalName}`);
+      logger.error({ src: "core:plugin", pluginName: canonicalName }, "Circular dependency detected");
       return;
     }
     visiting.add(canonicalName);
@@ -48746,7 +49332,7 @@ function resolvePluginDependencies(availablePlugins, isTestMode = false) {
     }
     return null;
   }).filter((p) => Boolean(p));
-  logger.info({ plugins: finalPlugins.map((p) => p.name) }, `Final plugins being loaded:`);
+  logger.debug({ src: "core:plugin", plugins: finalPlugins.map((p) => p.name) }, "Plugins resolved");
   return finalPlugins;
 }
 async function loadPlugin(nameOrPlugin) {
@@ -48755,7 +49341,7 @@ async function loadPlugin(nameOrPlugin) {
   }
   const validation = validatePlugin(nameOrPlugin);
   if (!validation.isValid) {
-    logger.error(`Invalid plugin provided: ${validation.errors.join(", ")}`);
+    logger.error({ src: "core:plugin", errors: validation.errors }, "Invalid plugin provided");
     return null;
   }
   return nameOrPlugin;
@@ -48800,7 +49386,8 @@ async function resolvePlugins(plugins, isTestMode = false) {
   }
   const pluginObjects = plugins.filter((p) => typeof p !== "string");
   if (plugins.some((p) => typeof p === "string")) {
-    logger.warn("Browser environment: String plugin references are not supported. Only Plugin objects will be used. Skipped plugins: " + plugins.filter((p) => typeof p === "string").join(", "));
+    const skippedPlugins = plugins.filter((p) => typeof p === "string");
+    logger.warn({ src: "core:plugin", skippedPlugins }, "Browser environment: String plugin references not supported");
   }
   const pluginMap = new Map;
   for (const plugin of pluginObjects) {
@@ -49158,7 +49745,7 @@ async function getRecentInteractions(runtime, sourceEntityId, candidateEntities,
 async function findEntityByName(runtime, message, state) {
   const room = state.data.room ?? await runtime.getRoom(message.roomId);
   if (!room) {
-    logger.warn("Room not found for entity search");
+    logger.warn({ src: "core:entities", roomId: message.roomId }, "Room not found for entity search");
     return null;
   }
   const world = room.worldId ? await runtime.getWorld(room.worldId) : null;
@@ -49209,7 +49796,7 @@ async function findEntityByName(runtime, message, state) {
   });
   const resolution = parseKeyValueXml(result);
   if (!resolution) {
-    logger.warn("Failed to parse entity resolution result");
+    logger.warn({ src: "core:entities" }, "Failed to parse entity resolution result");
     return null;
   }
   if (resolution.type === "EXACT_MATCH" && resolution.entityId) {
@@ -49480,5 +50067,5 @@ export {
   AgentRuntime
 };
 
-//# debugId=A1412E5E5FDE737964756E2164756E21
+//# debugId=019277DAE9D708DD64756E2164756E21
 //# sourceMappingURL=index.node.js.map