@elizaos/core 1.6.2-alpha.9 → 1.6.2

package/dist/node/index.node.js

@@ -25,6 +25,7 @@ var __export = (target, all) => {
       set: (newValue) => all[name] = () => newValue
     });
 };
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // ../../node_modules/retry/lib/retry_operation.js
@@ -2291,6 +2292,9 @@ var require_parse_options = __commonJS((exports, module) => {
 var require_identifiers = __commonJS((exports, module) => {
   var numeric = /^[0-9]+$/;
   var compareIdentifiers = (a, b) => {
+    if (typeof a === "number" && typeof b === "number") {
+      return a === b ? 0 : a < b ? -1 : 1;
+    }
     const anum = numeric.test(a);
     const bnum = numeric.test(b);
     if (anum && bnum) {
@@ -2393,7 +2397,25 @@ var require_semver = __commonJS((exports, module) => {
       if (!(other instanceof SemVer)) {
         other = new SemVer(other, this.options);
       }
-      return compareIdentifiers(this.major, other.major) || compareIdentifiers(this.minor, other.minor) || compareIdentifiers(this.patch, other.patch);
+      if (this.major < other.major) {
+        return -1;
+      }
+      if (this.major > other.major) {
+        return 1;
+      }
+      if (this.minor < other.minor) {
+        return -1;
+      }
+      if (this.minor > other.minor) {
+        return 1;
+      }
+      if (this.patch < other.patch) {
+        return -1;
+      }
+      if (this.patch > other.patch) {
+        return 1;
+      }
+      return 0;
     }
     comparePre(other) {
       if (!(other instanceof SemVer)) {
@@ -3070,6 +3092,7 @@ var require_range = __commonJS((exports, module) => {
     return result;
   };
   var parseComparator = (comp, options) => {
+    comp = comp.replace(re[t.BUILD], "");
     debug("comp", comp, options);
     comp = replaceCarets(comp, options);
     debug("caret", comp);
@@ -9811,6 +9834,217 @@ Length provided: ${this.length}. Number of dictionaries provided: ${this.diction
   };
 });
 
+// src/utils/environment.ts
+var exports_environment = {};
+__export(exports_environment, {
+  setEnv: () => setEnv,
+  loadEnvConfig: () => loadEnvConfig,
+  initBrowserEnvironment: () => initBrowserEnvironment,
+  hasEnv: () => hasEnv,
+  getNumberEnv: () => getNumberEnv,
+  getEnvironment: () => getEnvironment,
+  getEnv: () => getEnv3,
+  getBooleanEnv: () => getBooleanEnv,
+  findEnvFile: () => findEnvFile,
+  detectEnvironment: () => detectEnvironment,
+  currentRuntime: () => currentRuntime,
+  Environment: () => Environment
+});
+function detectEnvironment() {
+  if (typeof process !== "undefined" && process.versions && process.versions.node) {
+    return "node";
+  }
+  if (typeof globalThis !== "undefined" && typeof globalThis.window !== "undefined" && typeof globalThis.window.document !== "undefined") {
+    return "browser";
+  }
+  return "unknown";
+}
+
+class BrowserEnvironmentStore {
+  store = {};
+  constructor() {
+    if (typeof globalThis !== "undefined" && globalThis.window && globalThis.window.ENV) {
+      this.store = { ...globalThis.window.ENV };
+    }
+    if (typeof globalThis !== "undefined" && globalThis.__ENV__) {
+      this.store = { ...this.store, ...globalThis.__ENV__ };
+    }
+  }
+  get(key) {
+    const value = this.store[key];
+    return value !== undefined ? String(value) : undefined;
+  }
+  set(key, value) {
+    this.store[key] = value;
+  }
+  has(key) {
+    return key in this.store;
+  }
+  getAll() {
+    return { ...this.store };
+  }
+}
+
+class Environment {
+  runtime;
+  browserStore;
+  cache = new Map;
+  constructor() {
+    this.runtime = detectEnvironment();
+    if (this.runtime === "browser") {
+      this.browserStore = new BrowserEnvironmentStore;
+    }
+  }
+  getRuntime() {
+    return this.runtime;
+  }
+  isNode() {
+    return this.runtime === "node";
+  }
+  isBrowser() {
+    return this.runtime === "browser";
+  }
+  get(key, defaultValue) {
+    if (this.cache.has(key)) {
+      const cached = this.cache.get(key);
+      return cached === undefined && defaultValue !== undefined ? defaultValue : cached;
+    }
+    let value;
+    switch (this.runtime) {
+      case "node":
+        if (typeof process !== "undefined" && process.env) {
+          value = process.env[key];
+        }
+        break;
+      case "browser":
+        if (this.browserStore) {
+          value = this.browserStore.get(key);
+        }
+        break;
+      default:
+        value = undefined;
+    }
+    this.cache.set(key, value);
+    return value === undefined && defaultValue !== undefined ? defaultValue : value;
+  }
+  set(key, value) {
+    const stringValue = String(value);
+    this.cache.delete(key);
+    switch (this.runtime) {
+      case "node":
+        if (typeof process !== "undefined" && process.env) {
+          process.env[key] = stringValue;
+        }
+        break;
+      case "browser":
+        if (this.browserStore) {
+          this.browserStore.set(key, value);
+        }
+        break;
+    }
+  }
+  has(key) {
+    const value = this.get(key);
+    return value !== undefined;
+  }
+  getAll() {
+    switch (this.runtime) {
+      case "node":
+        if (typeof process !== "undefined" && process.env) {
+          return { ...process.env };
+        }
+        break;
+      case "browser":
+        if (this.browserStore) {
+          return this.browserStore.getAll();
+        }
+        break;
+    }
+    return {};
+  }
+  getBoolean(key, defaultValue = false) {
+    const value = this.get(key);
+    if (value === undefined) {
+      return defaultValue;
+    }
+    return ["true", "1", "yes", "on"].includes(value.toLowerCase());
+  }
+  getNumber(key, defaultValue) {
+    const value = this.get(key);
+    if (value === undefined) {
+      return defaultValue;
+    }
+    const parsed = Number(value);
+    return isNaN(parsed) ? defaultValue : parsed;
+  }
+  clearCache() {
+    this.cache.clear();
+  }
+}
+function getEnvironment() {
+  if (!environmentInstance) {
+    environmentInstance = new Environment;
+  }
+  return environmentInstance;
+}
+function getEnv3(key, defaultValue) {
+  return getEnvironment().get(key, defaultValue);
+}
+function setEnv(key, value) {
+  getEnvironment().set(key, value);
+}
+function hasEnv(key) {
+  return getEnvironment().has(key);
+}
+function getBooleanEnv(key, defaultValue = false) {
+  return getEnvironment().getBoolean(key, defaultValue);
+}
+function getNumberEnv(key, defaultValue) {
+  return getEnvironment().getNumber(key, defaultValue);
+}
+function initBrowserEnvironment(config) {
+  const env = getEnvironment();
+  if (env.isBrowser()) {
+    Object.entries(config).forEach(([key, value]) => {
+      if (value !== undefined) {
+        env.set(key, value);
+      }
+    });
+  }
+}
+function findEnvFile() {
+  if (typeof process === "undefined" || !process.cwd) {
+    return null;
+  }
+  const fs = __require("node:fs");
+  const path = __require("node:path");
+  const possiblePaths = [path.join(process.cwd(), ".env"), path.join(process.cwd(), ".env.local")];
+  for (const envPath of possiblePaths) {
+    if (fs.existsSync(envPath)) {
+      return envPath;
+    }
+  }
+  return null;
+}
+async function loadEnvConfig(envPath) {
+  if (typeof process === "undefined" || !process.cwd) {
+    return {};
+  }
+  const dotenv = __require("dotenv");
+  const resolvedPath = envPath || findEnvFile();
+  if (resolvedPath) {
+    const result = dotenv.config({ path: resolvedPath });
+    if (result.error) {
+      throw result.error;
+    }
+  }
+  return process.env;
+}
+var environmentInstance = null, currentRuntime;
+var init_environment = __esm(() => {
+  currentRuntime = detectEnvironment();
+});
+
 // ../../node_modules/picocolors/picocolors.js
 var require_picocolors = __commonJS((exports, module) => {
   var p = process || {};
@@ -10499,24 +10733,6 @@ var require_get_proto = __commonJS((exports, module) => {
   } : null;
 });
 
-// ../../node_modules/async-function/index.js
-var require_async_function = __commonJS((exports, module) => {
-  var cached = async function() {}.constructor;
-  module.exports = () => cached;
-});
-
-// ../../node_modules/generator-function/index.js
-var require_generator_function = __commonJS((exports, module) => {
-  var cached = function* () {}.constructor;
-  module.exports = () => cached;
-});
-
-// ../../node_modules/async-generator-function/index.js
-var require_async_generator_function = __commonJS((exports, module) => {
-  var cached = async function* () {}.constructor;
-  module.exports = () => cached;
-});
-
 // ../../node_modules/hasown/index.js
 var require_hasown = __commonJS((exports, module) => {
   var call = Function.prototype.call;
@@ -10543,6 +10759,12 @@ var require_get_intrinsic = __commonJS((exports, module) => {
   var pow = require_pow();
   var round = require_round();
   var sign = require_sign();
+  var $Function = Function;
+  var getEvalledConstructor = function(expressionSyntax) {
+    try {
+      return $Function('"use strict"; return (' + expressionSyntax + ").constructor;")();
+    } catch (e) {}
+  };
   var $gOPD = require_gopd();
   var $defineProperty = require_es_define_property();
   var throwTypeError = function() {
@@ -10597,7 +10819,7 @@ var require_get_intrinsic = __commonJS((exports, module) => {
     "%Float32Array%": typeof Float32Array === "undefined" ? undefined3 : Float32Array,
     "%Float64Array%": typeof Float64Array === "undefined" ? undefined3 : Float64Array,
     "%FinalizationRegistry%": typeof FinalizationRegistry === "undefined" ? undefined3 : FinalizationRegistry,
-    "%Function%": Function,
+    "%Function%": $Function,
     "%GeneratorFunction%": needsEval,
     "%Int8Array%": typeof Int8Array === "undefined" ? undefined3 : Int8Array,
     "%Int16Array%": typeof Int16Array === "undefined" ? undefined3 : Int16Array,
@@ -10660,17 +10882,14 @@ var require_get_intrinsic = __commonJS((exports, module) => {
     }
   }
   var errorProto;
-  var getAsyncFunction = require_async_function();
-  var getGeneratorFunction = require_generator_function();
-  var getAsyncGeneratorFunction = require_async_generator_function();
   var doEval = function doEval(name) {
     var value;
     if (name === "%AsyncFunction%") {
-      value = getAsyncFunction() || undefined;
+      value = getEvalledConstructor("async function () {}");
     } else if (name === "%GeneratorFunction%") {
-      value = getGeneratorFunction() || undefined;
+      value = getEvalledConstructor("function* () {}");
     } else if (name === "%AsyncGeneratorFunction%") {
-      value = getAsyncGeneratorFunction() || undefined;
+      value = getEvalledConstructor("async function* () {}");
     } else if (name === "%AsyncGenerator%") {
       var fn = doEval("%AsyncGeneratorFunction%");
       if (fn) {
@@ -24970,6 +25189,7 @@ var ServiceType = {
   WALLET: "wallet",
   LP_POOL: "lp_pool",
   TOKEN_DATA: "token_data",
+  MESSAGE_SERVICE: "message_service",
   MESSAGE: "message",
   POST: "post",
   UNKNOWN: "unknown"
@@ -25770,7 +25990,7 @@ var getDefaultProjectName = () => {
 };
 
 // ../../node_modules/langsmith/dist/index.js
-var __version__ = "0.3.71";
+var __version__ = "0.3.74";
 
 // ../../node_modules/langsmith/dist/utils/env.js
 var globalEnv;
@@ -25815,8 +26035,8 @@ function getRuntimeEnvironment() {
   }
   return runtimeEnvironment;
 }
-function getLangChainEnvVarsMetadata() {
-  const allEnvVars = getEnvironmentVariables() || {};
+function getLangSmithEnvVarsMetadata() {
+  const allEnvVars = getLangSmithEnvironmentVariables();
   const envVars = {};
   const excluded = [
     "LANGCHAIN_API_KEY",
@@ -25831,7 +26051,7 @@ function getLangChainEnvVarsMetadata() {
     "LANGSMITH_SESSION"
   ];
   for (const [key, value] of Object.entries(allEnvVars)) {
-    if ((key.startsWith("LANGCHAIN_") || key.startsWith("LANGSMITH_")) && typeof value === "string" && !excluded.includes(key) && !key.toLowerCase().includes("key") && !key.toLowerCase().includes("secret") && !key.toLowerCase().includes("token")) {
+    if (typeof value === "string" && !excluded.includes(key) && !key.toLowerCase().includes("key") && !key.toLowerCase().includes("secret") && !key.toLowerCase().includes("token")) {
       if (key === "LANGCHAIN_REVISION_ID") {
         envVars["revision_id"] = value;
       } else {
@@ -25841,18 +26061,22 @@ function getLangChainEnvVarsMetadata() {
   }
   return envVars;
 }
-function getEnvironmentVariables() {
+function getLangSmithEnvironmentVariables() {
+  const envVars = {};
   try {
     if (typeof process !== "undefined" && process.env) {
-      return Object.entries(process.env).reduce((acc, [key, value]) => {
-        acc[key] = String(value);
-        return acc;
-      }, {});
+      for (const [key, value] of Object.entries(process.env)) {
+        if ((key.startsWith("LANGCHAIN_") || key.startsWith("LANGSMITH_")) && value != null) {
+          if ((key.toLowerCase().includes("key") || key.toLowerCase().includes("secret") || key.toLowerCase().includes("token")) && typeof value === "string") {
+            envVars[key] = value.slice(0, 2) + "*".repeat(value.length - 4) + value.slice(-2);
+          } else {
+            envVars[key] = value;
+          }
+        }
+      }
     }
-    return;
-  } catch (e) {
-    return;
-  }
+  } catch (e) {}
+  return envVars;
 }
 function getEnvironmentVariable(name) {
   try {
@@ -26727,9 +26951,9 @@ function replaceGetterValues(replacer) {
 }
 
 // ../../node_modules/langsmith/dist/client.js
-function mergeRuntimeEnvIntoRun(run) {
+function mergeRuntimeEnvIntoRun(run, cachedEnvVars) {
   const runtimeEnv = getRuntimeEnvironment();
-  const envVars = getLangChainEnvVarsMetadata();
+  const envVars = cachedEnvVars ?? getLangSmithEnvVarsMetadata();
   const extra = run.extra ?? {};
   const metadata = extra.metadata;
   run.extra = {
@@ -27035,6 +27259,12 @@ class Client {
       writable: true,
       value: undefined
     });
+    Object.defineProperty(this, "cachedLSEnvVarsForMetadata", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: undefined
+    });
     Object.defineProperty(this, "multipartStreamingDisabled", {
       enumerable: true,
       configurable: true,
@@ -27089,6 +27319,7 @@ class Client {
     if (getOtelEnabled()) {
       this.langSmithToOTELTranslator = new LangSmithToOTELTranslator;
     }
+    this.cachedLSEnvVarsForMetadata = getLangSmithEnvVarsMetadata();
   }
   static getDefaultClientConfig() {
     const apiKey = getLangSmithEnvironmentVariable("API_KEY");
@@ -27400,7 +27631,7 @@ class Client {
   async processRunOperation(item) {
     clearTimeout(this.autoBatchTimeout);
     this.autoBatchTimeout = undefined;
-    item.item = mergeRuntimeEnvIntoRun(item.item);
+    item.item = mergeRuntimeEnvIntoRun(item.item, this.cachedLSEnvVarsForMetadata);
     const itemPromise = this.autoBatchQueue.push(item);
     if (this.manualFlushMode) {
       return itemPromise;
@@ -27515,7 +27746,7 @@ class Client {
       }).catch(console.error);
       return;
     }
-    const mergedRunCreateParam = mergeRuntimeEnvIntoRun(runCreate);
+    const mergedRunCreateParam = mergeRuntimeEnvIntoRun(runCreate, this.cachedLSEnvVarsForMetadata);
     if (options?.apiKey !== undefined) {
       headers["x-api-key"] = options.apiKey;
     }
@@ -28017,6 +28248,9 @@ Context: ${context}`);
       is_root: isRoot,
       order
     };
+    if (body.select.includes("child_run_ids")) {
+      warnOnce("Deprecated: 'child_run_ids' in the listRuns select parameter is deprecated and will be removed in a future version.");
+    }
     let runsYielded = 0;
     for await (const runs of this._getCursorPaginatedList("/runs/query", body)) {
       if (limit) {
@@ -39079,171 +39313,8 @@ var import_handlebars = __toESM(require_lib(), 1);
 var import_unique_names_generator = __toESM(require_dist4(), 1);
 import { z as z2 } from "zod";
 
-// src/utils/environment.ts
-function detectEnvironment() {
-  if (typeof process !== "undefined" && process.versions && process.versions.node) {
-    return "node";
-  }
-  if (typeof globalThis !== "undefined" && typeof globalThis.window !== "undefined" && typeof globalThis.window.document !== "undefined") {
-    return "browser";
-  }
-  return "unknown";
-}
-
-class BrowserEnvironmentStore {
-  store = {};
-  constructor() {
-    if (typeof globalThis !== "undefined" && globalThis.window && globalThis.window.ENV) {
-      this.store = { ...globalThis.window.ENV };
-    }
-    if (typeof globalThis !== "undefined" && globalThis.__ENV__) {
-      this.store = { ...this.store, ...globalThis.__ENV__ };
-    }
-  }
-  get(key) {
-    const value = this.store[key];
-    return value !== undefined ? String(value) : undefined;
-  }
-  set(key, value) {
-    this.store[key] = value;
-  }
-  has(key) {
-    return key in this.store;
-  }
-  getAll() {
-    return { ...this.store };
-  }
-}
-
-class Environment {
-  runtime;
-  browserStore;
-  cache = new Map;
-  constructor() {
-    this.runtime = detectEnvironment();
-    if (this.runtime === "browser") {
-      this.browserStore = new BrowserEnvironmentStore;
-    }
-  }
-  getRuntime() {
-    return this.runtime;
-  }
-  isNode() {
-    return this.runtime === "node";
-  }
-  isBrowser() {
-    return this.runtime === "browser";
-  }
-  get(key, defaultValue) {
-    if (this.cache.has(key)) {
-      const cached = this.cache.get(key);
-      return cached === undefined && defaultValue !== undefined ? defaultValue : cached;
-    }
-    let value;
-    switch (this.runtime) {
-      case "node":
-        if (typeof process !== "undefined" && process.env) {
-          value = process.env[key];
-        }
-        break;
-      case "browser":
-        if (this.browserStore) {
-          value = this.browserStore.get(key);
-        }
-        break;
-      default:
-        value = undefined;
-    }
-    this.cache.set(key, value);
-    return value === undefined && defaultValue !== undefined ? defaultValue : value;
-  }
-  set(key, value) {
-    const stringValue = String(value);
-    this.cache.delete(key);
-    switch (this.runtime) {
-      case "node":
-        if (typeof process !== "undefined" && process.env) {
-          process.env[key] = stringValue;
-        }
-        break;
-      case "browser":
-        if (this.browserStore) {
-          this.browserStore.set(key, value);
-        }
-        break;
-    }
-  }
-  has(key) {
-    const value = this.get(key);
-    return value !== undefined;
-  }
-  getAll() {
-    switch (this.runtime) {
-      case "node":
-        if (typeof process !== "undefined" && process.env) {
-          return { ...process.env };
-        }
-        break;
-      case "browser":
-        if (this.browserStore) {
-          return this.browserStore.getAll();
-        }
-        break;
-    }
-    return {};
-  }
-  getBoolean(key, defaultValue = false) {
-    const value = this.get(key);
-    if (value === undefined) {
-      return defaultValue;
-    }
-    return ["true", "1", "yes", "on"].includes(value.toLowerCase());
-  }
-  getNumber(key, defaultValue) {
-    const value = this.get(key);
-    if (value === undefined) {
-      return defaultValue;
-    }
-    const parsed = Number(value);
-    return isNaN(parsed) ? defaultValue : parsed;
-  }
-  clearCache() {
-    this.cache.clear();
-  }
-}
-var environmentInstance = null;
-function getEnvironment() {
-  if (!environmentInstance) {
-    environmentInstance = new Environment;
-  }
-  return environmentInstance;
-}
-function getEnv3(key, defaultValue) {
-  return getEnvironment().get(key, defaultValue);
-}
-function setEnv(key, value) {
-  getEnvironment().set(key, value);
-}
-function hasEnv(key) {
-  return getEnvironment().has(key);
-}
-function getBooleanEnv(key, defaultValue = false) {
-  return getEnvironment().getBoolean(key, defaultValue);
-}
-function getNumberEnv(key, defaultValue) {
-  return getEnvironment().getNumber(key, defaultValue);
-}
-function initBrowserEnvironment(config) {
-  const env = getEnvironment();
-  if (env.isBrowser()) {
-    Object.entries(config).forEach(([key, value]) => {
-      if (value !== undefined) {
-        env.set(key, value);
-      }
-    });
-  }
-}
-var currentRuntime = detectEnvironment();
+// src/logger.ts
+init_environment();
 // ../../node_modules/adze/dist/tools.js
 class Tools {
   globalStore;
@@ -41379,6 +41450,7 @@ var recentLogs = () => globalInMemoryDestination.recentLogs();
 var logger_default = logger;
 
 // src/utils.ts
+init_environment();
 function upgradeDoubleToTriple(tpl) {
   return tpl.replace(/(?<!{){{(?![{#\/!>])([\s\S]*?)}}/g, (_match, inner) => {
     if (inner.trim() === "else")
@@ -42090,6 +42162,10 @@ function parseAndValidateCharacter(jsonString) {
 function isValidCharacter(data2) {
   return validateCharacter(data2).success;
 }
+
+// src/index.node.ts
+init_environment();
+
 // src/utils/buffer.ts
 function hasNativeBuffer() {
   return typeof Buffer !== "undefined" && typeof Buffer.from === "function";
@@ -42490,6 +42566,67 @@ function formatActions(actions) {
 class DatabaseAdapter {
   db;
 }
+// src/character.ts
+function parseCharacter(input) {
+  if (typeof input === "string") {
+    throw new Error(`Character path provided but must be loaded first: ${input}`);
+  }
+  if (typeof input === "object") {
+    const validationResult = validateCharacter(input);
+    if (!validationResult.success) {
+      const errorDetails = validationResult.error?.issues ? validationResult.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ") : validationResult.error?.message || "Unknown validation error";
+      throw new Error(`Character validation failed: ${errorDetails}`);
+    }
+    return validationResult.data;
+  }
+  throw new Error("Invalid character input format");
+}
+function validateCharacterConfig(character) {
+  const validationResult = validateCharacter(character);
+  if (validationResult.success) {
+    return {
+      isValid: true,
+      errors: []
+    };
+  }
+  const errors = validationResult.error?.issues ? validationResult.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`) : [validationResult.error?.message || "Unknown validation error"];
+  return {
+    isValid: false,
+    errors
+  };
+}
+function mergeCharacterDefaults(char) {
+  const defaults = {
+    settings: {},
+    plugins: [],
+    bio: []
+  };
+  return {
+    ...defaults,
+    ...char,
+    name: char.name || "Unnamed Character"
+  };
+}
+function buildCharacterPlugins(env2 = process.env) {
+  const plugins = [
+    "@elizaos/plugin-sql",
+    ...env2.ANTHROPIC_API_KEY?.trim() ? ["@elizaos/plugin-anthropic"] : [],
+    ...env2.OPENROUTER_API_KEY?.trim() ? ["@elizaos/plugin-openrouter"] : [],
+    ...env2.OPENAI_API_KEY?.trim() ? ["@elizaos/plugin-openai"] : [],
+    ...env2.GOOGLE_GENERATIVE_AI_API_KEY?.trim() ? ["@elizaos/plugin-google-genai"] : [],
+    ...env2.DISCORD_API_TOKEN?.trim() ? ["@elizaos/plugin-discord"] : [],
+    ...env2.TWITTER_API_KEY?.trim() && env2.TWITTER_API_SECRET_KEY?.trim() && env2.TWITTER_ACCESS_TOKEN?.trim() && env2.TWITTER_ACCESS_TOKEN_SECRET?.trim() ? ["@elizaos/plugin-twitter"] : [],
+    ...env2.TELEGRAM_BOT_TOKEN?.trim() ? ["@elizaos/plugin-telegram"] : [],
+    ...(() => {
+      const ignore = env2.IGNORE_BOOTSTRAP?.trim().toLowerCase();
+      const shouldIgnore = ignore === "true" || ignore === "1" || ignore === "yes";
+      return shouldIgnore ? [] : ["@elizaos/plugin-bootstrap"];
+    })(),
+    ...!env2.ANTHROPIC_API_KEY?.trim() && !env2.OPENROUTER_API_KEY?.trim() && !env2.OPENAI_API_KEY?.trim() && !env2.GOOGLE_GENERATIVE_AI_API_KEY?.trim() ? ["@elizaos/plugin-ollama"] : []
+  ];
+  return plugins;
+}
+
 // src/memory.ts
 function createMessageMemory(params) {
   return {
@@ -42862,6 +42999,754 @@ function v43(options, buf, offset) {
   return _v4(options, buf, offset);
 }
 var v4_default = v43;
+// src/runtime.ts
+init_environment();
+
+// src/services/default-message-service.ts
+var latestResponseIds = new Map;
+
+class DefaultMessageService {
+  async handleMessage(runtime, message, callback, options) {
+    const opts = {
+      maxRetries: options?.maxRetries ?? 3,
+      timeoutDuration: options?.timeoutDuration ?? 60 * 60 * 1000,
+      useMultiStep: options?.useMultiStep ?? parseBooleanFromText2(runtime.getSetting("USE_MULTI_STEP")),
+      maxMultiStepIterations: options?.maxMultiStepIterations ?? parseInt(runtime.getSetting("MAX_MULTISTEP_ITERATIONS") || "6")
+    };
+    let timeoutId = undefined;
+    const responseId = v4_default();
+    try {
+      runtime.logger.info(`[MessageService] Message received from ${message.entityId} in room ${message.roomId}`);
+      if (!latestResponseIds.has(runtime.agentId)) {
+        latestResponseIds.set(runtime.agentId, new Map);
+      }
+      const agentResponses = latestResponseIds.get(runtime.agentId);
+      if (!agentResponses)
+        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}`);
+      }
+      agentResponses.set(message.roomId, responseId);
+      const runId = runtime.startRun();
+      const startTime = Date.now();
+      await runtime.emitEvent("RUN_STARTED" /* RUN_STARTED */, {
+        runtime,
+        runId,
+        messageId: message.id,
+        roomId: message.roomId,
+        entityId: message.entityId,
+        startTime,
+        status: "started",
+        source: "messageHandler",
+        metadata: message.content
+      });
+      const timeoutPromise = new Promise((_, reject) => {
+        timeoutId = setTimeout(async () => {
+          await runtime.emitEvent("RUN_TIMEOUT" /* RUN_TIMEOUT */, {
+            runtime,
+            runId,
+            messageId: message.id,
+            roomId: message.roomId,
+            entityId: message.entityId,
+            startTime,
+            status: "timeout",
+            endTime: Date.now(),
+            duration: Date.now() - startTime,
+            error: "Run exceeded timeout",
+            source: "messageHandler"
+          });
+          reject(new Error("Run exceeded timeout"));
+        }, opts.timeoutDuration);
+      });
+      const processingPromise = this.processMessage(runtime, message, callback, responseId, runId, startTime, opts);
+      const result = await Promise.race([processingPromise, timeoutPromise]);
+      clearTimeout(timeoutId);
+      return result;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      runtime.logger.error({ error }, "[MessageService] Error in handleMessage:");
+      throw error;
+    }
+  }
+  async processMessage(runtime, message, callback, responseId, runId, startTime, opts) {
+    try {
+      const agentResponses = latestResponseIds.get(runtime.agentId);
+      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})`);
+        await this.emitRunEnded(runtime, runId, message, startTime, "self");
+        return {
+          didRespond: false,
+          responseContent: null,
+          responseMessages: [],
+          state: {},
+          mode: "none"
+        };
+      }
+      runtime.logger.debug(`[MessageService] Processing message: ${truncateToCompleteSentence(message.content.text || "", 50)}...`);
+      runtime.logger.debug("[MessageService] Saving message to memory and queueing embeddings");
+      let memoryToQueue;
+      if (message.id) {
+        const existingMemory = await runtime.getMemoryById(message.id);
+        if (existingMemory) {
+          runtime.logger.debug("[MessageService] Memory already exists, skipping creation");
+          memoryToQueue = existingMemory;
+        } else {
+          const createdMemoryId = await runtime.createMemory(message, "messages");
+          memoryToQueue = { ...message, id: createdMemoryId };
+        }
+        await runtime.queueEmbeddingGeneration(memoryToQueue, "high");
+      } else {
+        const memoryId = await runtime.createMemory(message, "messages");
+        message.id = memoryId;
+        memoryToQueue = { ...message, id: memoryId };
+        await runtime.queueEmbeddingGeneration(memoryToQueue, "normal");
+      }
+      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");
+        await this.emitRunEnded(runtime, runId, message, startTime, "off");
+        return {
+          didRespond: false,
+          responseContent: null,
+          responseMessages: [],
+          state: {},
+          mode: "none"
+        };
+      }
+      if (agentUserState === "MUTED" && !message.content.text?.toLowerCase().includes(runtime.character.name.toLowerCase())) {
+        runtime.logger.debug(`[MessageService] Ignoring muted room ${message.roomId}`);
+        await this.emitRunEnded(runtime, runId, message, startTime, "muted");
+        return {
+          didRespond: false,
+          responseContent: null,
+          responseMessages: [],
+          state: {},
+          mode: "none"
+        };
+      }
+      let state = await runtime.composeState(message, ["ANXIETY", "ENTITIES", "CHARACTER", "RECENT_MESSAGES", "ACTIONS"], true);
+      const mentionContext = message.content.mentionContext;
+      const room = await runtime.getRoom(message.roomId);
+      if (message.content.attachments && message.content.attachments.length > 0) {
+        message.content.attachments = await this.processAttachments(runtime, message.content.attachments);
+        if (message.id) {
+          await runtime.updateMemory({ id: message.id, content: message.content });
+        }
+      }
+      const responseDecision = this.shouldRespond(runtime, message, room ?? undefined, mentionContext);
+      runtime.logger.debug(`[MessageService] Response decision: ${JSON.stringify(responseDecision)}`);
+      let shouldRespondToMessage = true;
+      if (responseDecision.skipEvaluation) {
+        runtime.logger.debug(`[MessageService] Skipping evaluation for ${runtime.character.name} (${responseDecision.reason})`);
+        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})`);
+        const response = await runtime.useModel(ModelType.TEXT_SMALL, {
+          prompt: shouldRespondPrompt
+        });
+        runtime.logger.debug(`[MessageService] LLM evaluation result:
+${response}`);
+        const responseObject = parseKeyValueXml(response);
+        runtime.logger.debug({ responseObject }, "[MessageService] Parsed evaluation result:");
+        const nonResponseActions = ["IGNORE", "NONE"];
+        shouldRespondToMessage = responseObject?.action && !nonResponseActions.includes(responseObject.action.toUpperCase());
+      }
+      let responseContent = null;
+      let responseMessages = [];
+      let mode = "none";
+      if (shouldRespondToMessage) {
+        const result = opts.useMultiStep ? await this.runMultiStepCore(runtime, message, state, callback, opts) : await this.runSingleShotCore(runtime, message, state, opts);
+        responseContent = result.responseContent;
+        responseMessages = result.responseMessages;
+        state = result.state;
+        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}`);
+          return {
+            didRespond: false,
+            responseContent: null,
+            responseMessages: [],
+            state,
+            mode: "none"
+          };
+        }
+        if (responseContent && message.id) {
+          responseContent.inReplyTo = createUniqueUuid(runtime, message.id);
+        }
+        if (responseContent?.providers?.length && responseContent.providers.length > 0) {
+          state = await runtime.composeState(message, responseContent.providers || []);
+        }
+        if (responseContent) {
+          if (mode === "simple") {
+            if (responseContent.providers && responseContent.providers.length > 0) {
+              runtime.logger.debug({ providers: responseContent.providers }, "[MessageService] 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");
+              responseContent.actionCallbacks = content;
+              if (callback) {
+                return callback(content);
+              }
+              return [];
+            });
+          }
+        }
+      } else {
+        runtime.logger.debug("[MessageService] Agent decided not to respond (shouldRespond is false).");
+        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}`);
+          await this.emitRunEnded(runtime, runId, message, startTime, "replaced");
+          return {
+            didRespond: false,
+            responseContent: null,
+            responseMessages: [],
+            state,
+            mode: "none"
+          };
+        }
+        if (!message.id) {
+          runtime.logger.error("[MessageService] Message ID is missing, cannot create ignore response.");
+          await this.emitRunEnded(runtime, runId, message, startTime, "noMessageId");
+          return {
+            didRespond: false,
+            responseContent: null,
+            responseMessages: [],
+            state,
+            mode: "none"
+          };
+        }
+        const ignoreContent = {
+          thought: "Agent decided not to respond to this message.",
+          actions: ["IGNORE"],
+          simple: true,
+          inReplyTo: createUniqueUuid(runtime, message.id)
+        };
+        if (callback) {
+          await callback(ignoreContent);
+        }
+        const ignoreMemory = {
+          id: asUUID(v4_default()),
+          entityId: runtime.agentId,
+          agentId: runtime.agentId,
+          content: ignoreContent,
+          roomId: message.roomId,
+          createdAt: Date.now()
+        };
+        await runtime.createMemory(ignoreMemory, "messages");
+        runtime.logger.debug("[MessageService] Saved ignore response to memory", `memoryId: ${ignoreMemory.id}`);
+      }
+      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");
+        if (responseContent) {
+          responseContent.evalCallbacks = content;
+        }
+        if (callback) {
+          return callback(content);
+        }
+        return [];
+      }, responseMessages);
+      let entityName = "noname";
+      if (message.metadata && "entityName" in message.metadata) {
+        entityName = message.metadata.entityName;
+      }
+      const isDM = message.content?.channelType === "DM" /* DM */;
+      let roomName = entityName;
+      if (!isDM) {
+        const roomDatas = await runtime.getRoomsByIds([message.roomId]);
+        if (roomDatas?.length) {
+          const roomData = roomDatas[0];
+          if (roomData.name) {
+            roomName = roomData.name;
+          }
+          if (roomData.worldId) {
+            const worldData = await runtime.getWorld(roomData.worldId);
+            if (worldData) {
+              roomName = worldData.name + "-" + roomName;
+            }
+          }
+        }
+      }
+      const date2 = new Date;
+      const availableActions = state.data?.providers?.ACTIONS?.data?.actionsData?.map((a) => a.name) || [-1];
+      const logData = {
+        at: date2.toString(),
+        timestamp: parseInt("" + date2.getTime() / 1000),
+        messageId: message.id,
+        userEntityId: message.entityId,
+        input: message.content.text,
+        thought: responseContent?.thought,
+        simple: responseContent?.simple,
+        availableActions,
+        actions: responseContent?.actions,
+        providers: responseContent?.providers,
+        irt: responseContent?.inReplyTo,
+        output: responseContent?.text,
+        entityName,
+        source: message.content.source,
+        channelType: message.content.channelType,
+        roomName
+      };
+      await runtime.emitEvent("RUN_ENDED" /* RUN_ENDED */, {
+        runtime,
+        runId,
+        messageId: message.id,
+        roomId: message.roomId,
+        entityId: message.entityId,
+        startTime,
+        status: "completed",
+        endTime: Date.now(),
+        duration: Date.now() - startTime,
+        source: "messageHandler",
+        entityName,
+        responseContent,
+        metadata: logData
+      });
+      return {
+        didRespond: shouldRespondToMessage,
+        responseContent,
+        responseMessages,
+        state,
+        mode
+      };
+    } catch (error) {
+      console.error("error is", error);
+      await runtime.emitEvent("RUN_ENDED" /* RUN_ENDED */, {
+        runtime,
+        runId,
+        messageId: message.id,
+        roomId: message.roomId,
+        entityId: message.entityId,
+        startTime,
+        status: "error",
+        endTime: Date.now(),
+        duration: Date.now() - startTime,
+        error: error.message,
+        source: "messageHandler"
+      });
+      throw error;
+    }
+  }
+  shouldRespond(runtime, message, room, mentionContext) {
+    if (!room) {
+      return { shouldRespond: false, skipEvaluation: true, reason: "no room context" };
+    }
+    function normalizeEnvList(value) {
+      if (!value || typeof value !== "string")
+        return [];
+      const cleaned = value.trim().replace(/^\[|\]$/g, "");
+      return cleaned.split(",").map((v) => v.trim()).filter(Boolean);
+    }
+    const alwaysRespondChannels = [
+      "DM" /* DM */,
+      "VOICE_DM" /* VOICE_DM */,
+      "SELF" /* SELF */,
+      "API" /* API */
+    ];
+    const alwaysRespondSources = ["client_chat"];
+    const customChannels = normalizeEnvList(runtime.getSetting("ALWAYS_RESPOND_CHANNELS") || runtime.getSetting("SHOULD_RESPOND_BYPASS_TYPES"));
+    const customSources = normalizeEnvList(runtime.getSetting("ALWAYS_RESPOND_SOURCES") || runtime.getSetting("SHOULD_RESPOND_BYPASS_SOURCES"));
+    const respondChannels = new Set([...alwaysRespondChannels.map((t) => t.toString()), ...customChannels].map((s) => s.trim().toLowerCase()));
+    const respondSources = [...alwaysRespondSources, ...customSources].map((s) => s.trim().toLowerCase());
+    const roomType = room.type?.toString().toLowerCase();
+    const sourceStr = message.content.source?.toLowerCase() || "";
+    if (respondChannels.has(roomType)) {
+      return { shouldRespond: true, skipEvaluation: true, reason: `private channel: ${roomType}` };
+    }
+    if (respondSources.some((pattern) => sourceStr.includes(pattern))) {
+      return {
+        shouldRespond: true,
+        skipEvaluation: true,
+        reason: `whitelisted source: ${sourceStr}`
+      };
+    }
+    const hasPlatformMention = !!(mentionContext?.isMention || mentionContext?.isReply);
+    if (hasPlatformMention) {
+      const mentionType = mentionContext?.isMention ? "mention" : "reply";
+      return { shouldRespond: true, skipEvaluation: true, reason: `platform ${mentionType}` };
+    }
+    return { shouldRespond: false, skipEvaluation: false, reason: "needs LLM evaluation" };
+  }
+  async processAttachments(runtime, attachments) {
+    if (!attachments || attachments.length === 0) {
+      return [];
+    }
+    runtime.logger.debug(`[MessageService] Processing ${attachments.length} attachment(s)`);
+    const processedAttachments = [];
+    for (const attachment of attachments) {
+      try {
+        const processedAttachment = { ...attachment };
+        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}`);
+          let imageUrl = url;
+          if (!isRemote) {
+            const res = await fetch(url);
+            if (!res.ok)
+              throw new Error(`Failed to fetch image: ${res.statusText}`);
+            const arrayBuffer = await res.arrayBuffer();
+            const buffer = Buffer.from(arrayBuffer);
+            const contentType = res.headers.get("content-type") || "application/octet-stream";
+            imageUrl = `data:${contentType};base64,${buffer.toString("base64")}`;
+          }
+          try {
+            const response = await runtime.useModel(ModelType.IMAGE_DESCRIPTION, {
+              prompt: imageDescriptionTemplate,
+              imageUrl
+            });
+            if (typeof response === "string") {
+              const parsedXml = parseKeyValueXml(response);
+              if (parsedXml && (parsedXml.description || parsedXml.text)) {
+                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)}...`);
+              } else {
+                const responseStr = response;
+                const titleMatch = responseStr.match(/<title>([^<]+)<\/title>/);
+                const descMatch = responseStr.match(/<description>([^<]+)<\/description>/);
+                const textMatch = responseStr.match(/<text>([^<]+)<\/text>/);
+                if (titleMatch || descMatch || textMatch) {
+                  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)}...`);
+                } else {
+                  runtime.logger.warn(`[MessageService] 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)}...`);
+            } else {
+              runtime.logger.warn(`[MessageService] Unexpected response format for image description`);
+            }
+          } catch (error) {
+            runtime.logger.error({ error }, `[MessageService] Error generating image description:`);
+          }
+        } else if (attachment.contentType === "document" /* DOCUMENT */ && !attachment.text) {
+          const res = await fetch(url);
+          if (!res.ok)
+            throw new Error(`Failed to fetch document: ${res.statusText}`);
+          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}`);
+            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)}...`);
+          } else {
+            runtime.logger.warn(`[MessageService] Skipping non-plain-text document: ${contentType}`);
+          }
+        }
+        processedAttachments.push(processedAttachment);
+      } catch (error) {
+        runtime.logger.error({ error, attachmentUrl: attachment.url }, `[MessageService] Failed to process attachment ${attachment.url}:`);
+        processedAttachments.push(attachment);
+      }
+    }
+    return processedAttachments;
+  }
+  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");
+    }
+    const prompt = composePromptFromState({
+      state,
+      template: runtime.character.templates?.messageHandlerTemplate || messageHandlerTemplate
+    });
+    let responseContent = null;
+    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 ***");
+      const parsedXml = parseKeyValueXml(response);
+      runtime.logger.debug({ parsedXml }, "[MessageService] *** Parsed XML Content ***");
+      if (parsedXml) {
+        responseContent = {
+          ...parsedXml,
+          thought: parsedXml.thought || "",
+          actions: parsedXml.actions || ["IGNORE"],
+          providers: parsedXml.providers || [],
+          text: parsedXml.text || "",
+          simple: parsedXml.simple || false
+        };
+      } else {
+        responseContent = null;
+      }
+      retries++;
+      if (!responseContent?.thought || !responseContent?.actions) {
+        runtime.logger.warn({ response, parsedXml, responseContent }, "[MessageService] *** Missing required fields (thought or actions), retrying... ***");
+      }
+    }
+    if (!responseContent) {
+      return { responseContent: null, responseMessages: [], state, mode: "none" };
+    }
+    if (responseContent.actions && responseContent.actions.length > 1) {
+      const isIgnore = (a) => typeof a === "string" && a.toUpperCase() === "IGNORE";
+      const hasIgnore = responseContent.actions.some(isIgnore);
+      if (hasIgnore) {
+        if (!responseContent.text || responseContent.text.trim() === "") {
+          responseContent.actions = ["IGNORE"];
+        } else {
+          const filtered = responseContent.actions.filter((a) => !isIgnore(a));
+          responseContent.actions = filtered.length ? filtered : ["REPLY"];
+        }
+      }
+    }
+    const isSimple = responseContent.actions?.length === 1 && typeof responseContent.actions[0] === "string" && responseContent.actions[0].toUpperCase() === "REPLY" && (!responseContent.providers || responseContent.providers.length === 0);
+    responseContent.simple = isSimple;
+    const responseMessages = [
+      {
+        id: asUUID(v4_default()),
+        entityId: runtime.agentId,
+        agentId: runtime.agentId,
+        content: responseContent,
+        roomId: message.roomId,
+        createdAt: Date.now()
+      }
+    ];
+    return {
+      responseContent,
+      responseMessages,
+      state,
+      mode: isSimple && responseContent.text ? "simple" : "actions"
+    };
+  }
+  async runMultiStepCore(runtime, message, state, callback, opts) {
+    const traceActionResult = [];
+    let accumulatedState = state;
+    let iterationCount = 0;
+    while (iterationCount < opts.maxMultiStepIterations) {
+      iterationCount++;
+      runtime.logger.debug(`[MultiStep] Starting iteration ${iterationCount}/${opts.maxMultiStepIterations}`);
+      accumulatedState = await runtime.composeState(message, [
+        "RECENT_MESSAGES",
+        "ACTION_STATE"
+      ]);
+      accumulatedState.data.actionResults = traceActionResult;
+      const prompt = composePromptFromState({
+        state: accumulatedState,
+        template: runtime.character.templates?.multiStepDecisionTemplate || multiStepDecisionTemplate
+      });
+      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}`);
+        traceActionResult.push({
+          data: { actionName: "parse_error" },
+          success: false,
+          error: "Failed to parse step result"
+        });
+        break;
+      }
+      const { thought, providers = [], action, isFinish } = parsedStep;
+      if (isFinish === "true" || isFinish === true) {
+        runtime.logger.info(`[MultiStep] Task marked as complete at iteration ${iterationCount}`);
+        if (callback) {
+          await callback({
+            text: "",
+            thought: thought ?? ""
+          });
+        }
+        break;
+      }
+      if ((!providers || providers.length === 0) && !action) {
+        runtime.logger.warn(`[MultiStep] No providers or action specified at iteration ${iterationCount}, 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}`);
+            traceActionResult.push({
+              data: { actionName: providerName },
+              success: false,
+              error: `Provider not found: ${providerName}`
+            });
+            continue;
+          }
+          const providerResult = await provider.get(runtime, message, state);
+          if (!providerResult) {
+            runtime.logger.warn(`[MultiStep] Provider returned no result: ${providerName}`);
+            traceActionResult.push({
+              data: { actionName: providerName },
+              success: false,
+              error: `Provider returned no result`
+            });
+            continue;
+          }
+          const success = !!providerResult.text;
+          traceActionResult.push({
+            data: { actionName: providerName },
+            success,
+            text: success ? providerResult.text : undefined,
+            error: success ? undefined : "Provider returned no result"
+          });
+          if (callback) {
+            await callback({
+              text: `\uD83D\uDD0E Provider executed: ${providerName}`,
+              actions: [providerName],
+              thought: thought ?? ""
+            });
+          }
+        }
+        if (action) {
+          const actionContent = {
+            text: `\uD83D\uDD0E Executing action: ${action}`,
+            actions: [action],
+            thought: thought ?? ""
+          };
+          await runtime.processActions(message, [
+            {
+              id: v4_default(),
+              entityId: runtime.agentId,
+              roomId: message.roomId,
+              createdAt: Date.now(),
+              content: actionContent
+            }
+          ], state, async () => {
+            return [];
+          });
+          const cachedState = runtime.stateCache?.get(`${message.id}_action_results`);
+          const actionResults = cachedState?.values?.actionResults || [];
+          const result = actionResults.length > 0 ? actionResults[0] : null;
+          const success = result?.success ?? false;
+          traceActionResult.push({
+            data: { actionName: action },
+            success,
+            text: result?.text,
+            values: result?.values,
+            error: success ? undefined : result?.text
+          });
+        }
+      } catch (err) {
+        runtime.logger.error({ err }, "[MultiStep] Error executing step");
+        traceActionResult.push({
+          data: { actionName: action || "unknown" },
+          success: false,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+    if (iterationCount >= opts.maxMultiStepIterations) {
+      runtime.logger.warn(`[MultiStep] Reached maximum iterations (${opts.maxMultiStepIterations}), forcing completion`);
+    }
+    accumulatedState = await runtime.composeState(message, [
+      "RECENT_MESSAGES",
+      "ACTION_STATE"
+    ]);
+    const summaryPrompt = composePromptFromState({
+      state: accumulatedState,
+      template: runtime.character.templates?.multiStepSummaryTemplate || multiStepSummaryTemplate
+    });
+    const finalOutput = await runtime.useModel(ModelType.TEXT_LARGE, { prompt: summaryPrompt });
+    const summary = parseKeyValueXml(finalOutput);
+    let responseContent = null;
+    if (summary?.text) {
+      responseContent = {
+        actions: ["MULTI_STEP_SUMMARY"],
+        text: summary.text,
+        thought: summary.thought || "Final user-facing message after task completion.",
+        simple: true
+      };
+    }
+    const responseMessages = responseContent ? [
+      {
+        id: asUUID(v4_default()),
+        entityId: runtime.agentId,
+        agentId: runtime.agentId,
+        content: responseContent,
+        roomId: message.roomId,
+        createdAt: Date.now()
+      }
+    ] : [];
+    return {
+      responseContent,
+      responseMessages,
+      state: accumulatedState,
+      mode: responseContent ? "simple" : "none"
+    };
+  }
+  async emitRunEnded(runtime, runId, message, startTime, status) {
+    await runtime.emitEvent("RUN_ENDED" /* RUN_ENDED */, {
+      runtime,
+      runId,
+      messageId: message.id,
+      roomId: message.roomId,
+      entityId: message.entityId,
+      startTime,
+      status,
+      endTime: Date.now(),
+      duration: Date.now() - startTime,
+      source: "messageHandler"
+    });
+  }
+  async deleteMessage(runtime, message) {
+    try {
+      if (!message.id) {
+        runtime.logger.error("[MessageService] Cannot delete memory: message ID is missing");
+        return;
+      }
+      runtime.logger.info("[MessageService] Deleting memory for message", message.id, "from room", message.roomId);
+      await runtime.deleteMemory(message.id);
+      runtime.logger.debug({ messageId: message.id }, "[MessageService] Successfully deleted memory for message");
+    } catch (error) {
+      runtime.logger.error({ error }, "[MessageService] Error in deleteMessage:");
+      throw error;
+    }
+  }
+  async clearChannel(runtime, roomId, channelId) {
+    try {
+      runtime.logger.info(`[MessageService] Clearing message memories from channel ${channelId} -> room ${roomId}`);
+      const memories = await runtime.getMemoriesByRoomIds({
+        tableName: "messages",
+        roomIds: [roomId]
+      });
+      runtime.logger.info(`[MessageService] Found ${memories.length} message memories to delete from channel ${channelId}`);
+      let deletedCount = 0;
+      for (const memory of memories) {
+        if (memory.id) {
+          try {
+            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.info(`[MessageService] Successfully cleared ${deletedCount}/${memories.length} message memories from channel ${channelId}`);
+    } catch (error) {
+      runtime.logger.error({ error }, "[MessageService] Error in clearChannel:");
+      throw error;
+    }
+  }
+}
+
 // src/search.ts
 var isV = (char) => {
   switch (char) {
@@ -43738,8 +44623,9 @@ class AgentRuntime {
   currentRunId;
   currentActionContext;
   maxWorkingMemoryEntries = 50;
+  messageService = null;
   constructor(opts) {
-    this.agentId = opts.character?.id ?? opts?.agentId ?? stringToUuid(opts.character?.name ?? v4_default() + opts.character?.username);
+    this.agentId = opts.character?.id ?? opts?.agentId ?? stringToUuid(opts.character?.name ?? v4_default());
     this.character = opts.character;
     this.initPromise = new Promise((resolve, reject) => {
       this.initResolver = resolve;
@@ -43902,12 +44788,16 @@ class AgentRuntime {
       if (!await this.adapter.isReady()) {
         await this.adapter.init();
       }
+      this.messageService = new DefaultMessageService;
       this.logger.info("Running plugin migrations...");
       await this.runPluginMigrations();
       this.logger.info("Plugin migrations completed.");
-      const existingAgent = await this.ensureAgentExists(this.character);
+      const existingAgent = await this.ensureAgentExists({
+        ...this.character,
+        id: this.agentId
+      });
       if (!existingAgent) {
-        const errorMsg = `Agent ${this.character.name} does not exist in database after ensureAgentExists call`;
+        const errorMsg = `Agent ${this.agentId} does not exist in database after ensureAgentExists call`;
         throw new Error(errorMsg);
       }
       let agentEntity = await this.getEntityById(this.agentId);
@@ -44455,42 +45345,56 @@ class AgentRuntime {
     }
   }
   async evaluate(message, state, didRespond, callback, responses) {
-    const evaluatorPromises = this.evaluators.map(async (evaluator) => {
-      if (!evaluator.handler) {
-        return null;
-      }
-      if (!didRespond && !evaluator.alwaysRun) {
-        return null;
-      }
-      const result = await evaluator.validate(this, message, state);
-      if (result) {
-        return evaluator;
+    try {
+      const evaluatorPromises = this.evaluators.map(async (evaluator) => {
+        try {
+          if (!evaluator.handler) {
+            return null;
+          }
+          if (!didRespond && !evaluator.alwaysRun) {
+            return null;
+          }
+          const result = await evaluator.validate(this, message, state);
+          if (result) {
+            return evaluator;
+          }
+          return null;
+        } catch (error) {
+          this.logger.error({ error, evaluatorName: evaluator.name }, `Error validating evaluator ${evaluator.name}`);
+          return null;
+        }
+      });
+      const evaluators = (await Promise.all(evaluatorPromises)).filter(Boolean);
+      if (evaluators.length === 0) {
+        return [];
       }
-      return null;
-    });
-    const evaluators = (await Promise.all(evaluatorPromises)).filter(Boolean);
-    if (evaluators.length === 0) {
+      state = await this.composeState(message, ["RECENT_MESSAGES", "EVALUATORS"]);
+      await Promise.all(evaluators.map(async (evaluator) => {
+        try {
+          if (evaluator.handler) {
+            await evaluator.handler(this, message, state, {}, callback, responses);
+            this.adapter.log({
+              entityId: message.entityId,
+              roomId: message.roomId,
+              type: "evaluator",
+              body: {
+                evaluator: evaluator.name,
+                messageId: message.id,
+                message: message.content.text,
+                state,
+                runId: this.getCurrentRunId()
+              }
+            });
+          }
+        } catch (error) {
+          this.logger.error({ error, evaluatorName: evaluator.name }, `Error executing evaluator ${evaluator.name}`);
+        }
+      }));
+      return evaluators;
+    } catch (error) {
+      this.logger.error({ error, messageId: message.id, roomId: message.roomId }, "Error in evaluate method");
       return [];
     }
-    state = await this.composeState(message, ["RECENT_MESSAGES", "EVALUATORS"]);
-    await Promise.all(evaluators.map(async (evaluator) => {
-      if (evaluator.handler) {
-        await evaluator.handler(this, message, state, {}, callback, responses);
-        this.adapter.log({
-          entityId: message.entityId,
-          roomId: message.roomId,
-          type: "evaluator",
-          body: {
-            evaluator: evaluator.name,
-            messageId: message.id,
-            message: message.content.text,
-            state,
-            runId: this.getCurrentRunId()
-          }
-        });
-      }
-    }));
-    return evaluators;
   }
   async ensureConnections(entities, rooms, source, world) {
     if (!entities) {
@@ -45095,6 +45999,51 @@ class AgentRuntime {
       throw error;
     }
   }
+  async generateText(input, options) {
+    if (!input?.trim()) {
+      throw new Error("Input cannot be empty");
+    }
+    const includeCharacter = options?.includeCharacter ?? true;
+    const modelType = options?.modelType ?? ModelType.TEXT_LARGE;
+    let prompt = input;
+    if (includeCharacter && this.character) {
+      const c = this.character;
+      const parts = [];
+      const bioText = Array.isArray(c.bio) ? c.bio.join(" ") : c.bio;
+      if (bioText) {
+        parts.push(`# About ${c.name}
+${bioText}`);
+      }
+      if (c.system) {
+        parts.push(c.system);
+      }
+      const styles2 = [...c.style?.all || [], ...c.style?.chat || []];
+      if (styles2.length > 0) {
+        parts.push(`Style:
+${styles2.map((s) => `- ${s}`).join(`
+`)}`);
+      }
+      if (parts.length > 0) {
+        prompt = `${parts.join(`
+
+`)}
+
+${input}`;
+      }
+    }
+    const params = {
+      prompt,
+      maxTokens: options?.maxTokens,
+      temperature: options?.temperature,
+      frequencyPenalty: options?.frequencyPenalty,
+      presencePenalty: options?.presencePenalty,
+      stopSequences: options?.stopSequences
+    };
+    const response = await this.useModel(modelType, params);
+    return {
+      text: response
+    };
+  }
   registerEvent(event, handler) {
     if (!this.events[event]) {
       this.events[event] = [];
@@ -45181,34 +46130,33 @@ class AgentRuntime {
     return await this.adapter.deleteAgent(agentId);
   }
   async ensureAgentExists(agent) {
-    if (!agent.name) {
-      throw new Error("Agent name is required");
+    if (!agent.id) {
+      throw new Error("Agent id is required");
     }
-    const agents = await this.adapter.getAgents();
-    const existingAgentId = agents.find((a) => a.name === agent.name)?.id;
-    if (existingAgentId) {
+    const existingAgent = await this.adapter.getAgent(agent.id);
+    if (existingAgent) {
       const updatedAgent = {
         ...agent,
-        id: existingAgentId,
+        id: agent.id,
         updatedAt: Date.now()
       };
-      await this.adapter.updateAgent(existingAgentId, updatedAgent);
-      const existingAgent = await this.adapter.getAgent(existingAgentId);
-      if (!existingAgent) {
-        throw new Error(`Failed to retrieve agent after update: ${existingAgentId}`);
+      await this.adapter.updateAgent(agent.id, updatedAgent);
+      const refreshedAgent = await this.adapter.getAgent(agent.id);
+      if (!refreshedAgent) {
+        throw new Error(`Failed to retrieve agent after update: ${agent.id}`);
       }
-      this.logger.debug(`Updated existing agent ${agent.name} on restart`);
-      return existingAgent;
+      this.logger.debug(`Updated existing agent ${agent.id} on restart`);
+      return refreshedAgent;
     }
     const newAgent = {
       ...agent,
-      id: stringToUuid(agent.name)
+      id: agent.id
     };
     const created = await this.adapter.createAgent(newAgent);
     if (!created) {
-      throw new Error(`Failed to create agent: ${agent.name}`);
+      throw new Error(`Failed to create agent: ${agent.id}`);
     }
-    this.logger.debug(`Created new agent ${agent.name}`);
+    this.logger.debug(`Created new agent ${agent.id}`);
     return newAgent;
   }
   async getEntityById(entityId) {
@@ -45578,8 +46526,44 @@ class AgentRuntime {
   }
 }
 
+// src/secrets.ts
+init_environment();
+function hasCharacterSecrets(character) {
+  return Boolean(character?.settings?.secrets && Object.keys(character.settings.secrets).length > 0);
+}
+async function loadSecretsNodeImpl(character) {
+  const fs = await import("node:fs");
+  const dotenv = await import("dotenv");
+  const { findEnvFile: findEnvFile2 } = await Promise.resolve().then(() => (init_environment(), exports_environment));
+  if (hasCharacterSecrets(character)) {
+    return false;
+  }
+  const envPath = findEnvFile2();
+  if (!envPath)
+    return false;
+  try {
+    const buf = fs.readFileSync(envPath);
+    const envSecrets = dotenv.parse(buf);
+    if (!character.settings) {
+      character.settings = {};
+    }
+    character.settings.secrets = envSecrets;
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function setDefaultSecretsFromEnv(character) {
+  const env2 = detectEnvironment();
+  if (env2 !== "node") {
+    return false;
+  }
+  return loadSecretsNodeImpl(character);
+}
+
 // src/settings.ts
 var import_crypto_browserify = __toESM(require_crypto_browserify(), 1);
+init_environment();
 function createSettingFromConfig(configSetting) {
   return {
     name: configSetting.name,
@@ -45856,20 +46840,293 @@ function defineService(definition) {
   return createService(definition.serviceType).withDescription(definition.description).withStart(definition.start).withStop(definition.stop || (() => Promise.resolve())).build();
 }
 
+// src/plugin.ts
+init_environment();
+var attemptedInstalls = new Set;
+function isAutoInstallAllowed() {
+  if (process.env.ELIZA_NO_AUTO_INSTALL === "true")
+    return false;
+  if (process.env.ELIZA_NO_PLUGIN_AUTO_INSTALL === "true")
+    return false;
+  if (process.env.CI === "true")
+    return false;
+  if (process.env.ELIZA_TEST_MODE === "true")
+    return false;
+  if (false)
+    ;
+  return true;
+}
+async function tryInstallPlugin(pluginName) {
+  try {
+    if (!isAutoInstallAllowed()) {
+      logger.debug(`Auto-install disabled or not allowed in this environment. Skipping install for ${pluginName}.`);
+      return false;
+    }
+    if (attemptedInstalls.has(pluginName)) {
+      logger.debug(`Auto-install already attempted for ${pluginName}. 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}`);
+      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}`);
+        return false;
+      }
+    } catch {
+      logger.warn(`Bun not available on PATH. Cannot auto-install ${pluginName}. Please run: bun add ${pluginName}`);
+      return false;
+    }
+    logger.info(`Attempting to auto-install missing plugin: ${pluginName}`);
+    const install = Bun.spawn(["bun", "add", pluginName], {
+      cwd: process.cwd(),
+      env: process.env,
+      stdout: "inherit",
+      stderr: "inherit"
+    });
+    const exit = await install.exited;
+    if (exit === 0) {
+      logger.info(`Successfully installed ${pluginName}. Retrying import...`);
+      return true;
+    }
+    logger.error(`bun add ${pluginName} failed with exit code ${exit}. Please install manually.`);
+    return false;
+  } catch (e) {
+    const message = e instanceof Error ? e.message : String(e);
+    logger.error(`Unexpected error during auto-install of ${pluginName}: ${message}`);
+    return false;
+  }
+}
+function isValidPluginShape(obj) {
+  if (!obj || typeof obj !== "object") {
+    return false;
+  }
+  const plugin = obj;
+  if (!plugin.name) {
+    return false;
+  }
+  return !!(plugin.init || plugin.services || plugin.providers || plugin.actions || plugin.evaluators || plugin.description);
+}
+function validatePlugin(plugin) {
+  const errors = [];
+  if (!plugin) {
+    errors.push("Plugin is null or undefined");
+    return { isValid: false, errors };
+  }
+  const pluginObj = plugin;
+  if (!pluginObj.name) {
+    errors.push("Plugin must have a name");
+  }
+  if (pluginObj.actions) {
+    if (!Array.isArray(pluginObj.actions)) {
+      errors.push("Plugin actions must be an array");
+    } else {
+      const invalidActions = pluginObj.actions.filter((a) => typeof a !== "object" || !a);
+      if (invalidActions.length > 0) {
+        errors.push("Plugin actions must be an array of action objects");
+      }
+    }
+  }
+  if (pluginObj.services) {
+    if (!Array.isArray(pluginObj.services)) {
+      errors.push("Plugin services must be an array");
+    } else {
+      const invalidServices = pluginObj.services.filter((s) => typeof s !== "function" && (typeof s !== "object" || !s));
+      if (invalidServices.length > 0) {
+        errors.push("Plugin services must be an array of service classes or objects");
+      }
+    }
+  }
+  if (pluginObj.providers && !Array.isArray(pluginObj.providers)) {
+    errors.push("Plugin providers must be an array");
+  }
+  if (pluginObj.evaluators && !Array.isArray(pluginObj.evaluators)) {
+    errors.push("Plugin evaluators must be an array");
+  }
+  return {
+    isValid: errors.length === 0,
+    errors
+  };
+}
+async function loadAndPreparePlugin(pluginName) {
+  try {
+    let pluginModule;
+    try {
+      pluginModule = await import(pluginName);
+    } catch (error) {
+      logger.warn(`Failed to load plugin ${pluginName}: ${error}`);
+      const attempted = await tryInstallPlugin(pluginName);
+      if (!attempted) {
+        return null;
+      }
+      try {
+        pluginModule = await import(pluginName);
+      } catch (secondError) {
+        logger.error(`Auto-install attempted for ${pluginName} but import still failed: ${secondError}`);
+        return null;
+      }
+    }
+    if (!pluginModule) {
+      logger.error(`Failed to load module for plugin ${pluginName}.`);
+      return null;
+    }
+    const expectedFunctionName = `${pluginName.replace(/^@elizaos\/plugin-/, "").replace(/^@elizaos\//, "").replace(/-./g, (match) => match[1].toUpperCase())}Plugin`;
+    const moduleObj = pluginModule;
+    const exportsToCheck = [
+      moduleObj[expectedFunctionName],
+      moduleObj.default,
+      ...Object.values(moduleObj)
+    ];
+    for (const potentialPlugin of exportsToCheck) {
+      if (isValidPluginShape(potentialPlugin)) {
+        return potentialPlugin;
+      }
+      if (typeof potentialPlugin === "function" && potentialPlugin.length === 0) {
+        try {
+          const produced = potentialPlugin();
+          if (isValidPluginShape(produced)) {
+            return produced;
+          }
+        } catch (err) {
+          logger.debug(`Factory export threw for ${pluginName}: ${err}`);
+        }
+      }
+    }
+    logger.warn(`Could not find a valid plugin export in ${pluginName}.`);
+    return null;
+  } catch (error) {
+    logger.error(`Error loading plugin ${pluginName}: ${error}`);
+    return null;
+  }
+}
+function resolvePluginDependencies(availablePlugins, isTestMode = false) {
+  const resolutionOrder = [];
+  const visited = new Set;
+  const visiting = new Set;
+  function visit(pluginName) {
+    if (!availablePlugins.has(pluginName)) {
+      logger.warn(`Plugin dependency "${pluginName}" not found and will be skipped.`);
+      return;
+    }
+    if (visited.has(pluginName))
+      return;
+    if (visiting.has(pluginName)) {
+      logger.error(`Circular dependency detected involving plugin: ${pluginName}`);
+      return;
+    }
+    visiting.add(pluginName);
+    const plugin = availablePlugins.get(pluginName);
+    if (plugin) {
+      const deps = [...plugin.dependencies || []];
+      if (isTestMode) {
+        deps.push(...plugin.testDependencies || []);
+      }
+      for (const dep of deps) {
+        visit(dep);
+      }
+    }
+    visiting.delete(pluginName);
+    visited.add(pluginName);
+    resolutionOrder.push(pluginName);
+  }
+  for (const name of availablePlugins.keys()) {
+    if (!visited.has(name)) {
+      visit(name);
+    }
+  }
+  const finalPlugins = resolutionOrder.map((name) => availablePlugins.get(name)).filter((p) => Boolean(p));
+  logger.info({ plugins: finalPlugins.map((p) => p.name) }, `Final plugins being loaded:`);
+  return finalPlugins;
+}
+async function loadPlugin(nameOrPlugin) {
+  if (typeof nameOrPlugin === "string") {
+    return loadAndPreparePlugin(nameOrPlugin);
+  }
+  const validation = validatePlugin(nameOrPlugin);
+  if (!validation.isValid) {
+    logger.error(`Invalid plugin provided: ${validation.errors.join(", ")}`);
+    return null;
+  }
+  return nameOrPlugin;
+}
+async function resolvePluginsImpl(plugins, isTestMode = false) {
+  const pluginMap = new Map;
+  const queue2 = [...plugins];
+  while (queue2.length > 0) {
+    const next = queue2.shift();
+    const loaded = await loadPlugin(next);
+    if (!loaded)
+      continue;
+    if (!pluginMap.has(loaded.name)) {
+      pluginMap.set(loaded.name, loaded);
+      for (const depName of loaded.dependencies ?? []) {
+        if (!pluginMap.has(depName)) {
+          queue2.push(depName);
+        }
+      }
+      if (isTestMode) {
+        for (const depName of loaded.testDependencies ?? []) {
+          if (!pluginMap.has(depName)) {
+            queue2.push(depName);
+          }
+        }
+      }
+    }
+  }
+  return resolvePluginDependencies(pluginMap, isTestMode);
+}
+async function resolvePlugins(plugins, isTestMode = false) {
+  const env2 = detectEnvironment();
+  if (env2 === "node") {
+    return resolvePluginsImpl(plugins, isTestMode);
+  }
+  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 pluginMap = new Map;
+  for (const plugin of pluginObjects) {
+    pluginMap.set(plugin.name, plugin);
+  }
+  return resolvePluginDependencies(pluginMap, isTestMode);
+}
+
 // src/elizaos.ts
 class ElizaOS extends EventTarget {
   runtimes = new Map;
+  initFunctions = new Map;
   editableMode = false;
-  async addAgents(agents) {
+  async addAgents(agents, options) {
     const promises = agents.map(async (agent) => {
+      const character = agent.character;
+      if (!hasCharacterSecrets(character)) {
+        await setDefaultSecretsFromEnv(character);
+      }
+      const resolvedPlugins = agent.plugins ? await resolvePlugins(agent.plugins, options?.isTestMode || false) : [];
       const runtime = new AgentRuntime({
-        character: agent.character,
-        plugins: agent.plugins || [],
+        character,
+        plugins: resolvedPlugins,
         settings: agent.settings || {}
       });
       this.runtimes.set(runtime.agentId, runtime);
+      if (typeof agent.init === "function") {
+        this.initFunctions.set(runtime.agentId, agent.init);
+      }
+      const { settings, ...characterWithoutSecrets } = character;
+      const { secrets, ...settingsWithoutSecrets } = settings || {};
       this.dispatchEvent(new CustomEvent("agent:added", {
-        detail: { agentId: runtime.agentId, character: agent.character }
+        detail: {
+          agentId: runtime.agentId,
+          character: {
+            ...characterWithoutSecrets,
+            settings: settingsWithoutSecrets
+          }
+        }
       }));
       return runtime.agentId;
     });
@@ -45905,6 +47162,7 @@ class ElizaOS extends EventTarget {
     await this.stopAgents(agentIds);
     for (const id of agentIds) {
       this.runtimes.delete(id);
+      this.initFunctions.delete(id);
     }
     this.dispatchEvent(new CustomEvent("agents:deleted", {
       detail: { agentIds, count: agentIds.length }
@@ -45922,6 +47180,16 @@ class ElizaOS extends EventTarget {
         detail: { agentId: id }
       }));
     }));
+    for (const id of ids) {
+      const initFn = this.initFunctions.get(id);
+      if (initFn) {
+        const runtime = this.runtimes.get(id);
+        if (runtime) {
+          await initFn(runtime);
+          this.initFunctions.delete(id);
+        }
+      }
+    }
     this.dispatchEvent(new CustomEvent("agents:started", {
       detail: { agentIds: ids, count: ids.length }
     }));
@@ -46284,11 +47552,14 @@ var isNode3 = true;
 export {
   waitForServerReady,
   validateUuid,
+  validatePlugin,
+  validateCharacterConfig,
   validateCharacter,
   uuidSchema2 as uuidSchema,
   updateWorldSettings,
   unsaltWorldSettings,
   unsaltSettingValue,
+  tryInstallPlugin,
   truncateToCompleteSentence,
   trimTokens,
   toString2 as toString,
@@ -46301,10 +47572,13 @@ export {
   shouldRespondTemplate,
   settingsSchema,
   setEnv,
+  setDefaultSecretsFromEnv,
   secretsSchema,
   saltWorldSettings,
   saltSettingValue,
   safeReplacer,
+  resolvePlugins,
+  resolvePluginDependencies,
   resetPaths,
   recentLogs,
   randomBytes,
@@ -46313,6 +47587,7 @@ export {
   pingServer,
   parseKeyValueXml,
   parseJSONObjectFromText,
+  parseCharacter,
   parseBooleanFromText2 as parseBooleanFromText,
   parseAndValidateCharacter,
   normalizeJsonString,
@@ -46320,9 +47595,14 @@ export {
   multiStepDecisionTemplate,
   messageHandlerTemplate,
   messageExampleSchema,
+  mergeCharacterDefaults,
   mediaSchema,
   logger,
+  loadPlugin,
+  loadEnvConfig,
+  loadAndPreparePlugin,
   knowledgeItemSchema,
+  isValidPluginShape,
   isValidCharacter,
   isNode3 as isNode,
   isMessageMetadata,
@@ -46338,6 +47618,7 @@ export {
   initBrowserEnvironment,
   imageDescriptionTemplate,
   hasEnv,
+  hasCharacterSecrets,
   getWorldSettings,
   getUserServerRole,
   getUploadsChannelsDir,
@@ -46368,6 +47649,7 @@ export {
   formatActions,
   formatActionNames,
   findWorldsForOwner,
+  findEnvFile,
   findEntityByName,
   equals,
   encryptedCharacter,
@@ -46397,6 +47679,7 @@ export {
   clearSaltCache,
   characterSchema,
   byteLength,
+  buildCharacterPlugins,
   booleanFooter,
   asUUID,
   alloc,
@@ -46418,6 +47701,7 @@ export {
   EventType,
   Environment,
   ElizaOS,
+  DefaultMessageService,
   DatabaseAdapter,
   ContentType,
   ChannelType,
@@ -46427,5 +47711,5 @@ export {
   AgentRuntime
 };
 
-//# debugId=EC34687CD2FBE32664756E2164756E21
+//# debugId=738C38AE1C103AEB64756E2164756E21
 //# sourceMappingURL=index.node.js.map