@elizaos/core 1.6.5-alpha.9 → 1.6.5

package/dist/node/index.node.js

@@ -1438,295 +1438,6 @@ var require_dist2 = __commonJS((exports) => {
   }
 });
 
-// ../../node_modules/retry/lib/retry_operation.js
-var require_retry_operation = __commonJS((exports, module) => {
-  function RetryOperation(timeouts, options) {
-    if (typeof options === "boolean") {
-      options = { forever: options };
-    }
-    this._originalTimeouts = JSON.parse(JSON.stringify(timeouts));
-    this._timeouts = timeouts;
-    this._options = options || {};
-    this._maxRetryTime = options && options.maxRetryTime || Infinity;
-    this._fn = null;
-    this._errors = [];
-    this._attempts = 1;
-    this._operationTimeout = null;
-    this._operationTimeoutCb = null;
-    this._timeout = null;
-    this._operationStart = null;
-    this._timer = null;
-    if (this._options.forever) {
-      this._cachedTimeouts = this._timeouts.slice(0);
-    }
-  }
-  module.exports = RetryOperation;
-  RetryOperation.prototype.reset = function() {
-    this._attempts = 1;
-    this._timeouts = this._originalTimeouts.slice(0);
-  };
-  RetryOperation.prototype.stop = function() {
-    if (this._timeout) {
-      clearTimeout(this._timeout);
-    }
-    if (this._timer) {
-      clearTimeout(this._timer);
-    }
-    this._timeouts = [];
-    this._cachedTimeouts = null;
-  };
-  RetryOperation.prototype.retry = function(err) {
-    if (this._timeout) {
-      clearTimeout(this._timeout);
-    }
-    if (!err) {
-      return false;
-    }
-    var currentTime = new Date().getTime();
-    if (err && currentTime - this._operationStart >= this._maxRetryTime) {
-      this._errors.push(err);
-      this._errors.unshift(new Error("RetryOperation timeout occurred"));
-      return false;
-    }
-    this._errors.push(err);
-    var timeout = this._timeouts.shift();
-    if (timeout === undefined) {
-      if (this._cachedTimeouts) {
-        this._errors.splice(0, this._errors.length - 1);
-        timeout = this._cachedTimeouts.slice(-1);
-      } else {
-        return false;
-      }
-    }
-    var self2 = this;
-    this._timer = setTimeout(function() {
-      self2._attempts++;
-      if (self2._operationTimeoutCb) {
-        self2._timeout = setTimeout(function() {
-          self2._operationTimeoutCb(self2._attempts);
-        }, self2._operationTimeout);
-        if (self2._options.unref) {
-          self2._timeout.unref();
-        }
-      }
-      self2._fn(self2._attempts);
-    }, timeout);
-    if (this._options.unref) {
-      this._timer.unref();
-    }
-    return true;
-  };
-  RetryOperation.prototype.attempt = function(fn, timeoutOps) {
-    this._fn = fn;
-    if (timeoutOps) {
-      if (timeoutOps.timeout) {
-        this._operationTimeout = timeoutOps.timeout;
-      }
-      if (timeoutOps.cb) {
-        this._operationTimeoutCb = timeoutOps.cb;
-      }
-    }
-    var self2 = this;
-    if (this._operationTimeoutCb) {
-      this._timeout = setTimeout(function() {
-        self2._operationTimeoutCb();
-      }, self2._operationTimeout);
-    }
-    this._operationStart = new Date().getTime();
-    this._fn(this._attempts);
-  };
-  RetryOperation.prototype.try = function(fn) {
-    console.log("Using RetryOperation.try() is deprecated");
-    this.attempt(fn);
-  };
-  RetryOperation.prototype.start = function(fn) {
-    console.log("Using RetryOperation.start() is deprecated");
-    this.attempt(fn);
-  };
-  RetryOperation.prototype.start = RetryOperation.prototype.try;
-  RetryOperation.prototype.errors = function() {
-    return this._errors;
-  };
-  RetryOperation.prototype.attempts = function() {
-    return this._attempts;
-  };
-  RetryOperation.prototype.mainError = function() {
-    if (this._errors.length === 0) {
-      return null;
-    }
-    var counts = {};
-    var mainError = null;
-    var mainErrorCount = 0;
-    for (var i = 0;i < this._errors.length; i++) {
-      var error = this._errors[i];
-      var message = error.message;
-      var count = (counts[message] || 0) + 1;
-      counts[message] = count;
-      if (count >= mainErrorCount) {
-        mainError = error;
-        mainErrorCount = count;
-      }
-    }
-    return mainError;
-  };
-});
-
-// ../../node_modules/retry/lib/retry.js
-var require_retry = __commonJS((exports) => {
-  var RetryOperation = require_retry_operation();
-  exports.operation = function(options) {
-    var timeouts = exports.timeouts(options);
-    return new RetryOperation(timeouts, {
-      forever: options && (options.forever || options.retries === Infinity),
-      unref: options && options.unref,
-      maxRetryTime: options && options.maxRetryTime
-    });
-  };
-  exports.timeouts = function(options) {
-    if (options instanceof Array) {
-      return [].concat(options);
-    }
-    var opts = {
-      retries: 10,
-      factor: 2,
-      minTimeout: 1 * 1000,
-      maxTimeout: Infinity,
-      randomize: false
-    };
-    for (var key in options) {
-      opts[key] = options[key];
-    }
-    if (opts.minTimeout > opts.maxTimeout) {
-      throw new Error("minTimeout is greater than maxTimeout");
-    }
-    var timeouts = [];
-    for (var i = 0;i < opts.retries; i++) {
-      timeouts.push(this.createTimeout(i, opts));
-    }
-    if (options && options.forever && !timeouts.length) {
-      timeouts.push(this.createTimeout(i, opts));
-    }
-    timeouts.sort(function(a, b) {
-      return a - b;
-    });
-    return timeouts;
-  };
-  exports.createTimeout = function(attempt, opts) {
-    var random = opts.randomize ? Math.random() + 1 : 1;
-    var timeout = Math.round(random * Math.max(opts.minTimeout, 1) * Math.pow(opts.factor, attempt));
-    timeout = Math.min(timeout, opts.maxTimeout);
-    return timeout;
-  };
-  exports.wrap = function(obj, options, methods) {
-    if (options instanceof Array) {
-      methods = options;
-      options = null;
-    }
-    if (!methods) {
-      methods = [];
-      for (var key in obj) {
-        if (typeof obj[key] === "function") {
-          methods.push(key);
-        }
-      }
-    }
-    for (var i = 0;i < methods.length; i++) {
-      var method = methods[i];
-      var original = obj[method];
-      obj[method] = function retryWrapper(original2) {
-        var op = exports.operation(options);
-        var args = Array.prototype.slice.call(arguments, 1);
-        var callback = args.pop();
-        args.push(function(err) {
-          if (op.retry(err)) {
-            return;
-          }
-          if (err) {
-            arguments[0] = op.mainError();
-          }
-          callback.apply(this, arguments);
-        });
-        op.attempt(function() {
-          original2.apply(obj, args);
-        });
-      }.bind(obj, original);
-      obj[method].options = options;
-    }
-  };
-});
-
-// ../../node_modules/p-retry/index.js
-var require_p_retry = __commonJS((exports, module) => {
-  var retry = require_retry();
-  var networkErrorMsgs = [
-    "Failed to fetch",
-    "NetworkError when attempting to fetch resource.",
-    "The Internet connection appears to be offline.",
-    "Network request failed"
-  ];
-
-  class AbortError extends Error {
-    constructor(message) {
-      super();
-      if (message instanceof Error) {
-        this.originalError = message;
-        ({ message } = message);
-      } else {
-        this.originalError = new Error(message);
-        this.originalError.stack = this.stack;
-      }
-      this.name = "AbortError";
-      this.message = message;
-    }
-  }
-  var decorateErrorWithCounts = (error, attemptNumber, options) => {
-    const retriesLeft = options.retries - (attemptNumber - 1);
-    error.attemptNumber = attemptNumber;
-    error.retriesLeft = retriesLeft;
-    return error;
-  };
-  var isNetworkError = (errorMessage) => networkErrorMsgs.includes(errorMessage);
-  var pRetry = (input, options) => new Promise((resolve, reject) => {
-    options = {
-      onFailedAttempt: () => {},
-      retries: 10,
-      ...options
-    };
-    const operation = retry.operation(options);
-    operation.attempt(async (attemptNumber) => {
-      try {
-        resolve(await input(attemptNumber));
-      } catch (error) {
-        if (!(error instanceof Error)) {
-          reject(new TypeError(`Non-error was thrown: "${error}". You should only throw errors.`));
-          return;
-        }
-        if (error instanceof AbortError) {
-          operation.stop();
-          reject(error.originalError);
-        } else if (error instanceof TypeError && !isNetworkError(error.message)) {
-          operation.stop();
-          reject(error);
-        } else {
-          decorateErrorWithCounts(error, attemptNumber, options);
-          try {
-            await options.onFailedAttempt(error);
-          } catch (error2) {
-            reject(error2);
-            return;
-          }
-          if (!operation.retry(error)) {
-            reject(operation.mainError());
-          }
-        }
-      }
-    });
-  });
-  module.exports = pRetry;
-  module.exports.default = pRetry;
-  module.exports.AbortError = AbortError;
-});
-
 // ../../node_modules/eventemitter3/index.js
 var require_eventemitter3 = __commonJS((exports, module) => {
   var has = Object.prototype.hasOwnProperty;
@@ -9894,6 +9605,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 +11840,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 +14971,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 +21595,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 +24943,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 +24967,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 +24991,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 +25049,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();
   }
@@ -25032,24 +25267,76 @@ var ModelType = {
 var MODEL_SETTINGS = {
   DEFAULT_MAX_TOKENS: "DEFAULT_MAX_TOKENS",
   DEFAULT_TEMPERATURE: "DEFAULT_TEMPERATURE",
+  DEFAULT_TOP_P: "DEFAULT_TOP_P",
+  DEFAULT_TOP_K: "DEFAULT_TOP_K",
+  DEFAULT_MIN_P: "DEFAULT_MIN_P",
+  DEFAULT_SEED: "DEFAULT_SEED",
+  DEFAULT_REPETITION_PENALTY: "DEFAULT_REPETITION_PENALTY",
   DEFAULT_FREQUENCY_PENALTY: "DEFAULT_FREQUENCY_PENALTY",
   DEFAULT_PRESENCE_PENALTY: "DEFAULT_PRESENCE_PENALTY",
   TEXT_SMALL_MAX_TOKENS: "TEXT_SMALL_MAX_TOKENS",
   TEXT_SMALL_TEMPERATURE: "TEXT_SMALL_TEMPERATURE",
+  TEXT_SMALL_TOP_P: "TEXT_SMALL_TOP_P",
+  TEXT_SMALL_TOP_K: "TEXT_SMALL_TOP_K",
+  TEXT_SMALL_MIN_P: "TEXT_SMALL_MIN_P",
+  TEXT_SMALL_SEED: "TEXT_SMALL_SEED",
+  TEXT_SMALL_REPETITION_PENALTY: "TEXT_SMALL_REPETITION_PENALTY",
   TEXT_SMALL_FREQUENCY_PENALTY: "TEXT_SMALL_FREQUENCY_PENALTY",
   TEXT_SMALL_PRESENCE_PENALTY: "TEXT_SMALL_PRESENCE_PENALTY",
   TEXT_LARGE_MAX_TOKENS: "TEXT_LARGE_MAX_TOKENS",
   TEXT_LARGE_TEMPERATURE: "TEXT_LARGE_TEMPERATURE",
+  TEXT_LARGE_TOP_P: "TEXT_LARGE_TOP_P",
+  TEXT_LARGE_TOP_K: "TEXT_LARGE_TOP_K",
+  TEXT_LARGE_MIN_P: "TEXT_LARGE_MIN_P",
+  TEXT_LARGE_SEED: "TEXT_LARGE_SEED",
+  TEXT_LARGE_REPETITION_PENALTY: "TEXT_LARGE_REPETITION_PENALTY",
   TEXT_LARGE_FREQUENCY_PENALTY: "TEXT_LARGE_FREQUENCY_PENALTY",
   TEXT_LARGE_PRESENCE_PENALTY: "TEXT_LARGE_PRESENCE_PENALTY",
   OBJECT_SMALL_MAX_TOKENS: "OBJECT_SMALL_MAX_TOKENS",
   OBJECT_SMALL_TEMPERATURE: "OBJECT_SMALL_TEMPERATURE",
+  OBJECT_SMALL_TOP_P: "OBJECT_SMALL_TOP_P",
+  OBJECT_SMALL_TOP_K: "OBJECT_SMALL_TOP_K",
+  OBJECT_SMALL_MIN_P: "OBJECT_SMALL_MIN_P",
+  OBJECT_SMALL_SEED: "OBJECT_SMALL_SEED",
+  OBJECT_SMALL_REPETITION_PENALTY: "OBJECT_SMALL_REPETITION_PENALTY",
   OBJECT_SMALL_FREQUENCY_PENALTY: "OBJECT_SMALL_FREQUENCY_PENALTY",
   OBJECT_SMALL_PRESENCE_PENALTY: "OBJECT_SMALL_PRESENCE_PENALTY",
   OBJECT_LARGE_MAX_TOKENS: "OBJECT_LARGE_MAX_TOKENS",
   OBJECT_LARGE_TEMPERATURE: "OBJECT_LARGE_TEMPERATURE",
+  OBJECT_LARGE_TOP_P: "OBJECT_LARGE_TOP_P",
+  OBJECT_LARGE_TOP_K: "OBJECT_LARGE_TOP_K",
+  OBJECT_LARGE_MIN_P: "OBJECT_LARGE_MIN_P",
+  OBJECT_LARGE_SEED: "OBJECT_LARGE_SEED",
+  OBJECT_LARGE_REPETITION_PENALTY: "OBJECT_LARGE_REPETITION_PENALTY",
   OBJECT_LARGE_FREQUENCY_PENALTY: "OBJECT_LARGE_FREQUENCY_PENALTY",
   OBJECT_LARGE_PRESENCE_PENALTY: "OBJECT_LARGE_PRESENCE_PENALTY",
+  TEXT_REASONING_SMALL_MAX_TOKENS: "TEXT_REASONING_SMALL_MAX_TOKENS",
+  TEXT_REASONING_SMALL_TEMPERATURE: "TEXT_REASONING_SMALL_TEMPERATURE",
+  TEXT_REASONING_SMALL_TOP_P: "TEXT_REASONING_SMALL_TOP_P",
+  TEXT_REASONING_SMALL_TOP_K: "TEXT_REASONING_SMALL_TOP_K",
+  TEXT_REASONING_SMALL_MIN_P: "TEXT_REASONING_SMALL_MIN_P",
+  TEXT_REASONING_SMALL_SEED: "TEXT_REASONING_SMALL_SEED",
+  TEXT_REASONING_SMALL_REPETITION_PENALTY: "TEXT_REASONING_SMALL_REPETITION_PENALTY",
+  TEXT_REASONING_SMALL_FREQUENCY_PENALTY: "TEXT_REASONING_SMALL_FREQUENCY_PENALTY",
+  TEXT_REASONING_SMALL_PRESENCE_PENALTY: "TEXT_REASONING_SMALL_PRESENCE_PENALTY",
+  TEXT_REASONING_LARGE_MAX_TOKENS: "TEXT_REASONING_LARGE_MAX_TOKENS",
+  TEXT_REASONING_LARGE_TEMPERATURE: "TEXT_REASONING_LARGE_TEMPERATURE",
+  TEXT_REASONING_LARGE_TOP_P: "TEXT_REASONING_LARGE_TOP_P",
+  TEXT_REASONING_LARGE_TOP_K: "TEXT_REASONING_LARGE_TOP_K",
+  TEXT_REASONING_LARGE_MIN_P: "TEXT_REASONING_LARGE_MIN_P",
+  TEXT_REASONING_LARGE_SEED: "TEXT_REASONING_LARGE_SEED",
+  TEXT_REASONING_LARGE_REPETITION_PENALTY: "TEXT_REASONING_LARGE_REPETITION_PENALTY",
+  TEXT_REASONING_LARGE_FREQUENCY_PENALTY: "TEXT_REASONING_LARGE_FREQUENCY_PENALTY",
+  TEXT_REASONING_LARGE_PRESENCE_PENALTY: "TEXT_REASONING_LARGE_PRESENCE_PENALTY",
+  TEXT_COMPLETION_MAX_TOKENS: "TEXT_COMPLETION_MAX_TOKENS",
+  TEXT_COMPLETION_TEMPERATURE: "TEXT_COMPLETION_TEMPERATURE",
+  TEXT_COMPLETION_TOP_P: "TEXT_COMPLETION_TOP_P",
+  TEXT_COMPLETION_TOP_K: "TEXT_COMPLETION_TOP_K",
+  TEXT_COMPLETION_MIN_P: "TEXT_COMPLETION_MIN_P",
+  TEXT_COMPLETION_SEED: "TEXT_COMPLETION_SEED",
+  TEXT_COMPLETION_REPETITION_PENALTY: "TEXT_COMPLETION_REPETITION_PENALTY",
+  TEXT_COMPLETION_FREQUENCY_PENALTY: "TEXT_COMPLETION_FREQUENCY_PENALTY",
+  TEXT_COMPLETION_PRESENCE_PENALTY: "TEXT_COMPLETION_PRESENCE_PENALTY",
   MODEL_MAX_TOKEN: "MODEL_MAX_TOKEN",
   MODEL_TEMPERATURE: "MODEL_TEMPERATURE",
   MODEL_FREQ_PENALTY: "MODEL_FREQ_PENALTY",
@@ -26036,6 +26323,8 @@ function mergeContent(firstContent, secondContent) {
       return secondContent;
     if (typeof secondContent === "string")
       return firstContent + secondContent;
+    else if (Array.isArray(secondContent) && secondContent.length === 0)
+      return firstContent;
     else if (Array.isArray(secondContent) && secondContent.some((c) => isDataContentBlock(c)))
       return [{
         type: "text",
@@ -26212,9 +26501,10 @@ function _mergeDicts(left = {}, right = {}) {
         "name",
         "output_version",
         "model_provider"
-      ].includes(key))
-        merged[key] = value;
-      else
+      ].includes(key)) {
+        if (value)
+          merged[key] = value;
+      } else
         merged[key] += value;
     else if (typeof merged[key] === "object" && !Array.isArray(merged[key]))
       merged[key] = _mergeDicts(merged[key], value);
@@ -26275,9 +26565,17 @@ Right ${typeof right}`);
 Left ${left}
 Right ${right}`);
 }
-var BaseMessageChunk = class extends BaseMessage {
+var BaseMessageChunk = class BaseMessageChunk2 extends BaseMessage {
   static isInstance(obj) {
-    return super.isInstance(obj) && "concat" in obj && typeof obj.concat === "function";
+    if (!super.isInstance(obj))
+      return false;
+    let proto = Object.getPrototypeOf(obj);
+    while (proto !== null) {
+      if (proto === BaseMessageChunk2.prototype)
+        return true;
+      proto = Object.getPrototypeOf(proto);
+    }
+    return false;
   }
 };
 
@@ -26398,47 +26696,227 @@ function isToolMessageChunk(x) {
 }
 
 // ../../node_modules/@langchain/core/dist/utils/json.js
-function parsePartialJson(s) {
-  if (typeof s === "undefined")
-    return null;
+function strictParsePartialJson(s) {
   try {
     return JSON.parse(s);
   } catch {}
-  let new_s = "";
-  const stack = [];
-  let isInsideString = false;
-  let escaped = false;
-  for (let char of s) {
-    if (isInsideString)
-      if (char === '"' && !escaped)
-        isInsideString = false;
-      else if (char === `
-` && !escaped)
-        char = "\\n";
-      else if (char === "\\")
-        escaped = !escaped;
-      else
+  const buffer = s.trim();
+  if (buffer.length === 0)
+    throw new Error("Unexpected end of JSON input");
+  let pos = 0;
+  function skipWhitespace() {
+    while (pos < buffer.length && /\s/.test(buffer[pos]))
+      pos += 1;
+  }
+  function parseString() {
+    if (buffer[pos] !== '"')
+      throw new Error(`Expected '"' at position ${pos}, got '${buffer[pos]}'`);
+    pos += 1;
+    let result = "";
+    let escaped = false;
+    while (pos < buffer.length) {
+      const char = buffer[pos];
+      if (escaped) {
+        if (char === "n")
+          result += `
+`;
+        else if (char === "t")
+          result += "\t";
+        else if (char === "r")
+          result += "\r";
+        else if (char === "\\")
+          result += "\\";
+        else if (char === '"')
+          result += '"';
+        else if (char === "b")
+          result += "\b";
+        else if (char === "f")
+          result += "\f";
+        else if (char === "/")
+          result += "/";
+        else if (char === "u") {
+          const hex = buffer.substring(pos + 1, pos + 5);
+          if (/^[0-9A-Fa-f]{0,4}$/.test(hex)) {
+            if (hex.length === 4)
+              result += String.fromCharCode(Number.parseInt(hex, 16));
+            else
+              result += `u${hex}`;
+            pos += hex.length;
+          } else
+            throw new Error(`Invalid unicode escape sequence '\\u${hex}' at position ${pos}`);
+        } else
+          throw new Error(`Invalid escape sequence '\\${char}' at position ${pos}`);
         escaped = false;
-    else if (char === '"') {
-      isInsideString = true;
-      escaped = false;
-    } else if (char === "{")
-      stack.push("}");
-    else if (char === "[")
-      stack.push("]");
-    else if (char === "}" || char === "]")
-      if (stack && stack[stack.length - 1] === char)
-        stack.pop();
-      else
-        return null;
-    new_s += char;
+      } else if (char === "\\")
+        escaped = true;
+      else if (char === '"') {
+        pos += 1;
+        return result;
+      } else
+        result += char;
+      pos += 1;
+    }
+    if (escaped)
+      result += "\\";
+    return result;
+  }
+  function parseNumber() {
+    const start = pos;
+    let numStr = "";
+    if (buffer[pos] === "-") {
+      numStr += "-";
+      pos += 1;
+    }
+    if (pos < buffer.length && buffer[pos] === "0") {
+      numStr += "0";
+      pos += 1;
+      if (buffer[pos] >= "0" && buffer[pos] <= "9")
+        throw new Error(`Invalid number at position ${start}`);
+    }
+    if (pos < buffer.length && buffer[pos] >= "1" && buffer[pos] <= "9")
+      while (pos < buffer.length && buffer[pos] >= "0" && buffer[pos] <= "9") {
+        numStr += buffer[pos];
+        pos += 1;
+      }
+    if (pos < buffer.length && buffer[pos] === ".") {
+      numStr += ".";
+      pos += 1;
+      while (pos < buffer.length && buffer[pos] >= "0" && buffer[pos] <= "9") {
+        numStr += buffer[pos];
+        pos += 1;
+      }
+    }
+    if (pos < buffer.length && (buffer[pos] === "e" || buffer[pos] === "E")) {
+      numStr += buffer[pos];
+      pos += 1;
+      if (pos < buffer.length && (buffer[pos] === "+" || buffer[pos] === "-")) {
+        numStr += buffer[pos];
+        pos += 1;
+      }
+      while (pos < buffer.length && buffer[pos] >= "0" && buffer[pos] <= "9") {
+        numStr += buffer[pos];
+        pos += 1;
+      }
+    }
+    if (numStr === "-")
+      return -0;
+    const num = Number.parseFloat(numStr);
+    if (Number.isNaN(num)) {
+      pos = start;
+      throw new Error(`Invalid number '${numStr}' at position ${start}`);
+    }
+    return num;
+  }
+  function parseValue() {
+    skipWhitespace();
+    if (pos >= buffer.length)
+      throw new Error(`Unexpected end of input at position ${pos}`);
+    const char = buffer[pos];
+    if (char === "{")
+      return parseObject();
+    if (char === "[")
+      return parseArray();
+    if (char === '"')
+      return parseString();
+    if ("null".startsWith(buffer.substring(pos, pos + 4))) {
+      pos += Math.min(4, buffer.length - pos);
+      return null;
+    }
+    if ("true".startsWith(buffer.substring(pos, pos + 4))) {
+      pos += Math.min(4, buffer.length - pos);
+      return true;
+    }
+    if ("false".startsWith(buffer.substring(pos, pos + 5))) {
+      pos += Math.min(5, buffer.length - pos);
+      return false;
+    }
+    if (char === "-" || char >= "0" && char <= "9")
+      return parseNumber();
+    throw new Error(`Unexpected character '${char}' at position ${pos}`);
+  }
+  function parseArray() {
+    if (buffer[pos] !== "[")
+      throw new Error(`Expected '[' at position ${pos}, got '${buffer[pos]}'`);
+    const arr = [];
+    pos += 1;
+    skipWhitespace();
+    if (pos >= buffer.length)
+      return arr;
+    if (buffer[pos] === "]") {
+      pos += 1;
+      return arr;
+    }
+    while (pos < buffer.length) {
+      skipWhitespace();
+      if (pos >= buffer.length)
+        return arr;
+      arr.push(parseValue());
+      skipWhitespace();
+      if (pos >= buffer.length)
+        return arr;
+      if (buffer[pos] === "]") {
+        pos += 1;
+        return arr;
+      } else if (buffer[pos] === ",") {
+        pos += 1;
+        continue;
+      }
+      throw new Error(`Expected ',' or ']' at position ${pos}, got '${buffer[pos]}'`);
+    }
+    return arr;
   }
-  if (isInsideString)
-    new_s += '"';
-  for (let i = stack.length - 1;i >= 0; i -= 1)
-    new_s += stack[i];
+  function parseObject() {
+    if (buffer[pos] !== "{")
+      throw new Error(`Expected '{' at position ${pos}, got '${buffer[pos]}'`);
+    const obj = {};
+    pos += 1;
+    skipWhitespace();
+    if (pos >= buffer.length)
+      return obj;
+    if (buffer[pos] === "}") {
+      pos += 1;
+      return obj;
+    }
+    while (pos < buffer.length) {
+      skipWhitespace();
+      if (pos >= buffer.length)
+        return obj;
+      const key = parseString();
+      skipWhitespace();
+      if (pos >= buffer.length)
+        return obj;
+      if (buffer[pos] !== ":")
+        throw new Error(`Expected ':' at position ${pos}, got '${buffer[pos]}'`);
+      pos += 1;
+      skipWhitespace();
+      if (pos >= buffer.length)
+        return obj;
+      obj[key] = parseValue();
+      skipWhitespace();
+      if (pos >= buffer.length)
+        return obj;
+      if (buffer[pos] === "}") {
+        pos += 1;
+        return obj;
+      } else if (buffer[pos] === ",") {
+        pos += 1;
+        continue;
+      }
+      throw new Error(`Expected ',' or '}' at position ${pos}, got '${buffer[pos]}'`);
+    }
+    return obj;
+  }
+  const value = parseValue();
+  skipWhitespace();
+  if (pos < buffer.length)
+    throw new Error(`Unexpected character '${buffer[pos]}' at position ${pos}`);
+  return value;
+}
+function parsePartialJson(s) {
   try {
-    return JSON.parse(new_s);
+    if (typeof s === "undefined")
+      return null;
+    return strictParsePartialJson(s);
   } catch {
     return null;
   }
@@ -26911,59 +27389,12 @@ var AIMessageChunk = class extends BaseMessageChunk {
         tool_call_chunks: [],
         usage_metadata: fields.usage_metadata !== undefined ? fields.usage_metadata : undefined
       };
-    else {
-      const toolCallChunks = fields.tool_call_chunks ?? [];
-      const groupedToolCallChunks = toolCallChunks.reduce((acc, chunk) => {
-        const matchedChunkIndex = acc.findIndex(([match]) => {
-          if ("id" in chunk && chunk.id && "index" in chunk && chunk.index !== undefined)
-            return chunk.id === match.id && chunk.index === match.index;
-          if ("id" in chunk && chunk.id)
-            return chunk.id === match.id;
-          if ("index" in chunk && chunk.index !== undefined)
-            return chunk.index === match.index;
-          return false;
-        });
-        if (matchedChunkIndex !== -1)
-          acc[matchedChunkIndex].push(chunk);
-        else
-          acc.push([chunk]);
-        return acc;
-      }, []);
-      const toolCalls = [];
-      const invalidToolCalls = [];
-      for (const chunks of groupedToolCallChunks) {
-        let parsedArgs = null;
-        const name = chunks[0]?.name ?? "";
-        const joinedArgs = chunks.map((c) => c.args || "").join("");
-        const argsStr = joinedArgs.length ? joinedArgs : "{}";
-        const id = chunks[0]?.id;
-        try {
-          parsedArgs = parsePartialJson(argsStr);
-          if (!id || parsedArgs === null || typeof parsedArgs !== "object" || Array.isArray(parsedArgs))
-            throw new Error("Malformed tool call chunk args.");
-          toolCalls.push({
-            name,
-            args: parsedArgs,
-            id,
-            type: "tool_call"
-          });
-        } catch {
-          invalidToolCalls.push({
-            name,
-            args: argsStr,
-            id,
-            error: "Malformed args.",
-            type: "invalid_tool_call"
-          });
-        }
-      }
+    else
       initParams = {
         ...fields,
-        tool_calls: toolCalls,
-        invalid_tool_calls: invalidToolCalls,
+        ...collapseToolCallChunks(fields.tool_call_chunks ?? []),
         usage_metadata: fields.usage_metadata !== undefined ? fields.usage_metadata : undefined
       };
-    }
     super(initParams);
     this.tool_call_chunks = initParams.tool_call_chunks ?? this.tool_call_chunks;
     this.tool_calls = initParams.tool_calls ?? this.tool_calls;
@@ -27062,6 +27493,57 @@ function getBufferString(messages, humanPrefix = "Human", aiPrefix = "AI") {
   return string_messages.join(`
 `);
 }
+function collapseToolCallChunks(chunks) {
+  const groupedToolCallChunks = chunks.reduce((acc, chunk) => {
+    const matchedChunkIndex = acc.findIndex(([match]) => {
+      if ("id" in chunk && chunk.id && "index" in chunk && chunk.index !== undefined)
+        return chunk.id === match.id && chunk.index === match.index;
+      if ("id" in chunk && chunk.id)
+        return chunk.id === match.id;
+      if ("index" in chunk && chunk.index !== undefined)
+        return chunk.index === match.index;
+      return false;
+    });
+    if (matchedChunkIndex !== -1)
+      acc[matchedChunkIndex].push(chunk);
+    else
+      acc.push([chunk]);
+    return acc;
+  }, []);
+  const toolCalls = [];
+  const invalidToolCalls = [];
+  for (const chunks$1 of groupedToolCallChunks) {
+    let parsedArgs = null;
+    const name = chunks$1[0]?.name ?? "";
+    const joinedArgs = chunks$1.map((c) => c.args || "").join("").trim();
+    const argsStr = joinedArgs.length ? joinedArgs : "{}";
+    const id = chunks$1[0]?.id;
+    try {
+      parsedArgs = parsePartialJson(argsStr);
+      if (!id || parsedArgs === null || typeof parsedArgs !== "object" || Array.isArray(parsedArgs))
+        throw new Error("Malformed tool call chunk args.");
+      toolCalls.push({
+        name,
+        args: parsedArgs,
+        id,
+        type: "tool_call"
+      });
+    } catch {
+      invalidToolCalls.push({
+        name,
+        args: argsStr,
+        id,
+        error: "Malformed args.",
+        type: "invalid_tool_call"
+      });
+    }
+  }
+  return {
+    tool_call_chunks: chunks,
+    tool_calls: toolCalls,
+    invalid_tool_calls: invalidToolCalls
+  };
+}
 
 // ../../node_modules/@langchain/core/dist/utils/env.js
 var env_exports = {};
@@ -27311,7 +27793,6 @@ function warnOnce(message) {
 
 // ../../node_modules/langsmith/dist/utils/_uuid.js
 var UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-var UUID7_WARNING_EMITTED = false;
 function assertUuid(str, which) {
   if (!UUID_REGEX.test(str)) {
     const msg = which !== undefined ? `Invalid UUID for ${which}: ${str}` : `Invalid UUID: ${str}`;
@@ -27323,22 +27804,8 @@ function uuid7FromTime(timestamp) {
   const msecs = typeof timestamp === "string" ? Date.parse(timestamp) : timestamp;
   return v72({ msecs, seq: 0 });
 }
-function getUuidVersion(uuidStr) {
-  if (!UUID_REGEX.test(uuidStr)) {
-    return null;
-  }
-  const versionChar = uuidStr[14];
-  return parseInt(versionChar, 16);
-}
-function warnIfNotUuidV7(uuidStr, _idType) {
-  const version3 = getUuidVersion(uuidStr);
-  if (version3 !== null && version3 !== 7 && !UUID7_WARNING_EMITTED) {
-    UUID7_WARNING_EMITTED = true;
-    warnOnce(`LangSmith now uses UUID v7 for run and trace identifiers. ` + `This warning appears when passing custom IDs. ` + `Please use: import { uuidv7 } from 'langsmith'; const id = uuidv7(); ` + `Future versions will require UUID v7.`);
-  }
-}
 // ../../node_modules/langsmith/dist/index.js
-var __version__ = "0.3.80";
+var __version__ = "0.3.82";
 
 // ../../node_modules/langsmith/dist/utils/env.js
 var globalEnv;
@@ -27925,10 +28392,213 @@ class LangSmithToOTELTranslator {
   }
 }
 
+// ../../node_modules/langsmith/dist/utils/is-network-error/index.js
+var objectToString = Object.prototype.toString;
+var isError = (value) => objectToString.call(value) === "[object Error]";
+var errorMessages = new Set([
+  "network error",
+  "Failed to fetch",
+  "NetworkError when attempting to fetch resource.",
+  "The Internet connection appears to be offline.",
+  "Network request failed",
+  "fetch failed",
+  "terminated",
+  " A network error occurred.",
+  "Network connection lost"
+]);
+function isNetworkError(error) {
+  const isValid = error && isError(error) && error.name === "TypeError" && typeof error.message === "string";
+  if (!isValid) {
+    return false;
+  }
+  const { message, stack } = error;
+  if (message === "Load failed") {
+    return stack === undefined || "__sentry_captured__" in error;
+  }
+  if (message.startsWith("error sending request for url")) {
+    return true;
+  }
+  return errorMessages.has(message);
+}
+
+// ../../node_modules/langsmith/dist/utils/p-retry/index.js
+function validateRetries(retries) {
+  if (typeof retries === "number") {
+    if (retries < 0) {
+      throw new TypeError("Expected `retries` to be a non-negative number.");
+    }
+    if (Number.isNaN(retries)) {
+      throw new TypeError("Expected `retries` to be a valid number or Infinity, got NaN.");
+    }
+  } else if (retries !== undefined) {
+    throw new TypeError("Expected `retries` to be a number or Infinity.");
+  }
+}
+function validateNumberOption(name, value, { min = 0, allowInfinity = false } = {}) {
+  if (value === undefined) {
+    return;
+  }
+  if (typeof value !== "number" || Number.isNaN(value)) {
+    throw new TypeError(`Expected \`${name}\` to be a number${allowInfinity ? " or Infinity" : ""}.`);
+  }
+  if (!allowInfinity && !Number.isFinite(value)) {
+    throw new TypeError(`Expected \`${name}\` to be a finite number.`);
+  }
+  if (value < min) {
+    throw new TypeError(`Expected \`${name}\` to be ≥ ${min}.`);
+  }
+}
+
+class AbortError extends Error {
+  constructor(message) {
+    super();
+    if (message instanceof Error) {
+      this.originalError = message;
+      ({ message } = message);
+    } else {
+      this.originalError = new Error(message);
+      this.originalError.stack = this.stack;
+    }
+    this.name = "AbortError";
+    this.message = message;
+  }
+}
+function calculateDelay(retriesConsumed, options) {
+  const attempt = Math.max(1, retriesConsumed + 1);
+  const random = options.randomize ? Math.random() + 1 : 1;
+  let timeout = Math.round(random * options.minTimeout * options.factor ** (attempt - 1));
+  timeout = Math.min(timeout, options.maxTimeout);
+  return timeout;
+}
+function calculateRemainingTime(start, max) {
+  if (!Number.isFinite(max)) {
+    return max;
+  }
+  return max - (performance.now() - start);
+}
+async function onAttemptFailure({ error, attemptNumber, retriesConsumed, startTime, options }) {
+  const normalizedError = error instanceof Error ? error : new TypeError(`Non-error was thrown: "${error}". You should only throw errors.`);
+  if (normalizedError instanceof AbortError) {
+    throw normalizedError.originalError;
+  }
+  const retriesLeft = Number.isFinite(options.retries) ? Math.max(0, options.retries - retriesConsumed) : options.retries;
+  const maxRetryTime = options.maxRetryTime ?? Number.POSITIVE_INFINITY;
+  const context = Object.freeze({
+    error: normalizedError,
+    attemptNumber,
+    retriesLeft,
+    retriesConsumed
+  });
+  await options.onFailedAttempt(context);
+  if (calculateRemainingTime(startTime, maxRetryTime) <= 0) {
+    throw normalizedError;
+  }
+  const consumeRetry = await options.shouldConsumeRetry(context);
+  const remainingTime = calculateRemainingTime(startTime, maxRetryTime);
+  if (remainingTime <= 0 || retriesLeft <= 0) {
+    throw normalizedError;
+  }
+  if (normalizedError instanceof TypeError && !isNetworkError(normalizedError)) {
+    if (consumeRetry) {
+      throw normalizedError;
+    }
+    options.signal?.throwIfAborted();
+    return false;
+  }
+  if (!await options.shouldRetry(context)) {
+    throw normalizedError;
+  }
+  if (!consumeRetry) {
+    options.signal?.throwIfAborted();
+    return false;
+  }
+  const delayTime = calculateDelay(retriesConsumed, options);
+  const finalDelay = Math.min(delayTime, remainingTime);
+  if (finalDelay > 0) {
+    await new Promise((resolve, reject) => {
+      const onAbort = () => {
+        clearTimeout(timeoutToken);
+        options.signal?.removeEventListener("abort", onAbort);
+        reject(options.signal.reason);
+      };
+      const timeoutToken = setTimeout(() => {
+        options.signal?.removeEventListener("abort", onAbort);
+        resolve();
+      }, finalDelay);
+      if (options.unref) {
+        timeoutToken.unref?.();
+      }
+      options.signal?.addEventListener("abort", onAbort, { once: true });
+    });
+  }
+  options.signal?.throwIfAborted();
+  return true;
+}
+async function pRetry(input, options = {}) {
+  options = { ...options };
+  validateRetries(options.retries);
+  if (Object.hasOwn(options, "forever")) {
+    throw new Error("The `forever` option is no longer supported. For many use-cases, you can set `retries: Infinity` instead.");
+  }
+  options.retries ??= 10;
+  options.factor ??= 2;
+  options.minTimeout ??= 1000;
+  options.maxTimeout ??= Number.POSITIVE_INFINITY;
+  options.maxRetryTime ??= Number.POSITIVE_INFINITY;
+  options.randomize ??= false;
+  options.onFailedAttempt ??= () => {};
+  options.shouldRetry ??= () => true;
+  options.shouldConsumeRetry ??= () => true;
+  validateNumberOption("factor", options.factor, {
+    min: 0,
+    allowInfinity: false
+  });
+  validateNumberOption("minTimeout", options.minTimeout, {
+    min: 0,
+    allowInfinity: false
+  });
+  validateNumberOption("maxTimeout", options.maxTimeout, {
+    min: 0,
+    allowInfinity: true
+  });
+  validateNumberOption("maxRetryTime", options.maxRetryTime, {
+    min: 0,
+    allowInfinity: true
+  });
+  if (!(options.factor > 0)) {
+    options.factor = 1;
+  }
+  options.signal?.throwIfAborted();
+  let attemptNumber = 0;
+  let retriesConsumed = 0;
+  const startTime = performance.now();
+  while (Number.isFinite(options.retries) ? retriesConsumed <= options.retries : true) {
+    attemptNumber++;
+    try {
+      options.signal?.throwIfAborted();
+      const result = await input(attemptNumber);
+      options.signal?.throwIfAborted();
+      return result;
+    } catch (error) {
+      if (await onAttemptFailure({
+        error,
+        attemptNumber,
+        retriesConsumed,
+        startTime,
+        options
+      })) {
+        retriesConsumed++;
+      }
+    }
+  }
+  throw new Error("Retry attempts exhausted without throwing an error.");
+}
+
 // ../../node_modules/langsmith/dist/utils/async_caller.js
-var import_p_retry = __toESM(require_p_retry(), 1);
 var import_p_queue = __toESM(require_dist3(), 1);
 var STATUS_RETRYABLE = [
+  408,
+  425,
   429,
   500,
   502,
@@ -27998,14 +28668,14 @@ class AsyncCaller {
       this.queueSizeBytes += sizeBytes;
     }
     const onFailedResponseHook = this.onFailedResponseHook;
-    let promise = this.queue.add(() => import_p_retry.default(() => callable(...args).catch((error) => {
+    let promise = this.queue.add(() => pRetry(() => callable(...args).catch((error) => {
       if (error instanceof Error) {
         throw error;
       } else {
         throw new Error(error);
       }
     }), {
-      async onFailedAttempt(error) {
+      async onFailedAttempt({ error }) {
         if (error.message.startsWith("Cancel") || error.message.startsWith("TimeoutError") || error.name === "TimeoutError" || error.message.startsWith("AbortError")) {
           throw error;
         }
@@ -31633,8 +32303,30 @@ var isTracingEnabled = (tracingEnabled) => {
 
 // ../../node_modules/langsmith/dist/singletons/constants.js
 var _LC_CONTEXT_VARIABLES_KEY = Symbol.for("lc:context_variables");
+var _REPLICA_TRACE_ROOTS_KEY = Symbol.for("langsmith:replica_trace_roots");
+
+// ../../node_modules/langsmith/dist/utils/context_vars.js
+function getContextVar(runTree, key) {
+  if (_LC_CONTEXT_VARIABLES_KEY in runTree) {
+    const contextVars = runTree[_LC_CONTEXT_VARIABLES_KEY];
+    return contextVars[key];
+  }
+  return;
+}
+function setContextVar(runTree, key, value) {
+  const contextVars = _LC_CONTEXT_VARIABLES_KEY in runTree ? runTree[_LC_CONTEXT_VARIABLES_KEY] : {};
+  contextVars[key] = value;
+  runTree[_LC_CONTEXT_VARIABLES_KEY] = contextVars;
+}
 
 // ../../node_modules/langsmith/dist/run_trees.js
+var TIMESTAMP_LENGTH = 36;
+var UUID_NAMESPACE_DNS = "6ba7b810-9dad-11d1-80b4-00c04fd430c8";
+function getReplicaKey(replica) {
+  const sortedKeys = Object.keys(replica).sort();
+  const keyData = sortedKeys.map((key) => `${key}:${replica[key] ?? ""}`).join("|");
+  return v52(keyData, UUID_NAMESPACE_DNS);
+}
 function stripNonAlphanumeric(input) {
   return input.replace(/[-:.]/g, "");
 }
@@ -31869,6 +32561,12 @@ class RunTree {
       writable: true,
       value: undefined
     });
+    Object.defineProperty(this, "distributedParentId", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: undefined
+    });
     Object.defineProperty(this, "_serialized_start_time", {
       enumerable: true,
       configurable: true,
@@ -31899,20 +32597,12 @@ class RunTree {
     if (!this.id) {
       this.id = uuid7FromTime(this._serialized_start_time ?? this.start_time);
     }
-    if (config.id) {
-      warnIfNotUuidV7(config.id, "run_id");
-    }
     if (!this.trace_id) {
       if (this.parent_run) {
         this.trace_id = this.parent_run.trace_id ?? this.id;
       } else {
         this.trace_id = this.id;
       }
-    } else if (config.trace_id) {
-      warnIfNotUuidV7(config.trace_id, "trace_id");
-    }
-    if (config.parent_run_id) {
-      warnIfNotUuidV7(config.parent_run_id, "parent_run_id");
     }
     this.replicas = _ensureWriteReplicas(this.replicas);
     if (!this.dotted_order) {
@@ -31959,11 +32649,16 @@ class RunTree {
   }
   createChild(config) {
     const child_execution_order = this.child_execution_order + 1;
+    const inheritedReplicas = this.replicas?.map((replica) => {
+      const { reroot, ...rest } = replica;
+      return rest;
+    });
+    const childReplicas = config.replicas ?? inheritedReplicas;
     const child = new RunTree({
       ...config,
       parent_run: this,
       project_name: this.project_name,
-      replicas: this.replicas,
+      replicas: childReplicas,
       client: this.client,
       tracingEnabled: this.tracingEnabled,
       execution_order: child_execution_order,
@@ -32047,10 +32742,126 @@ class RunTree {
       events: run.events
     };
   }
-  _remapForProject(projectName, runtimeEnv, excludeChildRuns = true) {
+  _sliceParentId(parentId, run) {
+    if (run.dotted_order) {
+      const segs = run.dotted_order.split(".");
+      let startIdx = null;
+      for (let idx = 0;idx < segs.length; idx++) {
+        const segId = segs[idx].slice(-TIMESTAMP_LENGTH);
+        if (segId === parentId) {
+          startIdx = idx;
+          break;
+        }
+      }
+      if (startIdx !== null) {
+        const trimmedSegs = segs.slice(startIdx + 1);
+        run.dotted_order = trimmedSegs.join(".");
+        if (trimmedSegs.length > 0) {
+          run.trace_id = trimmedSegs[0].slice(-TIMESTAMP_LENGTH);
+        } else {
+          run.trace_id = run.id;
+        }
+      }
+    }
+    if (run.parent_run_id === parentId) {
+      run.parent_run_id = undefined;
+    }
+  }
+  _setReplicaTraceRoot(replicaKey, traceRootId) {
+    const replicaTraceRoots = getContextVar(this, _REPLICA_TRACE_ROOTS_KEY) ?? {};
+    replicaTraceRoots[replicaKey] = traceRootId;
+    setContextVar(this, _REPLICA_TRACE_ROOTS_KEY, replicaTraceRoots);
+    for (const child of this.child_runs) {
+      child._setReplicaTraceRoot(replicaKey, traceRootId);
+    }
+  }
+  _remapForProject(params) {
+    const { projectName, runtimeEnv, excludeChildRuns = true, reroot = false, distributedParentId, apiUrl, apiKey, workspaceId } = params;
     const baseRun = this._convertToCreate(this, runtimeEnv, excludeChildRuns);
+    if (projectName === this.project_name) {
+      return {
+        ...baseRun,
+        session_name: projectName
+      };
+    }
+    if (reroot) {
+      if (distributedParentId) {
+        this._sliceParentId(distributedParentId, baseRun);
+      } else {
+        baseRun.parent_run_id = undefined;
+        if (baseRun.dotted_order) {
+          const segs = baseRun.dotted_order.split(".");
+          if (segs.length > 0) {
+            baseRun.dotted_order = segs[segs.length - 1];
+            baseRun.trace_id = baseRun.id;
+          }
+        }
+      }
+      const replicaKey = getReplicaKey({
+        projectName,
+        apiUrl,
+        apiKey,
+        workspaceId
+      });
+      this._setReplicaTraceRoot(replicaKey, baseRun.id);
+    }
+    let ancestorRerootedTraceId;
+    if (!reroot) {
+      const replicaTraceRoots = getContextVar(this, _REPLICA_TRACE_ROOTS_KEY) ?? {};
+      const replicaKey = getReplicaKey({
+        projectName,
+        apiUrl,
+        apiKey,
+        workspaceId
+      });
+      ancestorRerootedTraceId = replicaTraceRoots[replicaKey];
+      if (ancestorRerootedTraceId) {
+        baseRun.trace_id = ancestorRerootedTraceId;
+        if (baseRun.dotted_order) {
+          const segs = baseRun.dotted_order.split(".");
+          let rootIdx = null;
+          for (let idx = 0;idx < segs.length; idx++) {
+            const segId = segs[idx].slice(-TIMESTAMP_LENGTH);
+            if (segId === ancestorRerootedTraceId) {
+              rootIdx = idx;
+              break;
+            }
+          }
+          if (rootIdx !== null) {
+            const trimmedSegs = segs.slice(rootIdx);
+            baseRun.dotted_order = trimmedSegs.join(".");
+          }
+        }
+      }
+    }
+    const oldId = baseRun.id;
+    const newId = v52(`${oldId}:${projectName}`, UUID_NAMESPACE_DNS);
+    let newTraceId;
+    if (baseRun.trace_id) {
+      newTraceId = v52(`${baseRun.trace_id}:${projectName}`, UUID_NAMESPACE_DNS);
+    } else {
+      newTraceId = newId;
+    }
+    let newParentId;
+    if (baseRun.parent_run_id) {
+      newParentId = v52(`${baseRun.parent_run_id}:${projectName}`, UUID_NAMESPACE_DNS);
+    }
+    let newDottedOrder;
+    if (baseRun.dotted_order) {
+      const segs = baseRun.dotted_order.split(".");
+      const remappedSegs = segs.map((seg) => {
+        const segId = seg.slice(-TIMESTAMP_LENGTH);
+        const remappedId = v52(`${segId}:${projectName}`, UUID_NAMESPACE_DNS);
+        return seg.slice(0, -TIMESTAMP_LENGTH) + remappedId;
+      });
+      newDottedOrder = remappedSegs.join(".");
+    }
     return {
       ...baseRun,
+      id: newId,
+      trace_id: newTraceId,
+      parent_run_id: newParentId,
+      dotted_order: newDottedOrder,
       session_name: projectName
     };
   }
@@ -32058,8 +32869,17 @@ class RunTree {
     try {
       const runtimeEnv = getRuntimeEnvironment2();
       if (this.replicas && this.replicas.length > 0) {
-        for (const { projectName, apiKey, apiUrl, workspaceId } of this.replicas) {
-          const runCreate = this._remapForProject(projectName ?? this.project_name, runtimeEnv, true);
+        for (const { projectName, apiKey, apiUrl, workspaceId, reroot } of this.replicas) {
+          const runCreate = this._remapForProject({
+            projectName: projectName ?? this.project_name,
+            runtimeEnv,
+            excludeChildRuns: true,
+            reroot,
+            distributedParentId: this.distributedParentId,
+            apiUrl,
+            apiKey,
+            workspaceId
+          });
           await this.client.createRun(runCreate, {
             apiKey,
             apiUrl,
@@ -32082,8 +32902,17 @@ class RunTree {
   }
   async patchRun(options) {
     if (this.replicas && this.replicas.length > 0) {
-      for (const { projectName, apiKey, apiUrl, workspaceId, updates } of this.replicas) {
-        const runData = this._remapForProject(projectName ?? this.project_name);
+      for (const { projectName, apiKey, apiUrl, workspaceId, updates, reroot } of this.replicas) {
+        const runData = this._remapForProject({
+          projectName: projectName ?? this.project_name,
+          runtimeEnv: undefined,
+          excludeChildRuns: true,
+          reroot,
+          distributedParentId: this.distributedParentId,
+          apiUrl,
+          apiKey,
+          workspaceId
+        });
         const updatePayload = {
           id: runData.id,
           name: runData.name,
@@ -32235,7 +33064,9 @@ class RunTree {
       config.project_name = baggage.project_name;
       config.replicas = baggage.replicas;
     }
-    return new RunTree(config);
+    const runTree = new RunTree(config);
+    runTree.distributedParentId = runTree.id;
+    return runTree;
   }
   toHeaders(headers) {
     const result = {
@@ -35179,8 +36010,187 @@ var EventStreamCallbackHandler = class extends BaseTracer {
   }
 };
 
+// ../../node_modules/@langchain/core/dist/utils/is-network-error/index.js
+var objectToString2 = Object.prototype.toString;
+var isError2 = (value) => objectToString2.call(value) === "[object Error]";
+var errorMessages2 = new Set([
+  "network error",
+  "Failed to fetch",
+  "NetworkError when attempting to fetch resource.",
+  "The Internet connection appears to be offline.",
+  "Network request failed",
+  "fetch failed",
+  "terminated",
+  " A network error occurred.",
+  "Network connection lost"
+]);
+function isNetworkError2(error) {
+  const isValid = error && isError2(error) && error.name === "TypeError" && typeof error.message === "string";
+  if (!isValid)
+    return false;
+  const { message, stack } = error;
+  if (message === "Load failed")
+    return stack === undefined || "__sentry_captured__" in error;
+  if (message.startsWith("error sending request for url"))
+    return true;
+  return errorMessages2.has(message);
+}
+
+// ../../node_modules/@langchain/core/dist/utils/p-retry/index.js
+function validateRetries2(retries) {
+  if (typeof retries === "number") {
+    if (retries < 0)
+      throw new TypeError("Expected `retries` to be a non-negative number.");
+    if (Number.isNaN(retries))
+      throw new TypeError("Expected `retries` to be a valid number or Infinity, got NaN.");
+  } else if (retries !== undefined)
+    throw new TypeError("Expected `retries` to be a number or Infinity.");
+}
+function validateNumberOption2(name, value, { min = 0, allowInfinity = false } = {}) {
+  if (value === undefined)
+    return;
+  if (typeof value !== "number" || Number.isNaN(value))
+    throw new TypeError(`Expected \`${name}\` to be a number${allowInfinity ? " or Infinity" : ""}.`);
+  if (!allowInfinity && !Number.isFinite(value))
+    throw new TypeError(`Expected \`${name}\` to be a finite number.`);
+  if (value < min)
+    throw new TypeError(`Expected \`${name}\` to be ≥ ${min}.`);
+}
+var AbortError2 = class extends Error {
+  constructor(message) {
+    super();
+    if (message instanceof Error) {
+      this.originalError = message;
+      ({ message } = message);
+    } else {
+      this.originalError = new Error(message);
+      this.originalError.stack = this.stack;
+    }
+    this.name = "AbortError";
+    this.message = message;
+  }
+};
+function calculateDelay2(retriesConsumed, options) {
+  const attempt = Math.max(1, retriesConsumed + 1);
+  const random = options.randomize ? Math.random() + 1 : 1;
+  let timeout = Math.round(random * options.minTimeout * options.factor ** (attempt - 1));
+  timeout = Math.min(timeout, options.maxTimeout);
+  return timeout;
+}
+function calculateRemainingTime2(start, max) {
+  if (!Number.isFinite(max))
+    return max;
+  return max - (performance.now() - start);
+}
+async function onAttemptFailure2({ error, attemptNumber, retriesConsumed, startTime, options }) {
+  const normalizedError = error instanceof Error ? error : /* @__PURE__ */ new TypeError(`Non-error was thrown: "${error}". You should only throw errors.`);
+  if (normalizedError instanceof AbortError2)
+    throw normalizedError.originalError;
+  const retriesLeft = Number.isFinite(options.retries) ? Math.max(0, options.retries - retriesConsumed) : options.retries;
+  const maxRetryTime = options.maxRetryTime ?? Number.POSITIVE_INFINITY;
+  const context = Object.freeze({
+    error: normalizedError,
+    attemptNumber,
+    retriesLeft,
+    retriesConsumed
+  });
+  await options.onFailedAttempt(context);
+  if (calculateRemainingTime2(startTime, maxRetryTime) <= 0)
+    throw normalizedError;
+  const consumeRetry = await options.shouldConsumeRetry(context);
+  const remainingTime = calculateRemainingTime2(startTime, maxRetryTime);
+  if (remainingTime <= 0 || retriesLeft <= 0)
+    throw normalizedError;
+  if (normalizedError instanceof TypeError && !isNetworkError2(normalizedError)) {
+    if (consumeRetry)
+      throw normalizedError;
+    options.signal?.throwIfAborted();
+    return false;
+  }
+  if (!await options.shouldRetry(context))
+    throw normalizedError;
+  if (!consumeRetry) {
+    options.signal?.throwIfAborted();
+    return false;
+  }
+  const delayTime = calculateDelay2(retriesConsumed, options);
+  const finalDelay = Math.min(delayTime, remainingTime);
+  if (finalDelay > 0)
+    await new Promise((resolve, reject) => {
+      const onAbort = () => {
+        clearTimeout(timeoutToken);
+        options.signal?.removeEventListener("abort", onAbort);
+        reject(options.signal.reason);
+      };
+      const timeoutToken = setTimeout(() => {
+        options.signal?.removeEventListener("abort", onAbort);
+        resolve();
+      }, finalDelay);
+      if (options.unref)
+        timeoutToken.unref?.();
+      options.signal?.addEventListener("abort", onAbort, { once: true });
+    });
+  options.signal?.throwIfAborted();
+  return true;
+}
+async function pRetry2(input, options = {}) {
+  options = { ...options };
+  validateRetries2(options.retries);
+  if (Object.hasOwn(options, "forever"))
+    throw new Error("The `forever` option is no longer supported. For many use-cases, you can set `retries: Infinity` instead.");
+  options.retries ??= 10;
+  options.factor ??= 2;
+  options.minTimeout ??= 1000;
+  options.maxTimeout ??= Number.POSITIVE_INFINITY;
+  options.maxRetryTime ??= Number.POSITIVE_INFINITY;
+  options.randomize ??= false;
+  options.onFailedAttempt ??= () => {};
+  options.shouldRetry ??= () => true;
+  options.shouldConsumeRetry ??= () => true;
+  validateNumberOption2("factor", options.factor, {
+    min: 0,
+    allowInfinity: false
+  });
+  validateNumberOption2("minTimeout", options.minTimeout, {
+    min: 0,
+    allowInfinity: false
+  });
+  validateNumberOption2("maxTimeout", options.maxTimeout, {
+    min: 0,
+    allowInfinity: true
+  });
+  validateNumberOption2("maxRetryTime", options.maxRetryTime, {
+    min: 0,
+    allowInfinity: true
+  });
+  if (!(options.factor > 0))
+    options.factor = 1;
+  options.signal?.throwIfAborted();
+  let attemptNumber = 0;
+  let retriesConsumed = 0;
+  const startTime = performance.now();
+  while (Number.isFinite(options.retries) ? retriesConsumed <= options.retries : true) {
+    attemptNumber++;
+    try {
+      options.signal?.throwIfAborted();
+      const result = await input(attemptNumber);
+      options.signal?.throwIfAborted();
+      return result;
+    } catch (error) {
+      if (await onAttemptFailure2({
+        error,
+        attemptNumber,
+        retriesConsumed,
+        startTime,
+        options
+      }))
+        retriesConsumed++;
+    }
+  }
+  throw new Error("Retry attempts exhausted without throwing an error.");
+}
+
 // ../../node_modules/@langchain/core/dist/utils/async_caller.js
-var import_p_retry2 = __toESM(require_p_retry(), 1);
 var import_p_queue3 = __toESM(require_dist3(), 1);
 var async_caller_exports = {};
 __export(async_caller_exports, { AsyncCaller: () => AsyncCaller2 });
@@ -35221,14 +36231,14 @@ var AsyncCaller2 = class {
     const PQueue = "default" in import_p_queue3.default ? import_p_queue3.default.default : import_p_queue3.default;
     this.queue = new PQueue({ concurrency: this.maxConcurrency });
   }
-  call(callable, ...args) {
-    return this.queue.add(() => import_p_retry2.default(() => callable(...args).catch((error) => {
+  async call(callable, ...args) {
+    return this.queue.add(() => pRetry2(() => callable(...args).catch((error) => {
       if (error instanceof Error)
         throw error;
       else
         throw new Error(error);
     }), {
-      onFailedAttempt: this.onFailedAttempt,
+      onFailedAttempt: ({ error }) => this.onFailedAttempt?.(error),
       retries: this.maxRetries,
       randomize: true
     }), { throwOnTimeout: true });
@@ -35326,6 +36336,10 @@ var _RootEventFilter = class {
     return include;
   }
 };
+var toBase64Url = (str) => {
+  const encoded = btoa(str);
+  return encoded.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+};
 
 // ../../node_modules/@langchain/core/dist/utils/types/zod.js
 import { $ZodNever, $ZodOptional, $ZodUnknown, _never, _unknown, clone, globalRegistry, parse as parse3, parseAsync, util } from "zod/v4/core";
@@ -35401,6 +36415,20 @@ function isZodArrayV4(obj) {
     return true;
   return false;
 }
+function isZodOptionalV4(obj) {
+  if (!isZodSchemaV4(obj))
+    return false;
+  if (typeof obj === "object" && obj !== null && "_zod" in obj && typeof obj._zod === "object" && obj._zod !== null && "def" in obj._zod && typeof obj._zod.def === "object" && obj._zod.def !== null && "type" in obj._zod.def && obj._zod.def.type === "optional")
+    return true;
+  return false;
+}
+function isZodNullableV4(obj) {
+  if (!isZodSchemaV4(obj))
+    return false;
+  if (typeof obj === "object" && obj !== null && "_zod" in obj && typeof obj._zod === "object" && obj._zod !== null && "def" in obj._zod && typeof obj._zod.def === "object" && obj._zod.def !== null && "type" in obj._zod.def && obj._zod.def.type === "nullable")
+    return true;
+  return false;
+}
 function interopZodObjectStrict(schema, recursive = false) {
   if (isZodSchemaV3(schema))
     return schema.strict();
@@ -35471,6 +36499,18 @@ function interopZodTransformInputSchemaImpl(schema, recursive, cache) {
           ...outputSchema._zod.def,
           element: elementSchema
         });
+      } else if (isZodOptionalV4(outputSchema)) {
+        const innerSchema = interopZodTransformInputSchemaImpl(outputSchema._zod.def.innerType, recursive, cache);
+        outputSchema = clone(outputSchema, {
+          ...outputSchema._zod.def,
+          innerType: innerSchema
+        });
+      } else if (isZodNullableV4(outputSchema)) {
+        const innerSchema = interopZodTransformInputSchemaImpl(outputSchema._zod.def.innerType, recursive, cache);
+        outputSchema = clone(outputSchema, {
+          ...outputSchema._zod.def,
+          innerType: innerSchema
+        });
       }
     }
     const meta = globalRegistry.get(schema);
@@ -35579,7 +36619,7 @@ graph TD;
 async function drawMermaidImage(mermaidSyntax, config) {
   let backgroundColor = config?.backgroundColor ?? "white";
   const imageType = config?.imageType ?? "png";
-  const mermaidSyntaxEncoded = btoa(mermaidSyntax);
+  const mermaidSyntaxEncoded = toBase64Url(mermaidSyntax);
   if (backgroundColor !== undefined) {
     const hexColorPattern = /^#(?:[0-9a-fA-F]{3}){1,2}$/;
     if (!hexColorPattern.test(backgroundColor))
@@ -38186,7 +39226,6 @@ async function* consumeAsyncIterableInContext(context, iter) {
 }
 
 // ../../node_modules/@langchain/core/dist/runnables/base.js
-var import_p_retry3 = __toESM(require_p_retry(), 1);
 import { z } from "zod/v3";
 function _coerceToDict2(value, defaultKey) {
   return value && !Array.isArray(value) && !(value instanceof Date) && typeof value === "object" ? value : { [defaultKey]: value };
@@ -38783,8 +39822,8 @@ var RunnableRetry = class extends RunnableBinding {
     return patchConfig(config, { callbacks: runManager?.getChild(tag) });
   }
   async _invoke(input, config, runManager) {
-    return import_p_retry3.default((attemptNumber) => super.invoke(input, this._patchConfigForRetry(attemptNumber, config, runManager)), {
-      onFailedAttempt: (error) => this.onFailedAttempt(error, input),
+    return pRetry2((attemptNumber) => super.invoke(input, this._patchConfigForRetry(attemptNumber, config, runManager)), {
+      onFailedAttempt: ({ error }) => this.onFailedAttempt(error, input),
       retries: Math.max(this.maxAttemptNumber - 1, 0),
       randomize: true
     });
@@ -38795,7 +39834,7 @@ var RunnableRetry = class extends RunnableBinding {
   async _batch(inputs, configs, runManagers, batchOptions) {
     const resultsMap = {};
     try {
-      await import_p_retry3.default(async (attemptNumber) => {
+      await pRetry2(async (attemptNumber) => {
         const remainingIndexes = inputs.map((_, i) => i).filter((i) => resultsMap[i.toString()] === undefined || resultsMap[i.toString()] instanceof Error);
         const remainingInputs = remainingIndexes.map((i) => inputs[i]);
         const patchedConfigs = remainingIndexes.map((i) => this._patchConfigForRetry(attemptNumber, configs?.[i], runManagers?.[i]));
@@ -38819,7 +39858,7 @@ var RunnableRetry = class extends RunnableBinding {
           throw firstException;
         return results;
       }, {
-        onFailedAttempt: (error) => this.onFailedAttempt(error, error.input),
+        onFailedAttempt: ({ error }) => this.onFailedAttempt(error, error.input),
         retries: Math.max(this.maxAttemptNumber - 1, 0),
         randomize: true
       });
@@ -42448,6 +43487,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: () => {}
 };
@@ -42501,6 +43541,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 = {
@@ -42516,6 +43587,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 {
@@ -42664,24 +43775,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(),
@@ -42736,6 +43854,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];
@@ -42743,10 +43870,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,
@@ -42815,6 +43945,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];
@@ -42822,10 +43961,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));
@@ -42934,7 +44082,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";
@@ -43019,7 +44167,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;
@@ -43092,12 +44239,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) => {
@@ -43182,8 +44327,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;
@@ -43234,17 +44378,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) {
@@ -44321,8 +45460,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 */;
@@ -44337,12 +45476,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 = [];
@@ -44407,6 +45546,44 @@ function v43(options, buf, offset) {
   return _v4(options, buf, offset);
 }
 var v4_default = v43;
+// src/utils/type-guards.ts
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  if (Array.isArray(value)) {
+    return false;
+  }
+  if (isBuffer(value)) {
+    return false;
+  }
+  if (value instanceof Date) {
+    return false;
+  }
+  if (value instanceof RegExp) {
+    return false;
+  }
+  if (value instanceof Map) {
+    return false;
+  }
+  if (value instanceof Set) {
+    return false;
+  }
+  if (value instanceof WeakMap) {
+    return false;
+  }
+  if (value instanceof WeakSet) {
+    return false;
+  }
+  if (value instanceof Error) {
+    return false;
+  }
+  if (value instanceof Promise) {
+    return false;
+  }
+  return true;
+}
+
 // src/services/default-message-service.ts
 var latestResponseIds = new Map;
 
@@ -44421,7 +45598,12 @@ 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);
       }
@@ -44430,10 +45612,10 @@ 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();
+      const runId = runtime.startRun(message.roomId);
       const startTime = Date.now();
       await runtime.emitEvent("RUN_STARTED" /* RUN_STARTED */, {
         runtime,
@@ -44470,7 +45652,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;
     }
   }
@@ -44480,7 +45662,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,
@@ -44490,13 +45672,16 @@ 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");
@@ -44512,7 +45697,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,
@@ -44523,7 +45708,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,
@@ -44543,24 +45728,31 @@ 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());
       }
@@ -44575,7 +45767,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,
@@ -44593,14 +45785,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);
@@ -44610,11 +45802,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,
@@ -44625,7 +45817,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,
@@ -44653,14 +45845,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;
         }
@@ -44733,7 +45925,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,
@@ -44794,7 +45986,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 {
@@ -44802,7 +45994,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);
@@ -44824,7 +46016,10 @@ ${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>/);
@@ -44834,21 +46029,27 @@ ${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);
@@ -44857,18 +46058,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);
       }
     }
@@ -44877,7 +46078,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,
@@ -44887,9 +46088,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,
@@ -44904,7 +46105,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) {
@@ -44947,7 +46148,11 @@ ${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"
@@ -44960,7 +46165,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,
@@ -44970,7 +46175,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: "",
@@ -44980,14 +46185,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,
@@ -44997,7 +46202,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,
@@ -45050,7 +46255,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,
@@ -45059,7 +46264,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",
@@ -45114,25 +46319,30 @@ ${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) {
@@ -45140,13 +46350,19 @@ ${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;
     }
   }
@@ -46025,8 +47241,8 @@ class AgentRuntime {
   initPromise;
   initResolver;
   initRejecter;
-  migratedPlugins = new Set;
   currentRunId;
+  currentRoomId;
   currentActionContext;
   maxWorkingMemoryEntries = 50;
   messageService = null;
@@ -46055,7 +47271,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;
@@ -46066,12 +47282,14 @@ class AgentRuntime {
   createRunId() {
     return v4_default();
   }
-  startRun() {
+  startRun(roomId) {
     this.currentRunId = this.createRunId();
+    this.currentRoomId = roomId;
     return this.currentRunId;
   }
   endRun() {
     this.currentRunId = undefined;
+    this.currentRoomId = undefined;
   }
   getCurrentRunId() {
     if (!this.currentRunId) {
@@ -46082,20 +47300,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")) {
@@ -46108,7 +47326,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) {
@@ -46147,14 +47365,19 @@ 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)}`);
@@ -46171,9 +47394,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();
       }
@@ -46191,8 +47414,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()) {
@@ -46201,11 +47423,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,
@@ -46248,7 +47470,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) {
@@ -46258,7 +47480,7 @@ class AgentRuntime {
           source: "elizaos",
           type: "SELF" /* SELF */,
           channelId: this.agentId,
-          serverId: this.agentId,
+          messageServerId: this.agentId,
           worldId: this.agentId
         });
       }
@@ -46266,14 +47488,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();
       }
@@ -46283,7 +47504,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;
@@ -46303,31 +47524,34 @@ 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;
     }
   }
@@ -46364,26 +47588,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) {
@@ -46394,7 +47614,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 {
@@ -46433,13 +47653,17 @@ 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 });
@@ -46452,34 +47676,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",
@@ -46505,7 +47726,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",
@@ -46516,7 +47737,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,
@@ -46541,7 +47762,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,
@@ -46558,7 +47778,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) => {
@@ -46643,8 +47863,12 @@ 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) {
@@ -46682,13 +47906,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,
@@ -46715,7 +47933,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",
@@ -46798,7 +48016,12 @@ 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;
         }
       });
@@ -46825,24 +48048,35 @@ 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 });
@@ -46859,12 +48093,12 @@ class AgentRuntime {
     const roomsToCreate = roomIds.filter((id) => !roomsIdExists?.includes(id));
     const rf = {
       worldId: world.id,
-      serverId: world.serverId,
+      messageServerId: world.messageServerId,
       source,
       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);
     }
@@ -46879,10 +48113,10 @@ class AgentRuntime {
     };
     const wf = {
       worldId: world.id,
-      serverId: world.serverId
+      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,
@@ -46900,13 +48134,18 @@ 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,
@@ -46918,12 +48157,12 @@ class AgentRuntime {
     source,
     type,
     channelId,
-    serverId,
+    messageServerId,
     userId,
     metadata
   }) {
-    if (!worldId && serverId) {
-      worldId = createUniqueUuid(this, serverId);
+    if (!worldId && messageServerId) {
+      worldId = createUniqueUuid(this, messageServerId);
     }
     const names3 = [name, userName].filter(Boolean);
     const entityMetadata = {
@@ -46944,13 +48183,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;
           }
@@ -46973,9 +48212,9 @@ class AgentRuntime {
       }
       await this.ensureWorldExists({
         id: worldId,
-        name: worldName || serverId ? `World for server ${serverId}` : `World for room ${roomId}`,
+        name: worldName || messageServerId ? `World for server ${messageServerId}` : `World for room ${roomId}`,
         agentId: this.agentId,
-        serverId: serverId || "default",
+        messageServerId,
         metadata
       });
       await this.ensureRoomExists({
@@ -46984,7 +48223,7 @@ class AgentRuntime {
         source: source || "default",
         type: type || "DM" /* DM */,
         channelId,
-        serverId,
+        messageServerId,
         worldId
       });
       try {
@@ -46995,22 +48234,28 @@ 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) {
@@ -47023,9 +48268,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");
       }
     }
   }
@@ -47038,32 +48283,39 @@ class AgentRuntime {
   async getParticipantsForRoom(roomId) {
     return await this.adapter.getParticipantsForRoom(roomId);
   }
+  async isRoomParticipant(roomId, entityId) {
+    return await this.adapter.isRoomParticipant(roomId, entityId);
+  }
   async addParticipant(entityId, roomId) {
     return await this.adapter.addParticipantsRoom([entityId], roomId);
   }
   async addParticipantsRoom(entityIds, roomId) {
     return await this.adapter.addParticipantsRoom(entityIds, roomId);
   }
-  async ensureWorldExists({ id, name, serverId, metadata }) {
+  async ensureWorldExists({ id, name, messageServerId, metadata }) {
     const world = await this.getWorld(id);
     if (!world) {
-      this.logger.debug("Creating world:", JSON.stringify({
-        id,
-        name,
-        serverId,
-        agentId: this.agentId
-      }));
+      this.logger.debug({ src: "agent", agentId: this.agentId, worldId: id, name, messageServerId }, "Creating world");
       await this.adapter.createWorld({
         id,
         name,
         agentId: this.agentId,
-        serverId: serverId || "default",
+        messageServerId,
         metadata
       });
-      this.logger.debug(`World ${id} created successfully.`);
+      this.logger.debug({ src: "agent", agentId: this.agentId, worldId: id, messageServerId }, "World created");
     }
   }
-  async ensureRoomExists({ id, name, source, type, channelId, serverId, worldId, metadata }) {
+  async ensureRoomExists({
+    id,
+    name,
+    source,
+    type,
+    channelId,
+    messageServerId,
+    worldId,
+    metadata
+  }) {
     if (!worldId)
       throw new Error("worldId is required");
     const room = await this.getRoom(id);
@@ -47075,11 +48327,11 @@ class AgentRuntime {
         source,
         type,
         channelId,
-        serverId,
+        messageServerId,
         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) {
@@ -47106,7 +48358,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,
@@ -47164,7 +48416,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];
@@ -47175,7 +48427,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;
@@ -47214,13 +48466,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)`));
@@ -47247,17 +48499,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")) {
@@ -47268,10 +48523,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");
@@ -47335,13 +48590,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) {
@@ -47365,23 +48620,40 @@ class AgentRuntime {
           return numValue;
         }
       }
-      const legacyValue = this.getSetting(legacyKey);
-      if (legacyValue !== null && legacyValue !== undefined) {
-        const numValue = Number(legacyValue);
-        if (!isNaN(numValue)) {
-          return numValue;
+      if (legacyKey) {
+        const legacyValue = this.getSetting(legacyKey);
+        if (legacyValue !== null && legacyValue !== undefined) {
+          const numValue = Number(legacyValue);
+          if (!isNaN(numValue)) {
+            return numValue;
+          }
         }
       }
       return null;
     };
     const maxTokens = getSettingWithFallback("MAX_TOKENS", MODEL_SETTINGS.MODEL_MAX_TOKEN);
     const temperature = getSettingWithFallback("TEMPERATURE", MODEL_SETTINGS.MODEL_TEMPERATURE);
+    const topP = getSettingWithFallback("TOP_P");
+    const topK = getSettingWithFallback("TOP_K");
+    const minP = getSettingWithFallback("MIN_P");
+    const seed = getSettingWithFallback("SEED");
+    const repetitionPenalty = getSettingWithFallback("REPETITION_PENALTY");
     const frequencyPenalty = getSettingWithFallback("FREQUENCY_PENALTY", MODEL_SETTINGS.MODEL_FREQ_PENALTY);
     const presencePenalty = getSettingWithFallback("PRESENCE_PENALTY", MODEL_SETTINGS.MODEL_PRESENCE_PENALTY);
     if (maxTokens !== null)
       modelSettings.maxTokens = maxTokens;
     if (temperature !== null)
       modelSettings.temperature = temperature;
+    if (topP !== null)
+      modelSettings.topP = topP;
+    if (topK !== null)
+      modelSettings.topK = topK;
+    if (minP !== null)
+      modelSettings.minP = minP;
+    if (seed !== null)
+      modelSettings.seed = seed;
+    if (repetitionPenalty !== null)
+      modelSettings.repetitionPenalty = repetitionPenalty;
     if (frequencyPenalty !== null)
       modelSettings.frequencyPenalty = frequencyPenalty;
     if (presencePenalty !== null)
@@ -47396,10 +48668,14 @@ class AgentRuntime {
       const errorMsg = `No handler found for delegate type: ${modelKey}`;
       throw new Error(errorMsg);
     }
-    const binaryModels = [ModelType.TRANSCRIPTION, ModelType.IMAGE, ModelType.AUDIO, ModelType.VIDEO];
+    const binaryModels = [
+      ModelType.TRANSCRIPTION,
+      ModelType.IMAGE,
+      ModelType.AUDIO,
+      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)) {
@@ -47413,7 +48689,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)) {
@@ -47428,13 +48704,22 @@ class AgentRuntime {
       } else {
         modelParams = params;
       }
+      if (isPlainObject(modelParams)) {
+        if (modelParams.user === undefined && this.character?.name) {
+          modelParams.user = this.character.name;
+        }
+      }
     }
     const startTime = typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
     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({
@@ -47446,7 +48731,7 @@ class AgentRuntime {
       }
       this.adapter.log({
         entityId: this.agentId,
-        roomId: this.agentId,
+        roomId: this.currentRoomId ?? this.agentId,
         body: {
           modelType,
           modelKey,
@@ -47455,6 +48740,7 @@ class AgentRuntime {
             prompt: promptContent
           },
           prompt: promptContent,
+          systemPrompt: this.character?.system || null,
           runId: this.getCurrentRunId(),
           timestamp: Date.now(),
           executionTime: elapsedTime,
@@ -47507,10 +48793,18 @@ ${input}`;
     const params = {
       prompt,
       maxTokens: options?.maxTokens,
+      minTokens: options?.minTokens,
       temperature: options?.temperature,
+      topP: options?.topP,
+      topK: options?.topK,
+      minP: options?.minP,
+      seed: options?.seed,
+      repetitionPenalty: options?.repetitionPenalty,
       frequencyPenalty: options?.frequencyPenalty,
       presencePenalty: options?.presencePenalty,
-      stopSequences: options?.stopSequences
+      stopSequences: options?.stopSequences,
+      user: options?.user !== undefined ? options.user : this.character?.name,
+      responseFormat: options?.responseFormat
     };
     const response = await this.useModel(modelType, params);
     return {
@@ -47540,36 +48834,42 @@ ${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);
   }
@@ -47631,7 +48931,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 = {
@@ -47642,7 +48942,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) {
@@ -47700,7 +49000,11 @@ ${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;
@@ -47714,7 +49018,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 */, {
@@ -47742,7 +49045,12 @@ ${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;
@@ -47794,16 +49102,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);
@@ -47841,7 +49148,15 @@ ${input}`;
   async getRoomsByIds(roomIds) {
     return await this.adapter.getRoomsByIds(roomIds);
   }
-  async createRoom({ id, name, source, type, channelId, serverId, worldId }) {
+  async createRoom({
+    id,
+    name,
+    source,
+    type,
+    channelId,
+    messageServerId,
+    worldId
+  }) {
     if (!worldId)
       throw new Error("worldId is required");
     const res = await this.adapter.createRooms([
@@ -47851,7 +49166,7 @@ ${input}`;
         source,
         type,
         channelId,
-        serverId,
+        messageServerId,
         worldId
       }
     ]);
@@ -47968,29 +49283,38 @@ ${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;
     }
   }
@@ -48001,7 +49325,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() {
@@ -48062,8 +49386,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);
@@ -48078,15 +49402,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
@@ -48118,7 +49442,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 = {
@@ -48133,15 +49457,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(":");
@@ -48149,7 +49470,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) {}
@@ -48170,7 +49490,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(":");
@@ -48180,9 +49499,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);
@@ -48191,7 +49507,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;
   }
 }
@@ -48223,11 +49539,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) {
@@ -48239,8 +49555,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;
@@ -48251,7 +49567,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.serverId}`);
+    logger.debug({ src: "core:settings", serverId: world.messageServerId }, "Onboarding state already exists");
     const saltedSettings = world.metadata.settings;
     const salt = getSalt();
     return unsaltWorldSettings(saltedSettings, salt);
@@ -48267,7 +49583,7 @@ async function initializeOnboarding(runtime, world, config) {
   }
   world.metadata.settings = worldSettings;
   await runtime.updateWorld(world);
-  logger.info(`Initialized settings config for server ${world.serverId}`);
+  logger.info({ src: "core:settings", serverId: world.messageServerId }, "Settings config initialized");
   return worldSettings;
 }
 function encryptedCharacter(character) {
@@ -48384,30 +49700,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,
@@ -48416,14 +49732,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;
   }
 }
@@ -48484,7 +49800,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;
@@ -48492,12 +49808,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`;
@@ -48518,14 +49834,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;
   }
 }
@@ -48560,7 +49876,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);
@@ -48569,7 +49885,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);
@@ -48597,7 +49913,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) {
@@ -48606,7 +49922,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;
@@ -48651,7 +49967,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) {
@@ -48666,17 +49983,26 @@ class ElizaOS extends EventTarget {
   initFunctions = new Map;
   editableMode = false;
   async addAgents(agents, options) {
+    const createdRuntimes = [];
     const promises = agents.map(async (agent) => {
       const character = agent.character;
       await setDefaultSecretsFromEnv(character, { skipEnvMerge: options?.isTestMode });
-      const resolvedPlugins = agent.plugins ? await resolvePlugins(agent.plugins, options?.isTestMode || false) : [];
+      let resolvedPlugins = agent.plugins ? await resolvePlugins(agent.plugins, options?.isTestMode || false) : [];
+      if (agent.databaseAdapter) {
+        resolvedPlugins = resolvedPlugins.filter((p) => p.name !== "@elizaos/plugin-sql");
+      }
       const runtime = new AgentRuntime({
         character,
         plugins: resolvedPlugins,
         settings: agent.settings || {}
       });
+      if (agent.databaseAdapter) {
+        runtime.registerDatabaseAdapter(agent.databaseAdapter);
+      }
       runtime.elizaOS = this;
-      this.runtimes.set(runtime.agentId, runtime);
+      if (!options?.ephemeral) {
+        this.runtimes.set(runtime.agentId, runtime);
+      }
       if (typeof agent.init === "function") {
         this.initFunctions.set(runtime.agentId, agent.init);
       }
@@ -48688,15 +50014,33 @@ class ElizaOS extends EventTarget {
           character: {
             ...characterWithoutSecrets,
             settings: settingsWithoutSecrets
-          }
+          },
+          ephemeral: options?.ephemeral
         }
       }));
+      createdRuntimes.push(runtime);
       return runtime.agentId;
     });
     const ids = await Promise.all(promises);
+    if (options?.autoStart) {
+      await Promise.all(createdRuntimes.map(async (runtime) => {
+        await runtime.initialize({ skipMigrations: options?.skipMigrations });
+        const initFn = this.initFunctions.get(runtime.agentId);
+        if (initFn) {
+          await initFn(runtime);
+          this.initFunctions.delete(runtime.agentId);
+        }
+        this.dispatchEvent(new CustomEvent("agent:started", {
+          detail: { agentId: runtime.agentId }
+        }));
+      }));
+    }
     this.dispatchEvent(new CustomEvent("agents:added", {
-      detail: { agentIds: ids, count: ids.length }
+      detail: { agentIds: ids, count: ids.length, ephemeral: options?.ephemeral }
     }));
+    if (options?.returnRuntimes) {
+      return createdRuntimes;
+    }
     return ids;
   }
   registerAgent(runtime) {
@@ -48796,10 +50140,18 @@ class ElizaOS extends EventTarget {
   getAgentByCharacterId(characterId) {
     return this.getAgents().find((runtime) => runtime.character.id === characterId);
   }
-  async sendMessage(agentId, message, options) {
-    const runtime = this.runtimes.get(agentId);
-    if (!runtime) {
-      throw new Error(`Agent ${agentId} not found`);
+  async sendMessage(target, message, options) {
+    let runtime;
+    let agentId;
+    if (typeof target === "string") {
+      agentId = target;
+      runtime = this.runtimes.get(agentId);
+      if (!runtime) {
+        throw new Error(`Agent ${agentId} not found in registry`);
+      }
+    } else {
+      runtime = target;
+      agentId = runtime.agentId;
     }
     if (!runtime.messageService) {
       throw new Error("messageService is not initialized on runtime");
@@ -48827,6 +50179,13 @@ class ElizaOS extends EventTarget {
       useMultiStep: options?.useMultiStep,
       maxMultiStepIterations: options?.maxMultiStepIterations
     };
+    const handleMessageWithEntityContext = async (handler) => {
+      if (runtime.withEntityContext) {
+        return await runtime.withEntityContext(userMessage.entityId, handler);
+      } else {
+        return await handler();
+      }
+    };
     const isAsyncMode = !!options?.onResponse;
     if (isAsyncMode) {
       const callback = async (content) => {
@@ -48841,7 +50200,7 @@ class ElizaOS extends EventTarget {
         }
         return [];
       };
-      runtime.messageService.handleMessage(runtime, userMessage, callback, processingOptions).then(() => {
+      handleMessageWithEntityContext(() => runtime.messageService.handleMessage(runtime, userMessage, callback, processingOptions)).then(() => {
         if (options.onComplete)
           options.onComplete();
       }).catch((error) => {
@@ -48853,13 +50212,13 @@ class ElizaOS extends EventTarget {
       }));
       return { messageId, userMessage };
     } else {
-      const result = await runtime.messageService.handleMessage(runtime, userMessage, undefined, processingOptions);
+      const processing = await handleMessageWithEntityContext(() => runtime.messageService.handleMessage(runtime, userMessage, undefined, processingOptions));
       if (options?.onComplete)
         await options.onComplete();
       this.dispatchEvent(new CustomEvent("message:sent", {
-        detail: { agentId, messageId, mode: "sync", result }
+        detail: { agentId, messageId, mode: "sync", processing }
       }));
-      return { messageId, userMessage, result };
+      return { messageId, userMessage, processing };
     }
   }
   async sendMessages(messages) {
@@ -49002,7 +50361,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;
@@ -49053,7 +50412,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) {
@@ -49324,5 +50683,5 @@ export {
   AgentRuntime
 };
 
-//# debugId=14B681AD83723C0164756E2164756E21
+//# debugId=C468BC8B5AE0993F64756E2164756E21
 //# sourceMappingURL=index.node.js.map