@elizaos/core 1.6.5-alpha.20 → 1.6.5-alpha.21

package/dist/node/index.node.js

@@ -16,6 +16,16 @@ var __toESM = (mod, isNodeMode, target) => {
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // ../../node_modules/decamelize/index.js
@@ -3865,6 +3875,212 @@ var require_ansi_styles = __commonJS((exports, module) => {
   });
 });
 
+// ../../node_modules/is-network-error/index.js
+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);
+}
+var objectToString2, isError2 = (value) => objectToString2.call(value) === "[object Error]", errorMessages2;
+var init_is_network_error = __esm(() => {
+  objectToString2 = Object.prototype.toString;
+  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"
+  ]);
+});
+
+// ../../node_modules/p-retry/index.js
+var exports_p_retry = {};
+__export(exports_p_retry, {
+  makeRetriable: () => makeRetriable,
+  default: () => pRetry2,
+  AbortError: () => AbortError2
+});
+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}.`);
+  }
+}
+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.");
+}
+function makeRetriable(function_, options) {
+  return function(...arguments_) {
+    return pRetry2(() => function_.apply(this, arguments_), options);
+  };
+}
+var AbortError2;
+var init_p_retry = __esm(() => {
+  init_is_network_error();
+  AbortError2 = 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;
+    }
+  };
+});
+
 // ../../node_modules/base64-js/index.js
 var require_base64_js = __commonJS((exports) => {
   exports.byteLength = byteLength;
@@ -25417,7 +25633,7 @@ var SOCKET_MESSAGE_TYPE;
 })(SOCKET_MESSAGE_TYPE ||= {});
 // ../../node_modules/@langchain/core/dist/_virtual/rolldown_runtime.js
 var __defProp2 = Object.defineProperty;
-var __export = (target, all) => {
+var __export2 = (target, all) => {
   for (var name in all)
     __defProp2(target, name, {
       get: all[name],
@@ -25453,7 +25669,7 @@ function mapKeys(fields, mapper, map) {
 
 // ../../node_modules/@langchain/core/dist/load/serializable.js
 var serializable_exports = {};
-__export(serializable_exports, {
+__export2(serializable_exports, {
   Serializable: () => Serializable,
   get_lc_unique_name: () => get_lc_unique_name
 });
@@ -26580,7 +26796,7 @@ var BaseMessageChunk = class BaseMessageChunk2 extends BaseMessage {
 
 // ../../node_modules/@langchain/core/dist/messages/tool.js
 var tool_exports = {};
-__export(tool_exports, {
+__export2(tool_exports, {
   ToolMessage: () => ToolMessage,
   ToolMessageChunk: () => ToolMessageChunk,
   defaultToolCallParser: () => defaultToolCallParser,
@@ -26695,47 +26911,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;
+  }
+  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;
   }
-  if (isInsideString)
-    new_s += '"';
-  for (let i = stack.length - 1;i >= 0; i -= 1)
-    new_s += stack[i];
+  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;
   }
@@ -27231,7 +27627,7 @@ var AIMessageChunk = class extends BaseMessageChunk {
       for (const chunks of groupedToolCallChunks) {
         let parsedArgs = null;
         const name = chunks[0]?.name ?? "";
-        const joinedArgs = chunks.map((c) => c.args || "").join("");
+        const joinedArgs = chunks.map((c) => c.args || "").join("").trim();
         const argsStr = joinedArgs.length ? joinedArgs : "{}";
         const id = chunks[0]?.id;
         try {
@@ -27362,7 +27758,7 @@ function getBufferString(messages, humanPrefix = "Human", aiPrefix = "AI") {
 
 // ../../node_modules/@langchain/core/dist/utils/env.js
 var env_exports = {};
-__export(env_exports, {
+__export2(env_exports, {
   getEnv: () => getEnv,
   getEnvironmentVariable: () => getEnvironmentVariable,
   getRuntimeEnvironment: () => getRuntimeEnvironment,
@@ -27436,7 +27832,7 @@ var parse = import_dist.default.parse;
 
 // ../../node_modules/@langchain/core/dist/callbacks/base.js
 var base_exports = {};
-__export(base_exports, {
+__export2(base_exports, {
   BaseCallbackHandler: () => BaseCallbackHandler,
   callbackHandlerPrefersStreaming: () => callbackHandlerPrefersStreaming,
   isBaseCallbackHandler: () => isBaseCallbackHandler
@@ -32993,7 +33389,7 @@ function _checkEndpointEnvUnset(parsed) {
 }
 // ../../node_modules/@langchain/core/dist/tracers/base.js
 var base_exports2 = {};
-__export(base_exports2, {
+__export2(base_exports2, {
   BaseTracer: () => BaseTracer,
   isBaseTracer: () => isBaseTracer
 });
@@ -33431,7 +33827,7 @@ ${error.stack}` : "");
 // ../../node_modules/@langchain/core/dist/tracers/console.js
 var import_ansi_styles = __toESM(require_ansi_styles(), 1);
 var console_exports = {};
