@elizaos/core 1.6.5-alpha.18 → 1.6.5-alpha.19

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;
@@ -26612,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",
@@ -26851,9 +26564,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;
   }
 };
 
@@ -27887,7 +27608,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}`;
@@ -27899,22 +27619,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;
@@ -28501,10 +28207,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,
@@ -28574,14 +28483,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;
         }
@@ -32209,8 +32118,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, "");
 }
@@ -32445,6 +32376,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,
@@ -32475,20 +32412,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) {
@@ -32535,11 +32464,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,
@@ -32623,10 +32557,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
     };
   }
@@ -32634,8 +32684,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,
@@ -32658,8 +32717,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,
@@ -32811,7 +32879,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 = {
@@ -35755,8 +35825,197 @@ var EventStreamCallbackHandler = class extends BaseTracer {
   }
 };
 
+// ../../node_modules/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/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}.`);
+  }
+}
+
+class AbortError2 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 : 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 });
@@ -35798,13 +36057,13 @@ var AsyncCaller2 = class {
     this.queue = new PQueue({ concurrency: this.maxConcurrency });
   }
   call(callable, ...args) {
-    return this.queue.add(() => import_p_retry2.default(() => callable(...args).catch((error) => {
+    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 });
@@ -38762,7 +39021,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 };
@@ -39359,8 +39617,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
     });
@@ -39371,7 +39629,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]));
@@ -39395,7 +39653,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
       });
@@ -50067,5 +50325,5 @@ export {
   AgentRuntime
 };
 
-//# debugId=019277DAE9D708DD64756E2164756E21
+//# debugId=1AE99B04D756580C64756E2164756E21
 //# sourceMappingURL=index.node.js.map