@elizaos/core 1.6.2-alpha.10 → 1.6.2-alpha.12

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,220 @@ 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 +10736,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 +10762,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 +10822,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 +10885,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) {
@@ -25770,7 +25992,7 @@ var getDefaultProjectName = () => {
 };
 
 // ../../node_modules/langsmith/dist/index.js
-var __version__ = "0.3.71";
+var __version__ = "0.3.72";
 
 // ../../node_modules/langsmith/dist/utils/env.js
 var globalEnv;
@@ -39079,171 +39301,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 +41438,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 +42150,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";
@@ -42862,6 +42926,9 @@ function v43(options, buf, offset) {
   return _v4(options, buf, offset);
 }
 var v4_default = v43;
+// src/runtime.ts
+init_environment();
+
 // src/search.ts
 var isV = (char) => {
   switch (char) {
@@ -45580,6 +45647,7 @@ class AgentRuntime {
 
 // src/settings.ts
 var import_crypto_browserify = __toESM(require_crypto_browserify(), 1);
+init_environment();
 function createSettingFromConfig(configSetting) {
   return {
     name: configSetting.name,
@@ -45856,20 +45924,324 @@ function defineService(definition) {
   return createService(definition.serviceType).withDescription(definition.description).withStart(definition.start).withStop(definition.stop || (() => Promise.resolve())).build();
 }
 
+// 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/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;
   editableMode = false;
   async addAgents(agents) {
     const promises = agents.map(async (agent) => {
+      const character = agent.character;
+      if (!hasCharacterSecrets(character)) {
+        await setDefaultSecretsFromEnv(character);
+      }
+      const resolvedPlugins = agent.plugins ? await resolvePlugins(agent.plugins) : [];
       const runtime = new AgentRuntime({
-        character: agent.character,
-        plugins: agent.plugins || [],
+        character,
+        plugins: resolvedPlugins,
         settings: agent.settings || {}
       });
       this.runtimes.set(runtime.agentId, runtime);
+      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;
     });
@@ -46277,6 +46649,47 @@ Data: ${JSON.stringify(entity.metadata)}
   return entityStrings.join(`
 `);
 }
+// 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"
+  };
+}
 
 // src/index.node.ts
 var isBrowser4 = false;
@@ -46284,11 +46697,14 @@ var isNode3 = true;
 export {
   waitForServerReady,
   validateUuid,
+  validatePlugin,
+  validateCharacterConfig,
   validateCharacter,
   uuidSchema2 as uuidSchema,
   updateWorldSettings,
   unsaltWorldSettings,
   unsaltSettingValue,
+  tryInstallPlugin,
   truncateToCompleteSentence,
   trimTokens,
   toString2 as toString,
@@ -46301,10 +46717,13 @@ export {
   shouldRespondTemplate,
   settingsSchema,
   setEnv,
+  setDefaultSecretsFromEnv,
   secretsSchema,
   saltWorldSettings,
   saltSettingValue,
   safeReplacer,
+  resolvePlugins,
+  resolvePluginDependencies,
   resetPaths,
   recentLogs,
   randomBytes,
@@ -46313,6 +46732,7 @@ export {
   pingServer,
   parseKeyValueXml,
   parseJSONObjectFromText,
+  parseCharacter,
   parseBooleanFromText2 as parseBooleanFromText,
   parseAndValidateCharacter,
   normalizeJsonString,
@@ -46320,9 +46740,14 @@ export {
   multiStepDecisionTemplate,
   messageHandlerTemplate,
   messageExampleSchema,
+  mergeCharacterDefaults,
   mediaSchema,
   logger,
+  loadPlugin,
+  loadEnvConfig,
+  loadAndPreparePlugin,
   knowledgeItemSchema,
+  isValidPluginShape,
   isValidCharacter,
   isNode3 as isNode,
   isMessageMetadata,
@@ -46338,6 +46763,7 @@ export {
   initBrowserEnvironment,
   imageDescriptionTemplate,
   hasEnv,
+  hasCharacterSecrets,
   getWorldSettings,
   getUserServerRole,
   getUploadsChannelsDir,
@@ -46368,6 +46794,7 @@ export {
   formatActions,
   formatActionNames,
   findWorldsForOwner,
+  findEnvFile,
   findEntityByName,
   equals,
   encryptedCharacter,
@@ -46427,5 +46854,5 @@ export {
   AgentRuntime
 };
 
-//# debugId=EC34687CD2FBE32664756E2164756E21
+//# debugId=E2D0C494EAA6822164756E2164756E21
 //# sourceMappingURL=index.node.js.map