-__export(console_exports, { ConsoleCallbackHandler: () => ConsoleCallbackHandler });
+__export2(console_exports, { ConsoleCallbackHandler: () => ConsoleCallbackHandler });
 function wrap(style, text) {
   return `${style.open}${text}${style.close}`;
 }
@@ -33587,7 +33983,7 @@ function isTraceableFunction(x) {
 }
 // ../../node_modules/@langchain/core/dist/tracers/tracer_langchain.js
 var tracer_langchain_exports = {};
-__export(tracer_langchain_exports, { LangChainTracer: () => LangChainTracer });
+__export2(tracer_langchain_exports, { LangChainTracer: () => LangChainTracer });
 var LangChainTracer = class LangChainTracer2 extends BaseTracer {
   name = "langchain_tracer";
   projectName;
@@ -33708,7 +34104,7 @@ async function awaitAllCallbacks() {
 
 // ../../node_modules/@langchain/core/dist/callbacks/promises.js
 var promises_exports = {};
-__export(promises_exports, {
+__export2(promises_exports, {
   awaitAllCallbacks: () => awaitAllCallbacks,
   consumeCallback: () => consumeCallback
 });
@@ -33739,7 +34135,7 @@ var _getConfigureHooks = () => getContextVariable(LC_CONFIGURE_HOOKS_KEY) || [];
 
 // ../../node_modules/@langchain/core/dist/callbacks/manager.js
 var manager_exports = {};
-__export(manager_exports, {
+__export2(manager_exports, {
   BaseCallbackManager: () => BaseCallbackManager,
   BaseRunManager: () => BaseRunManager,
   CallbackManager: () => CallbackManager,
@@ -34331,7 +34727,7 @@ var AsyncLocalStorageProviderSingleton2 = new AsyncLocalStorageProvider2;
 
 // ../../node_modules/@langchain/core/dist/singletons/index.js
 var singletons_exports = {};
-__export(singletons_exports, {
+__export2(singletons_exports, {
   AsyncLocalStorageProviderSingleton: () => AsyncLocalStorageProviderSingleton2,
   MockAsyncLocalStorage: () => MockAsyncLocalStorage2,
   _CONTEXT_VARIABLES_KEY: () => _CONTEXT_VARIABLES_KEY
@@ -34525,7 +34921,7 @@ function getAbortSignalError(signal) {
 
 // ../../node_modules/@langchain/core/dist/utils/stream.js
 var stream_exports = {};
-__export(stream_exports, {
+__export2(stream_exports, {
   AsyncGeneratorWithSetup: () => AsyncGeneratorWithSetup,
   IterableReadableStream: () => IterableReadableStream,
   atee: () => atee,
@@ -34822,7 +35218,7 @@ var PatchError = class extends Error {
 
 // ../../node_modules/@langchain/core/dist/utils/fast-json-patch/src/core.js
 var core_exports = {};
-__export(core_exports, {
+__export2(core_exports, {
   JsonPatchError: () => JsonPatchError,
   _areEquals: () => _areEquals,
   applyOperation: () => applyOperation,
@@ -35150,7 +35546,7 @@ var fast_json_patch_default = {
 
 // ../../node_modules/@langchain/core/dist/tracers/log_stream.js
 var log_stream_exports = {};
-__export(log_stream_exports, {
+__export2(log_stream_exports, {
   LogStreamCallbackHandler: () => LogStreamCallbackHandler,
   RunLog: () => RunLog,
   RunLogPatch: () => RunLogPatch,
@@ -35407,7 +35803,7 @@ var LogStreamCallbackHandler = class extends BaseTracer {
 
 // ../../node_modules/@langchain/core/dist/outputs.js
 var outputs_exports = {};
-__export(outputs_exports, {
+__export2(outputs_exports, {
   ChatGenerationChunk: () => ChatGenerationChunk,
   GenerationChunk: () => GenerationChunk,
   RUN_KEY: () => RUN_KEY
@@ -35825,200 +36221,16 @@ 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_queue3 = __toESM(require_dist3(), 1);
 var async_caller_exports = {};
-__export(async_caller_exports, { AsyncCaller: () => AsyncCaller2 });
+__export2(async_caller_exports, { AsyncCaller: () => AsyncCaller2 });
+var pRetryModule = null;
+async function getPRetry() {
+  if (!pRetryModule)
+    pRetryModule = await Promise.resolve().then(() => (init_p_retry(), exports_p_retry));
+  return pRetryModule.default;
+}
 var STATUS_NO_RETRY = [
   400,
   401,
@@ -36056,8 +36268,9 @@ 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(() => pRetry2(() => callable(...args).catch((error) => {
+  async call(callable, ...args) {
+    const pRetry3 = await getPRetry();
+    return this.queue.add(() => pRetry3(() => callable(...args).catch((error) => {
       if (error instanceof Error)
         throw error;
       else
@@ -38715,7 +38928,7 @@ class Validator {
 
 // ../../node_modules/@langchain/core/dist/utils/json_schema.js
 var json_schema_exports = {};
-__export(json_schema_exports, {
+__export2(json_schema_exports, {
   Validator: () => Validator,
   deepCompareStrict: () => deepCompareStrict,
   toJsonSchema: () => toJsonSchema,
@@ -38768,7 +38981,7 @@ function validatesOnlyStrings(schema) {
 
 // ../../node_modules/@langchain/core/dist/runnables/graph.js
 var graph_exports = {};
-__export(graph_exports, { Graph: () => Graph });
+__export2(graph_exports, { Graph: () => Graph });
 function nodeDataStr(id, data) {
   if (id !== undefined && !validate(id))
     return id;
@@ -39021,6 +39234,7 @@ async function* consumeAsyncIterableInContext(context, iter) {
 }
 
 // ../../node_modules/@langchain/core/dist/runnables/base.js
+init_p_retry();
 import { z } from "zod/v3";
 function _coerceToDict2(value, defaultKey) {
   return value && !Array.isArray(value) && !(value instanceof Date) && typeof value === "object" ? value : { [defaultKey]: value };
@@ -40394,7 +40608,7 @@ var MappingDocumentTransformer = class extends BaseDocumentTransformer {
 
 // ../../node_modules/@langchain/core/dist/documents/index.js
 var documents_exports = {};
-__export(documents_exports, {
+__export2(documents_exports, {
   BaseDocumentTransformer: () => BaseDocumentTransformer,
   Document: () => Document,
   MappingDocumentTransformer: () => MappingDocumentTransformer
@@ -40661,7 +40875,7 @@ function getEncodingNameForModel(model) {
 }
 // ../../node_modules/@langchain/core/dist/utils/tiktoken.js
 var tiktoken_exports = {};
-__export(tiktoken_exports, {
+__export2(tiktoken_exports, {
   encodingForModel: () => encodingForModel,
   getEncoding: () => getEncoding
 });
@@ -49660,17 +49874,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);
       }
@@ -49682,15 +49905,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) {
@@ -49790,10 +50031,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");
@@ -49854,13 +50103,13 @@ class ElizaOS extends EventTarget {
       }));
       return { messageId, userMessage };
     } else {
-      const result = await handleMessageWithEntityContext(() => 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) {
@@ -50325,5 +50574,5 @@ export {
   AgentRuntime
 };
 
-//# debugId=1AE99B04D756580C64756E2164756E21
+//# debugId=DEC41F0963B99DD564756E2164756E21
 //# sourceMappingURL=index.node.js.map