@elizaos/core 1.6.2-alpha.2 → 1.6.2-alpha.21

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.74";
 
 // ../../node_modules/langsmith/dist/utils/env.js
 var globalEnv;
@@ -25815,8 +26037,8 @@ function getRuntimeEnvironment() {
   }
   return runtimeEnvironment;
 }
-function getLangChainEnvVarsMetadata() {
-  const allEnvVars = getEnvironmentVariables() || {};
+function getLangSmithEnvVarsMetadata() {
+  const allEnvVars = getLangSmithEnvironmentVariables();
   const envVars = {};
   const excluded = [
     "LANGCHAIN_API_KEY",
@@ -25831,7 +26053,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 +26063,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 +26953,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 +27261,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 +27321,7 @@ class Client {
     if (getOtelEnabled()) {
       this.langSmithToOTELTranslator = new LangSmithToOTELTranslator;
     }
+    this.cachedLSEnvVarsForMetadata = getLangSmithEnvVarsMetadata();
   }
   static getDefaultClientConfig() {
     const apiKey = getLangSmithEnvironmentVariable("API_KEY");
@@ -27400,7 +27633,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 +27748,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 +28250,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 +39315,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 +41452,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")
@@ -41791,6 +41865,8 @@ function safeReplacer() {
 function parseBooleanFromText2(value) {
   if (!value)
     return false;
+  if (typeof value === "boolean")
+    return value;
   const affirmative = ["YES", "Y", "TRUE", "T", "1", "ON", "ENABLE"];
   const negative = ["NO", "N", "FALSE", "F", "0", "OFF", "DISABLE"];
   const normalizedText = value.trim().toUpperCase();
@@ -41990,63 +42066,72 @@ function getLocalServerUrl(path) {
 }
 // src/schemas/character.ts
 import { z as z3 } from "zod";
-var uuidSchema2 = z3.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i, "Invalid UUID format");
+var uuidSchema2 = z3.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i, "Invalid UUID format").describe("Unique identifier for the character in UUID format");
+var mediaSchema = z3.object({
+  id: z3.string().describe("Unique identifier for the media"),
+  url: z3.string().describe("URL of the media file"),
+  title: z3.string().optional().describe("Media title"),
+  source: z3.string().optional().describe("Media source"),
+  description: z3.string().optional().describe("Media description"),
+  text: z3.string().optional().describe("Text content associated with the media"),
+  contentType: z3.nativeEnum(ContentType).optional().describe("Type of media content")
+}).loose().describe("Media attachment with URL and metadata");
 var contentSchema = z3.object({
-  text: z3.string().optional(),
-  thought: z3.string().optional(),
-  actions: z3.array(z3.string()).optional(),
-  providers: z3.array(z3.string()).optional(),
-  source: z3.string().optional(),
-  target: z3.string().optional(),
-  url: z3.string().optional(),
-  inReplyTo: uuidSchema2.optional(),
-  attachments: z3.array(z3.any()).optional(),
-  channelType: z3.nativeEnum(ChannelType).optional()
-}).passthrough();
+  text: z3.string().optional().describe("The main text content of the message"),
+  thought: z3.string().optional().describe("Internal thought process or reasoning"),
+  actions: z3.array(z3.string()).optional().describe("Actions to be taken in response"),
+  providers: z3.array(z3.string()).optional().describe("Data providers to use (e.g., KNOWLEDGE)"),
+  source: z3.string().optional().describe("Source of the content"),
+  target: z3.string().optional().describe("Target of the content"),
+  url: z3.string().optional().describe("Related URL"),
+  inReplyTo: uuidSchema2.optional().describe("UUID of message this is replying to"),
+  attachments: z3.array(mediaSchema).optional().describe("Array of media attachments (images, videos, documents, etc.)"),
+  channelType: z3.enum(ChannelType).optional().describe("Type of channel this content is for")
+}).catchall(z3.unknown()).describe("Content structure for messages in conversation examples");
 var messageExampleSchema = z3.object({
-  name: z3.string(),
+  name: z3.string().describe("Name of the speaker (can use {{name1}} placeholder for dynamic names)"),
   content: contentSchema
-});
+}).describe("A single message in a conversation example");
 var directoryItemSchema = z3.object({
-  directory: z3.string(),
-  shared: z3.boolean().optional()
-});
+  directory: z3.string().describe("Path to a directory containing knowledge files"),
+  shared: z3.boolean().optional().describe("Whether this knowledge is shared across characters")
+}).describe("Directory-based knowledge source");
 var knowledgeItemSchema = z3.union([
-  z3.string(),
+  z3.string().describe("File path to a knowledge document"),
   z3.object({
-    path: z3.string(),
-    shared: z3.boolean().optional()
+    path: z3.string().describe("Path to a knowledge file"),
+    shared: z3.boolean().optional().describe("Whether this knowledge is shared across characters")
   }),
   directoryItemSchema
-]);
+]).describe("Knowledge source - can be a file path, file object, or directory");
 var templateTypeSchema = z3.union([
-  z3.string(),
+  z3.string().describe("Template string with placeholders"),
   z3.function().optional()
-]);
+]).describe("Template for generating text - can be a string template or function");
 var styleSchema = z3.object({
-  all: z3.array(z3.string()).optional(),
-  chat: z3.array(z3.string()).optional(),
-  post: z3.array(z3.string()).optional()
-}).optional();
-var settingsSchema = z3.record(z3.string(), z3.union([z3.string(), z3.boolean(), z3.number(), z3.any()])).optional();
-var secretsSchema = z3.record(z3.string(), z3.union([z3.string(), z3.boolean(), z3.number()])).optional();
+  all: z3.array(z3.string()).optional().describe("Style guidelines applied to all types of responses"),
+  chat: z3.array(z3.string()).optional().describe("Style guidelines specific to chat/conversation responses"),
+  post: z3.array(z3.string()).optional().describe("Style guidelines specific to social media posts")
+}).optional().describe("Style configuration defining how the character communicates across different contexts");
+var settingsSchema = z3.record(z3.string(), z3.union([z3.string(), z3.boolean(), z3.number(), z3.object({}).loose(), z3.array(z3.any())])).optional().describe("Character-specific settings like avatar URL, preferences, and configuration");
+var secretsSchema = z3.record(z3.string(), z3.union([z3.string(), z3.boolean(), z3.number()])).optional().describe("Secret values and API keys (should not be committed to version control)");
 var characterSchema = z3.object({
-  id: uuidSchema2.optional(),
-  name: z3.string().min(1, "Character name is required"),
-  username: z3.string().optional(),
-  system: z3.string().optional(),
-  templates: z3.record(z3.string(), templateTypeSchema).optional(),
-  bio: z3.union([z3.string(), z3.array(z3.string())]),
-  messageExamples: z3.array(z3.array(messageExampleSchema)).optional(),
-  postExamples: z3.array(z3.string()).optional(),
-  topics: z3.array(z3.string()).optional(),
-  adjectives: z3.array(z3.string()).optional(),
-  knowledge: z3.array(knowledgeItemSchema).optional(),
-  plugins: z3.array(z3.string()).optional(),
+  id: uuidSchema2.optional().describe("Unique identifier for the character"),
+  name: z3.string().min(1, "Character name is required").describe('The name of the character (e.g., "Eliza")'),
+  username: z3.string().optional().describe("Username for the character on various platforms"),
+  system: z3.string().optional().describe("System prompt that defines the character's core behavior and response style"),
+  templates: z3.record(z3.string(), templateTypeSchema).optional().describe("Custom templates for generating different types of content"),
+  bio: z3.union([z3.string(), z3.array(z3.string())]).describe("Character biography - can be a single string or array of biographical points"),
+  messageExamples: z3.array(z3.array(messageExampleSchema)).optional().describe("Example conversations showing how the character responds in different scenarios"),
+  postExamples: z3.array(z3.string()).optional().describe("Example social media posts demonstrating the character's voice and topics"),
+  topics: z3.array(z3.string()).optional().describe("Topics the character is knowledgeable about and engages with"),
+  adjectives: z3.array(z3.string()).optional().describe("Adjectives that describe the character's personality and traits"),
+  knowledge: z3.array(knowledgeItemSchema).optional().describe("Knowledge sources (files, directories) the character can reference"),
+  plugins: z3.array(z3.string()).optional().describe('List of plugin package names to load (e.g., ["@elizaos/plugin-sql", "@elizaos/plugin-bootstrap"] - these are commonly required)'),
   settings: settingsSchema,
   secrets: secretsSchema,
   style: styleSchema
-}).strict();
+}).strict().describe("Complete character definition including personality, behavior, and capabilities");
 function validateCharacter(data2) {
   const result = characterSchema.safeParse(data2);
   if (result.success) {
@@ -42079,6 +42164,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";
@@ -42710,12 +42799,12 @@ These are the actions or data provider calls that have already been used in this
 
 <keys>
 "thought" Clearly explain your reasoning for the selected providers and/or action, and how this step contributes to resolving the user's request.
-"action"  Name of the action to execute after providers return (can be null if no action is needed).
+"action"  Name of the action to execute after providers return (can be empty if no action is needed).
 "providers" List of provider names to call in this step (can be empty if none are needed).
 "isFinish" Set to true only if the task is fully complete.
 </keys>
 
-⚠️ IMPORTANT: Do **not** mark the task as \`isFinish: true\` immediately after calling an action like. Wait for the action to complete before deciding the task is finished.
+⚠️ IMPORTANT: Do **not** mark the task as \`isFinish: true\` immediately after calling an action. Wait for the action to complete before deciding the task is finished.
 
 <output>
 <response>
@@ -42851,6 +42940,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) {
@@ -43728,7 +43820,7 @@ class AgentRuntime {
   currentActionContext;
   maxWorkingMemoryEntries = 50;
   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;
@@ -43894,9 +43986,12 @@ class AgentRuntime {
       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);
@@ -44444,42 +44539,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) {
@@ -45084,6 +45193,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] = [];
@@ -45170,34 +45324,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) {
@@ -45567,8 +45720,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,
@@ -45845,20 +46034,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;
     });
@@ -45894,6 +46356,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 }
@@ -45911,6 +46374,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 }
     }));
@@ -46266,6 +46739,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;
@@ -46273,22 +46787,33 @@ var isNode3 = true;
 export {
   waitForServerReady,
   validateUuid,
+  validatePlugin,
+  validateCharacterConfig,
   validateCharacter,
+  uuidSchema2 as uuidSchema,
   updateWorldSettings,
   unsaltWorldSettings,
   unsaltSettingValue,
+  tryInstallPlugin,
   truncateToCompleteSentence,
   trimTokens,
   toString2 as toString,
   toHex,
+  templateTypeSchema,
+  styleSchema,
   stringToUuid,
   splitChunks,
   slice,
   shouldRespondTemplate,
+  settingsSchema,
   setEnv,
+  setDefaultSecretsFromEnv,
+  secretsSchema,
   saltWorldSettings,
   saltSettingValue,
   safeReplacer,
+  resolvePlugins,
+  resolvePluginDependencies,
   resetPaths,
   recentLogs,
   randomBytes,
@@ -46297,13 +46822,22 @@ export {
   pingServer,
   parseKeyValueXml,
   parseJSONObjectFromText,
+  parseCharacter,
   parseBooleanFromText2 as parseBooleanFromText,
   parseAndValidateCharacter,
   normalizeJsonString,
   multiStepSummaryTemplate,
   multiStepDecisionTemplate,
   messageHandlerTemplate,
+  messageExampleSchema,
+  mergeCharacterDefaults,
+  mediaSchema,
   logger,
+  loadPlugin,
+  loadEnvConfig,
+  loadAndPreparePlugin,
+  knowledgeItemSchema,
+  isValidPluginShape,
   isValidCharacter,
   isNode3 as isNode,
   isMessageMetadata,
@@ -46319,6 +46853,7 @@ export {
   initBrowserEnvironment,
   imageDescriptionTemplate,
   hasEnv,
+  hasCharacterSecrets,
   getWorldSettings,
   getUserServerRole,
   getUploadsChannelsDir,
@@ -46349,12 +46884,14 @@ export {
   formatActions,
   formatActionNames,
   findWorldsForOwner,
+  findEnvFile,
   findEntityByName,
   equals,
   encryptedCharacter,
   encryptStringValue,
   encryptObjectValues,
   elizaLogger,
+  directoryItemSchema,
   detectEnvironment,
   defineService,
   decryptedCharacter,
@@ -46369,6 +46906,7 @@ export {
   createService,
   createMessageMemory,
   createLogger,
+  contentSchema,
   concat2 as concat,
   composePromptFromState,
   composePrompt,
@@ -46406,5 +46944,5 @@ export {
   AgentRuntime
 };
 
-//# debugId=35E0E0299134B2DE64756E2164756E21
+//# debugId=4E1D16D9C214CAAC64756E2164756E21
 //# sourceMappingURL=index.node.js.map