@elizaos/core 1.0.0-alpha.62 → 1.0.0-alpha.64

package/dist/index.js

@@ -4,7 +4,13 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJS = (cb, mod) => function __require() {
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
 var __copyProps = (to, from, except, desc) => {
@@ -121,23 +127,29 @@ var MemoryType = /* @__PURE__ */ ((MemoryType2) => {
 })(MemoryType || {});
 var ChannelType = /* @__PURE__ */ ((ChannelType2) => {
   ChannelType2["SELF"] = "SELF";
-  ChannelType2["DM"] = "DM";
-  ChannelType2["GROUP"] = "GROUP";
+  ChannelType2["DM"] = "dm";
+  ChannelType2["GROUP"] = "group";
   ChannelType2["VOICE_DM"] = "VOICE_DM";
   ChannelType2["VOICE_GROUP"] = "VOICE_GROUP";
   ChannelType2["FEED"] = "FEED";
   ChannelType2["THREAD"] = "THREAD";
   ChannelType2["WORLD"] = "WORLD";
-  ChannelType2["API"] = "API";
   ChannelType2["FORUM"] = "FORUM";
+  ChannelType2["API"] = "API";
   return ChannelType2;
 })(ChannelType || {});
 var Service = class {
+  /** Runtime instance */
+  runtime;
   constructor(runtime) {
     if (runtime) {
       this.runtime = runtime;
     }
   }
+  /** Service type */
+  static serviceType;
+  /** Service configuration */
+  config;
   /** Start service connection */
   static async start(_runtime) {
     throw new Error("Not implemented");
@@ -162,6 +174,7 @@ var CacheKeyPrefix = /* @__PURE__ */ ((CacheKeyPrefix2) => {
   return CacheKeyPrefix2;
 })(CacheKeyPrefix || {});
 var TeeLogDAO = class {
+  db;
 };
 var TEEMode = /* @__PURE__ */ ((TEEMode2) => {
   TEEMode2["OFF"] = "OFF";
@@ -181,31 +194,31 @@ var Role = /* @__PURE__ */ ((Role2) => {
   Role2["NONE"] = "NONE";
   return Role2;
 })(Role || {});
-var EventTypes = /* @__PURE__ */ ((EventTypes2) => {
-  EventTypes2["WORLD_JOINED"] = "WORLD_JOINED";
-  EventTypes2["WORLD_CONNECTED"] = "WORLD_CONNECTED";
-  EventTypes2["WORLD_LEFT"] = "WORLD_LEFT";
-  EventTypes2["ENTITY_JOINED"] = "ENTITY_JOINED";
-  EventTypes2["ENTITY_LEFT"] = "ENTITY_LEFT";
-  EventTypes2["ENTITY_UPDATED"] = "ENTITY_UPDATED";
-  EventTypes2["ROOM_JOINED"] = "ROOM_JOINED";
-  EventTypes2["ROOM_LEFT"] = "ROOM_LEFT";
-  EventTypes2["MESSAGE_RECEIVED"] = "MESSAGE_RECEIVED";
-  EventTypes2["MESSAGE_SENT"] = "MESSAGE_SENT";
-  EventTypes2["VOICE_MESSAGE_RECEIVED"] = "VOICE_MESSAGE_RECEIVED";
-  EventTypes2["VOICE_MESSAGE_SENT"] = "VOICE_MESSAGE_SENT";
-  EventTypes2["REACTION_RECEIVED"] = "REACTION_RECEIVED";
-  EventTypes2["POST_GENERATED"] = "POST_GENERATED";
-  EventTypes2["INTERACTION_RECEIVED"] = "INTERACTION_RECEIVED";
-  EventTypes2["RUN_STARTED"] = "RUN_STARTED";
-  EventTypes2["RUN_ENDED"] = "RUN_ENDED";
-  EventTypes2["RUN_TIMEOUT"] = "RUN_TIMEOUT";
-  EventTypes2["ACTION_STARTED"] = "ACTION_STARTED";
-  EventTypes2["ACTION_COMPLETED"] = "ACTION_COMPLETED";
-  EventTypes2["EVALUATOR_STARTED"] = "EVALUATOR_STARTED";
-  EventTypes2["EVALUATOR_COMPLETED"] = "EVALUATOR_COMPLETED";
-  return EventTypes2;
-})(EventTypes || {});
+var EventType = /* @__PURE__ */ ((EventType2) => {
+  EventType2["WORLD_JOINED"] = "WORLD_JOINED";
+  EventType2["WORLD_CONNECTED"] = "WORLD_CONNECTED";
+  EventType2["WORLD_LEFT"] = "WORLD_LEFT";
+  EventType2["ENTITY_JOINED"] = "ENTITY_JOINED";
+  EventType2["ENTITY_LEFT"] = "ENTITY_LEFT";
+  EventType2["ENTITY_UPDATED"] = "ENTITY_UPDATED";
+  EventType2["ROOM_JOINED"] = "ROOM_JOINED";
+  EventType2["ROOM_LEFT"] = "ROOM_LEFT";
+  EventType2["MESSAGE_RECEIVED"] = "MESSAGE_RECEIVED";
+  EventType2["MESSAGE_SENT"] = "MESSAGE_SENT";
+  EventType2["VOICE_MESSAGE_RECEIVED"] = "VOICE_MESSAGE_RECEIVED";
+  EventType2["VOICE_MESSAGE_SENT"] = "VOICE_MESSAGE_SENT";
+  EventType2["REACTION_RECEIVED"] = "REACTION_RECEIVED";
+  EventType2["POST_GENERATED"] = "POST_GENERATED";
+  EventType2["INTERACTION_RECEIVED"] = "INTERACTION_RECEIVED";
+  EventType2["RUN_STARTED"] = "RUN_STARTED";
+  EventType2["RUN_ENDED"] = "RUN_ENDED";
+  EventType2["RUN_TIMEOUT"] = "RUN_TIMEOUT";
+  EventType2["ACTION_STARTED"] = "ACTION_STARTED";
+  EventType2["ACTION_COMPLETED"] = "ACTION_COMPLETED";
+  EventType2["EVALUATOR_STARTED"] = "EVALUATOR_STARTED";
+  EventType2["EVALUATOR_COMPLETED"] = "EVALUATOR_COMPLETED";
+  return EventType2;
+})(EventType || {});
 var PlatformPrefix = /* @__PURE__ */ ((PlatformPrefix2) => {
   PlatformPrefix2["DISCORD"] = "DISCORD";
   PlatformPrefix2["TELEGRAM"] = "TELEGRAM";
@@ -215,6 +228,9 @@ var PlatformPrefix = /* @__PURE__ */ ((PlatformPrefix2) => {
 var SOCKET_MESSAGE_TYPE = /* @__PURE__ */ ((SOCKET_MESSAGE_TYPE2) => {
   SOCKET_MESSAGE_TYPE2[SOCKET_MESSAGE_TYPE2["ROOM_JOINING"] = 1] = "ROOM_JOINING";
   SOCKET_MESSAGE_TYPE2[SOCKET_MESSAGE_TYPE2["SEND_MESSAGE"] = 2] = "SEND_MESSAGE";
+  SOCKET_MESSAGE_TYPE2[SOCKET_MESSAGE_TYPE2["MESSAGE"] = 3] = "MESSAGE";
+  SOCKET_MESSAGE_TYPE2[SOCKET_MESSAGE_TYPE2["ACK"] = 4] = "ACK";
+  SOCKET_MESSAGE_TYPE2[SOCKET_MESSAGE_TYPE2["THINKING"] = 5] = "THINKING";
   return SOCKET_MESSAGE_TYPE2;
 })(SOCKET_MESSAGE_TYPE || {});
 function createMessageMemory(params) {
@@ -284,9 +300,7 @@ function createServiceError(error, code = "UNKNOWN_ERROR") {
 // src/actions.ts
 import { names, uniqueNamesGenerator } from "unique-names-generator";
 var composeActionExamples = (actionsData, count) => {
-  const data = actionsData.map((action) => [
-    ...action.examples
-  ]);
+  const data = actionsData.map((action) => [...action.examples]);
   const actionExamples = [];
   let length = data.length;
   for (let i = 0; i < count && length; i++) {
@@ -312,10 +326,7 @@ var composeActionExamples = (actionsData, count) => {
 ${example.map((message) => {
       let messageString = `${message.name}: ${message.content.text}${message.content.action ? ` (action: ${message.content.action})` : ""}${message.content.actions ? ` (actions: ${message.content.actions.join(", ")})` : ""}`;
       for (let i = 0; i < exampleNames.length; i++) {
-        messageString = messageString.replaceAll(
-          `{{name${i + 1}}}`,
-          exampleNames[i]
-        );
+        messageString = messageString.replaceAll(`{{name${i + 1}}}`, exampleNames[i]);
       }
       return messageString;
     }).join("\n")}`;
@@ -331,6 +342,10 @@ function formatActions(actions) {
 
 // src/database.ts
 var DatabaseAdapter = class {
+  /**
+   * The database instance.
+   */
+  db;
 };
 
 // src/prompts.ts
@@ -354,13 +369,15 @@ function parseBooleanFromText(value) {
   return false;
 }
 var InMemoryDestination = class {
+  logs = [];
+  maxLogs = 1e3;
+  // Keep last 1000 logs
+  stream;
   /**
    * Constructor for creating a new instance of the class.
    * @param {DestinationStream|null} stream - The stream to assign to the instance. Can be null.
    */
   constructor(stream) {
-    this.logs = [];
-    this.maxLogs = 1e3;
     this.stream = stream;
   }
   /**
@@ -370,16 +387,46 @@ var InMemoryDestination = class {
    * @returns {void}
    */
   write(data) {
-    const logEntry = typeof data === "string" ? JSON.parse(data) : data;
+    let logEntry;
+    let stringData;
+    if (typeof data === "string") {
+      stringData = data;
+      try {
+        logEntry = JSON.parse(data);
+      } catch (e) {
+        if (this.stream) {
+          this.stream.write(data);
+        }
+        return;
+      }
+    } else {
+      logEntry = data;
+      stringData = JSON.stringify(data);
+    }
     if (!logEntry.time) {
       logEntry.time = Date.now();
     }
+    const isDebugMode2 = (process?.env?.LOG_LEVEL || "").toLowerCase() === "debug";
+    const isLoggingDiagnostic = Boolean(process?.env?.LOG_DIAGNOSTIC);
+    if (isLoggingDiagnostic) {
+      logEntry.diagnostic = true;
+    }
+    if (!isDebugMode2) {
+      if (logEntry.agentName && logEntry.agentId) {
+        const msg = logEntry.msg || "";
+        if (typeof msg === "string" && (msg.includes("registered successfully") || msg.includes("Registering") || msg.includes("Success:") || msg.includes("linked to") || msg.includes("Started"))) {
+          if (isLoggingDiagnostic) {
+            console.error("Filtered log:", stringData);
+          }
+          return;
+        }
+      }
+    }
     this.logs.push(logEntry);
     if (this.logs.length > this.maxLogs) {
       this.logs.shift();
     }
     if (this.stream) {
-      const stringData = typeof data === "string" ? data : JSON.stringify(data);
       this.stream.write(stringData);
     }
   }
@@ -404,6 +451,8 @@ var customLevels = {
   trace: 10
 };
 var raw = parseBooleanFromText(process?.env?.LOG_JSON_FORMAT) || false;
+var isDebugMode = (process?.env?.LOG_LEVEL || "").toLowerCase() === "debug";
+var effectiveLogLevel = isDebugMode ? "debug" : process?.env?.DEFAULT_LOG_LEVEL || "info";
 var createStream = async () => {
   if (raw) {
     return void 0;
@@ -413,11 +462,12 @@ var createStream = async () => {
     colorize: true,
     translateTime: "yyyy-mm-dd HH:MM:ss",
     ignore: "pid,hostname"
+    // Don't use minimumLevel since we're filtering in the destination
   });
 };
-var defaultLevel = process?.env?.DEFAULT_LOG_LEVEL || process?.env?.LOG_LEVEL || "info";
 var options = {
-  level: defaultLevel,
+  level: effectiveLogLevel,
+  // Use more restrictive level unless in debug mode
   customLevels,
   hooks: {
     logMethod(inputArgs, method) {
@@ -430,13 +480,9 @@ var options = {
         method.apply(this, [arg1, message]);
       } else {
         const context = {};
-        const messageParts = [arg1, ...rest].map(
-          (arg) => typeof arg === "string" ? arg : arg
-        );
+        const messageParts = [arg1, ...rest].map((arg) => typeof arg === "string" ? arg : arg);
         const message = messageParts.filter((part) => typeof part === "string").join(" ");
-        const jsonParts = messageParts.filter(
-          (part) => typeof part === "object"
-        );
+        const jsonParts = messageParts.filter((part) => typeof part === "object");
         Object.assign(context, ...jsonParts);
         method.apply(this, [context, message]);
       }
@@ -445,11 +491,54 @@ var options = {
 };
 var logger = pino(options);
 if (typeof process !== "undefined") {
-  createStream().then((stream) => {
+  let stream = null;
+  if (!raw) {
+    try {
+      const pretty = __require("pino-pretty");
+      stream = pretty.default ? pretty.default({
+        colorize: true,
+        translateTime: "yyyy-mm-dd HH:MM:ss",
+        ignore: "pid,hostname",
+        customLevels: {
+          names: {
+            fatal: 60,
+            error: 50,
+            warn: 40,
+            info: 30,
+            log: 29,
+            progress: 28,
+            success: 27,
+            debug: 20,
+            trace: 10
+          },
+          // Map custom level values to their display text
+          // This ensures consistent level names in pretty-printed output
+          customLevelNames: {
+            10: "TRACE",
+            20: "DEBUG",
+            27: "SUCCESS",
+            28: "PROGRESS",
+            29: "LOG",
+            30: "INFO",
+            40: "WARN",
+            50: "ERROR",
+            60: "FATAL"
+          }
+        }
+      }) : null;
+    } catch (e) {
+      createStream().then((prettyStream) => {
+        const destination = new InMemoryDestination(prettyStream);
+        logger = pino(options, destination);
+        logger[Symbol.for("pino-destination")] = destination;
+      });
+    }
+  }
+  if (stream !== null || raw) {
     const destination = new InMemoryDestination(stream);
     logger = pino(options, destination);
     logger[Symbol.for("pino-destination")] = destination;
-  });
+  }
 }
 var elizaLogger = logger;
 var logger_default = logger;
@@ -471,17 +560,12 @@ var composePromptFromState = ({
   const templateStr = typeof template === "function" ? template({ state }) : template;
   const templateFunction = handlebars.compile(templateStr);
   const stateKeys = Object.keys(state);
-  const filteredKeys = stateKeys.filter(
-    (key) => !["text", "values", "data"].includes(key)
-  );
+  const filteredKeys = stateKeys.filter((key) => !["text", "values", "data"].includes(key));
   const filteredState = filteredKeys.reduce((acc, key) => {
     acc[key] = state[key];
     return acc;
   }, {});
-  const output = composeRandomUser(
-    templateFunction({ ...filteredState, ...state.values }),
-    10
-  );
+  const output = composeRandomUser(templateFunction({ ...filteredState, ...state.values }), 10);
   return output;
 };
 var addHeader = (header, body) => {
@@ -522,9 +606,7 @@ var formatPosts = ({
   );
   const formattedPosts = sortedRooms.map(([roomId, roomMessages]) => {
     const messageStrings = roomMessages.filter((message) => message.entityId).map((message) => {
-      const entity = entities.find(
-        (entity2) => entity2.id === message.entityId
-      );
+      const entity = entities.find((entity2) => entity2.id === message.entityId);
       const userName = entity?.names[0] || "Unknown User";
       const displayName = entity?.names[0] || "unknown";
       return `Name: ${userName} (@${displayName})
@@ -565,13 +647,7 @@ var formatMessages = ({
     const textString = messageText ? `${timestampString} ${formattedName}: ${messageText}` : null;
     const actionString = messageActions && messageActions.length > 0 ? `${textString ? "" : timestampString} (${formattedName}'s actions: ${messageActions.join(", ")})` : null;
     const planString = newestMessageWithContentPlan?.id === message.id ? `(${formattedName}'s plan: ${newestMessageWithContentPlan?.content?.plan})` : null;
-    const messageString = [
-      textString,
-      thoughtString,
-      planString,
-      actionString,
-      attachmentString
-    ].filter(Boolean).join("\n");
+    const messageString = [textString, thoughtString, planString, actionString, attachmentString].filter(Boolean).join("\n");
     return messageString;
   }).join("\n");
   return messageStrings;
@@ -695,10 +771,7 @@ function parseJsonArrayFromText(text) {
   const jsonBlockMatch = text?.match(jsonBlockPattern);
   if (jsonBlockMatch) {
     try {
-      const normalizedJson = jsonBlockMatch[1].replace(
-        /(?<!\\)'([^']*)'(?=\s*[,}\]])/g,
-        '"$1"'
-      );
+      const normalizedJson = jsonBlockMatch[1].replace(/(?<!\\)'([^']*)'(?=\s*[,}\]])/g, '"$1"');
       jsonData = JSON.parse(normalizeJsonString(normalizedJson));
     } catch (_e) {
       logger_default.warn("Could not parse text as JSON, will try pattern matching");
@@ -709,10 +782,7 @@ function parseJsonArrayFromText(text) {
     const arrayMatch = text.match(arrayPattern);
     if (arrayMatch) {
       try {
-        const normalizedJson = arrayMatch[0].replace(
-          /(?<!\\)'([^']*)'(?=\s*[,}\]])/g,
-          '"$1"'
-        );
+        const normalizedJson = arrayMatch[0].replace(/(?<!\\)'([^']*)'(?=\s*[,}\]])/g, '"$1"');
         jsonData = JSON.parse(normalizeJsonString(normalizedJson));
       } catch (_e) {
         logger_default.warn("Could not parse text as JSON, returning null");
@@ -752,9 +822,7 @@ function extractAttributes(response, attributesToExtract) {
     }
   } else {
     for (const attribute of attributesToExtract) {
-      const match = response.match(
-        new RegExp(`"${attribute}"\\s*:\\s*"([^"]*)"`, "i")
-      );
+      const match = response.match(new RegExp(`"${attribute}"\\s*:\\s*"([^"]*)"`, "i"));
       if (match) {
         attributes[attribute] = match[1];
       }
@@ -764,14 +832,8 @@ function extractAttributes(response, attributesToExtract) {
 }
 var normalizeJsonString = (str) => {
   str = str.replace(/\{\s+/, "{").replace(/\s+\}/, "}").trim();
-  str = str.replace(
-    /("[\w\d_-]+")\s*: \s*(?!"|\[)([\s\S]+?)(?=(,\s*"|\}$))/g,
-    '$1: "$2"'
-  );
-  str = str.replace(
-    /"([^"]+)"\s*:\s*'([^']*)'/g,
-    (_, key, value) => `"${key}": "${value}"`
-  );
+  str = str.replace(/("[\w\d_-]+")\s*: \s*(?!"|\[)([\s\S]+?)(?=(,\s*"|\}$))/g, '$1: "$2"');
+  str = str.replace(/"([^"]+)"\s*:\s*'([^']*)'/g, (_, key, value) => `"${key}": "${value}"`);
   str = str.replace(/("[\w\d_-]+")\s*:\s*([A-Za-z_]+)(?!["\w])/g, '$1: "$2"');
   str = str.replace(/(?:"')|(?:'")/g, '"');
   return str;
@@ -1014,17 +1076,14 @@ async function findEntityByName(runtime, message, state) {
     if (resolution.matches?.[0]?.name) {
       const matchName = resolution.matches[0].name.toLowerCase();
       const matchingEntity = allEntities.find((entity) => {
-        if (entity.names.some((n) => n.toLowerCase() === matchName))
-          return true;
+        if (entity.names.some((n) => n.toLowerCase() === matchName)) return true;
         return entity.components?.some(
           (c) => c.data.username?.toLowerCase() === matchName || c.data.handle?.toLowerCase() === matchName
         );
       });
       if (matchingEntity) {
         if (resolution.type === "RELATIONSHIP_MATCH") {
-          const interactionInfo = interactionData.find(
-            (d) => d.entity.id === matchingEntity.id
-          );
+          const interactionInfo = interactionData.find((d) => d.entity.id === matchingEntity.id);
           if (interactionInfo && interactionInfo.count > 0) {
             return matchingEntity;
           }
@@ -1093,175 +1152,6 @@ Data: ${JSON.stringify(entity.metadata)}
   return entityStrings.join("\n");
 }
 
-// src/environment.ts
-import fs from "node:fs";
-import path from "node:path";
-import { config } from "dotenv";
-import { z } from "zod";
-var environmentSettings = {};
-var isBrowser = () => {
-  return typeof window !== "undefined" && typeof window.document !== "undefined";
-};
-function findNearestEnvFile(startDir = process.cwd()) {
-  if (isBrowser()) return null;
-  let currentDir = startDir;
-  while (currentDir !== path.parse(currentDir).root) {
-    const envPath = path.join(currentDir, ".env");
-    if (fs.existsSync(envPath)) {
-      return envPath;
-    }
-    currentDir = path.dirname(currentDir);
-  }
-  const rootEnvPath = path.join(path.parse(currentDir).root, ".env");
-  return fs.existsSync(rootEnvPath) ? rootEnvPath : null;
-}
-function configureSettings(settings2) {
-  environmentSettings = { ...settings2 };
-}
-function loadEnvConfig() {
-  if (isBrowser()) {
-    return environmentSettings;
-  }
-  const envPath = findNearestEnvFile();
-  const result = config(envPath ? { path: envPath } : {});
-  if (!result.error) {
-    logger_default.log(`Loaded .env file from: ${envPath}`);
-  }
-  const env = typeof process !== "undefined" ? process.env : import.meta.env;
-  const namespacedSettings = parseNamespacedSettings(env);
-  if (typeof process !== "undefined") {
-    Object.entries(namespacedSettings).forEach(([namespace, settings2]) => {
-      process.env[`__namespaced_${namespace}`] = JSON.stringify(settings2);
-    });
-  }
-  return env;
-}
-function getEnvVariable(key, defaultValue) {
-  if (isBrowser()) {
-    return environmentSettings[key] || defaultValue;
-  }
-  const env = typeof process !== "undefined" ? process.env : import.meta.env;
-  return env[key] || defaultValue;
-}
-function hasEnvVariable(key) {
-  if (isBrowser()) {
-    return key in environmentSettings;
-  }
-  const env = typeof process !== "undefined" ? process.env : import.meta.env;
-  return key in env;
-}
-function parseNamespacedSettings(env) {
-  const namespaced = {};
-  for (const [key, value] of Object.entries(env)) {
-    if (!value) continue;
-    const [namespace, ...rest] = key.split(".");
-    if (!namespace || rest.length === 0) continue;
-    const settingKey = rest.join(".");
-    namespaced[namespace] = namespaced[namespace] || {};
-    namespaced[namespace][settingKey] = value;
-  }
-  return namespaced;
-}
-var settings = isBrowser() ? environmentSettings : loadEnvConfig();
-var MessageExampleSchema = z.object({
-  name: z.string(),
-  content: z.object({
-    text: z.string(),
-    action: z.string().optional(),
-    source: z.string().optional(),
-    url: z.string().optional(),
-    inReplyTo: z.string().uuid().optional(),
-    attachments: z.array(z.any()).optional()
-  }).and(z.record(z.string(), z.unknown()))
-  // For additional properties
-});
-var PluginSchema = z.object({
-  name: z.string(),
-  description: z.string(),
-  actions: z.array(z.any()).optional(),
-  providers: z.array(z.any()).optional(),
-  evaluators: z.array(z.any()).optional(),
-  services: z.array(z.any()).optional(),
-  clients: z.array(z.any()).optional()
-});
-var CharacterSchema = z.object({
-  id: z.string().uuid().optional(),
-  name: z.string(),
-  system: z.string().optional(),
-  templates: z.record(z.string()).optional(),
-  bio: z.union([z.string(), z.array(z.string())]),
-  messageExamples: z.array(z.array(MessageExampleSchema)),
-  postExamples: z.array(z.string()),
-  topics: z.array(z.string()),
-  adjectives: z.array(z.string()),
-  knowledge: z.array(
-    z.union([
-      z.string(),
-      // Direct knowledge strings
-      z.object({
-        // Individual file config
-        path: z.string(),
-        shared: z.boolean().optional()
-      }),
-      z.object({
-        // Directory config
-        directory: z.string(),
-        shared: z.boolean().optional()
-      })
-    ])
-  ).optional(),
-  plugins: z.union([z.array(z.string()), z.array(PluginSchema)]),
-  settings: z.object({
-    secrets: z.record(z.string()).optional(),
-    voice: z.object({
-      model: z.string().optional(),
-      url: z.string().optional()
-    }).optional(),
-    model: z.string().optional(),
-    modelConfig: z.object({
-      maxInputTokens: z.number().optional(),
-      maxOutputTokens: z.number().optional(),
-      temperature: z.number().optional(),
-      frequency_penalty: z.number().optional(),
-      presence_penalty: z.number().optional()
-    }).optional(),
-    embeddingModel: z.string().optional()
-  }).optional(),
-  style: z.object({
-    all: z.array(z.string()),
-    chat: z.array(z.string()),
-    post: z.array(z.string())
-  })
-});
-function validateCharacterConfig(json) {
-  try {
-    return CharacterSchema.parse(json);
-  } catch (error) {
-    if (error instanceof z.ZodError) {
-      const groupedErrors = error.errors.reduce(
-        (acc, err) => {
-          const path3 = err.path.join(".");
-          if (!acc[path3]) {
-            acc[path3] = [];
-          }
-          acc[path3].push(err.message);
-          return acc;
-        },
-        {}
-      );
-      for (const field in groupedErrors) {
-        logger_default.error(
-          `Validation errors in ${field}: ${groupedErrors[field].join(" - ")}`
-        );
-      }
-      throw new Error(
-        "Character configuration validation failed. Check logs for details."
-      );
-    }
-    throw error;
-  }
-}
-
 // src/import.ts
 var registrations = /* @__PURE__ */ new Map();
 var dynamicImport = async (specifier) => {
@@ -1276,7 +1166,6 @@ var registerDynamicImport = (specifier, module) => {
 };
 async function handlePluginImporting(plugins) {
   if (plugins.length > 0) {
-    logger_default.debug("Imported are: ", plugins);
     const importedPlugins = await Promise.all(
       plugins.map(async (plugin) => {
         try {
@@ -1342,8 +1231,8 @@ async function findWorldForOwner(runtime, entityId) {
 import { v4 as uuidv43 } from "uuid";
 
 // src/bootstrap.ts
-import fs2 from "node:fs";
-import path2 from "node:path";
+import fs from "node:fs";
+import path from "node:path";
 import { v4 } from "uuid";
 
 // src/actions/choice.ts
@@ -1388,11 +1277,7 @@ var choiceAction = {
       tags: ["AWAITING_CHOICE"]
     });
     const room = state.data.room ?? await runtime.getRoom(message.roomId);
-    const userRole = await getUserServerRole(
-      runtime,
-      message.entityId,
-      room.serverId
-    );
+    const userRole = await getUserServerRole(runtime, message.entityId, room.serverId);
     if (userRole !== "OWNER" && userRole !== "ADMIN") {
       return false;
     }
@@ -1407,9 +1292,7 @@ var choiceAction = {
       if (!pendingTasks?.length) {
         throw new Error("No pending tasks with options found");
       }
-      const tasksWithOptions = pendingTasks.filter(
-        (task) => task.metadata?.options
-      );
+      const tasksWithOptions = pendingTasks.filter((task) => task.metadata?.options);
       if (!tasksWithOptions.length) {
         throw new Error("No tasks currently have options to select from.");
       }
@@ -1444,9 +1327,7 @@ ${task.options.map((opt) => `- ${opt.name}: ${opt.description}`).join("\n")}`;
       const parsed = parseJSONObjectFromText(result);
       const { taskId, selectedOption } = parsed;
       if (taskId && selectedOption) {
-        const taskMap = new Map(
-          formattedTasks.map((task) => [task.taskId, task])
-        );
+        const taskMap = new Map(formattedTasks.map((task) => [task.taskId, task]));
         const taskInfo = taskMap.get(taskId);
         if (!taskInfo) {
           await callback({
@@ -1456,9 +1337,7 @@ ${task.options.map((opt) => `- ${opt.name}: ${opt.description}`).join("\n")}`;
           });
           return;
         }
-        const selectedTask = tasksWithOptions.find(
-          (task) => task.id === taskInfo.fullId
-        );
+        const selectedTask = tasksWithOptions.find((task) => task.id === taskInfo.fullId);
         if (!selectedTask) {
           await callback({
             text: "Error locating the selected task. Please try again.",
@@ -1478,11 +1357,7 @@ ${task.options.map((opt) => `- ${opt.name}: ${opt.description}`).join("\n")}`;
         }
         try {
           const taskWorker = runtime.getTaskWorker(selectedTask.name);
-          await taskWorker.execute(
-            runtime,
-            { option: selectedOption },
-            selectedTask
-          );
+          await taskWorker.execute(runtime, { option: selectedOption }, selectedTask);
           await callback({
             text: `Selected option: ${selectedOption} for task: ${selectedTask.name}`,
             actions: ["CHOOSE_OPTION"],
@@ -1574,25 +1449,11 @@ Otherwise, respond with NO.
 ${booleanFooter}`;
 var followRoomAction = {
   name: "FOLLOW_ROOM",
-  similes: [
-    "FOLLOW_CHAT",
-    "FOLLOW_CHANNEL",
-    "FOLLOW_CONVERSATION",
-    "FOLLOW_THREAD"
-  ],
+  similes: ["FOLLOW_CHAT", "FOLLOW_CHANNEL", "FOLLOW_CONVERSATION", "FOLLOW_THREAD"],
   description: "Start following this channel with great interest, chiming in without needing to be explicitly mentioned. Only do this if explicitly asked to.",
   validate: async (runtime, message) => {
-    const keywords = [
-      "follow",
-      "participate",
-      "engage",
-      "listen",
-      "take interest",
-      "join"
-    ];
-    if (!keywords.some(
-      (keyword) => message.content.text?.toLowerCase().includes(keyword)
-    )) {
+    const keywords = ["follow", "participate", "engage", "listen", "take interest", "join"];
+    if (!keywords.some((keyword) => message.content.text?.toLowerCase().includes(keyword))) {
       return false;
     }
     const roomId = message.roomId;
@@ -1613,35 +1474,41 @@ var followRoomAction = {
       });
       const cleanedResponse = response.trim().toLowerCase();
       if (cleanedResponse === "true" || cleanedResponse === "yes" || cleanedResponse === "y" || cleanedResponse.includes("true") || cleanedResponse.includes("yes")) {
-        await runtime.createMemory({
-          entityId: message.entityId,
-          agentId: message.agentId,
-          roomId: message.roomId,
-          content: {
-            source: message.content.source,
-            thought: "I will now follow this room and chime in",
-            actions: ["FOLLOW_ROOM_STARTED"]
+        await runtime.createMemory(
+          {
+            entityId: message.entityId,
+            agentId: message.agentId,
+            roomId: message.roomId,
+            content: {
+              source: message.content.source,
+              thought: "I will now follow this room and chime in",
+              actions: ["FOLLOW_ROOM_STARTED"]
+            },
+            metadata: {
+              type: "FOLLOW_ROOM"
+            }
           },
-          metadata: {
-            type: "FOLLOW_ROOM"
-          }
-        }, "messages");
+          "messages"
+        );
         return true;
       }
       if (cleanedResponse === "false" || cleanedResponse === "no" || cleanedResponse === "n" || cleanedResponse.includes("false") || cleanedResponse.includes("no")) {
-        await runtime.createMemory({
-          entityId: message.entityId,
-          agentId: message.agentId,
-          roomId: message.roomId,
-          content: {
-            source: message.content.source,
-            thought: "I decided to not follow this room",
-            actions: ["FOLLOW_ROOM_FAILED"]
+        await runtime.createMemory(
+          {
+            entityId: message.entityId,
+            agentId: message.agentId,
+            roomId: message.roomId,
+            content: {
+              source: message.content.source,
+              thought: "I decided to not follow this room",
+              actions: ["FOLLOW_ROOM_FAILED"]
+            },
+            metadata: {
+              type: "FOLLOW_ROOM"
+            }
           },
-          metadata: {
-            type: "FOLLOW_ROOM"
-          }
-        }, "messages");
+          "messages"
+        );
         return false;
       }
       logger_default.warn(`Unclear boolean response: ${response}, defaulting to false`);
@@ -1651,15 +1518,18 @@ var followRoomAction = {
       await runtime.setParticipantUserState(message.roomId, runtime.agentId, "FOLLOWED");
     }
     const room = state.data.room ?? await runtime.getRoom(message.roomId);
-    await runtime.createMemory({
-      entityId: message.entityId,
-      agentId: message.agentId,
-      roomId: message.roomId,
-      content: {
-        thought: `I followed the room ${room.name}`,
-        actions: ["FOLLOW_ROOM_START"]
-      }
-    }, "messages");
+    await runtime.createMemory(
+      {
+        entityId: message.entityId,
+        agentId: message.agentId,
+        roomId: message.roomId,
+        content: {
+          thought: `I followed the room ${room.name}`,
+          actions: ["FOLLOW_ROOM_START"]
+        }
+      },
+      "messages"
+    );
   },
   examples: [
     [
@@ -2170,13 +2040,7 @@ Otherwise, respond with NO.
 ${booleanFooter}`;
 var muteRoomAction = {
   name: "MUTE_ROOM",
-  similes: [
-    "MUTE_CHAT",
-    "MUTE_CONVERSATION",
-    "MUTE_ROOM",
-    "MUTE_THREAD",
-    "MUTE_CHANNEL"
-  ],
+  similes: ["MUTE_CHAT", "MUTE_CONVERSATION", "MUTE_ROOM", "MUTE_THREAD", "MUTE_CHANNEL"],
   description: "Mutes a room, ignoring all messages unless explicitly mentioned. Only do this if explicitly asked to, or if you're annoying people.",
   validate: async (runtime, message) => {
     const roomId = message.roomId;
@@ -2197,35 +2061,41 @@ var muteRoomAction = {
       });
       const cleanedResponse = response.trim().toLowerCase();
       if (cleanedResponse === "true" || cleanedResponse === "yes" || cleanedResponse === "y" || cleanedResponse.includes("true") || cleanedResponse.includes("yes")) {
-        await runtime.createMemory({
-          entityId: message.entityId,
-          agentId: message.agentId,
-          roomId: message.roomId,
-          content: {
-            source: message.content.source,
-            thought: "I will now mute this room",
-            actions: ["MUTE_ROOM_STARTED"]
+        await runtime.createMemory(
+          {
+            entityId: message.entityId,
+            agentId: message.agentId,
+            roomId: message.roomId,
+            content: {
+              source: message.content.source,
+              thought: "I will now mute this room",
+              actions: ["MUTE_ROOM_STARTED"]
+            },
+            metadata: {
+              type: "MUTE_ROOM"
+            }
           },
-          metadata: {
-            type: "MUTE_ROOM"
-          }
-        }, "messages");
+          "messages"
+        );
         return true;
       }
       if (cleanedResponse === "false" || cleanedResponse === "no" || cleanedResponse === "n" || cleanedResponse.includes("false") || cleanedResponse.includes("no")) {
-        await runtime.createMemory({
-          entityId: message.entityId,
-          agentId: message.agentId,
-          roomId: message.roomId,
-          content: {
-            source: message.content.source,
-            thought: "I decided to not mute this room",
-            actions: ["MUTE_ROOM_FAILED"]
+        await runtime.createMemory(
+          {
+            entityId: message.entityId,
+            agentId: message.agentId,
+            roomId: message.roomId,
+            content: {
+              source: message.content.source,
+              thought: "I decided to not mute this room",
+              actions: ["MUTE_ROOM_FAILED"]
+            },
+            metadata: {
+              type: "MUTE_ROOM"
+            }
           },
-          metadata: {
-            type: "MUTE_ROOM"
-          }
-        }, "messages");
+          "messages"
+        );
       }
       logger_default.warn(`Unclear boolean response: ${response}, defaulting to false`);
       return false;
@@ -2234,15 +2104,18 @@ var muteRoomAction = {
       await runtime.setParticipantUserState(message.roomId, runtime.agentId, "MUTED");
     }
     const room = state.data.room ?? await runtime.getRoom(message.roomId);
-    await runtime.createMemory({
-      entityId: message.entityId,
-      agentId: message.agentId,
-      roomId: message.roomId,
-      content: {
-        thought: `I muted the room ${room.name}`,
-        actions: ["MUTE_ROOM_START"]
-      }
-    }, "messages");
+    await runtime.createMemory(
+      {
+        entityId: message.entityId,
+        agentId: message.agentId,
+        roomId: message.roomId,
+        content: {
+          thought: `I muted the room ${room.name}`,
+          actions: ["MUTE_ROOM_START"]
+        }
+      },
+      "messages"
+    );
   },
   examples: [
     [
@@ -2507,7 +2380,7 @@ Response format should be formatted in a valid JSON block like this:
 Your response should include the valid JSON block and nothing else.`;
 var replyAction = {
   name: "REPLY",
-  similes: ["GREET", "REPLY_TO_MESSAGE", "SEND_REPLY", "RESPOND"],
+  similes: ["GREET", "REPLY_TO_MESSAGE", "SEND_REPLY", "RESPOND", "RESPONSE"],
   description: "Replies to the current conversation with the text from the generated message. Default if the agent is responding with a message and no other action. Use REPLY at the beginning of a chain of actions as an acknowledgement, and at the end of a chain of actions as a final response.",
   validate: async (_runtime) => {
     return true;
@@ -2622,7 +2495,7 @@ var updateRoleAction = {
     const serverId = message.content.serverId;
     return (
       // First, check if this is a supported channel type
-      (channelType === "GROUP" /* GROUP */ || channelType === "WORLD" /* WORLD */) && // Then, check if we have a server ID
+      (channelType === "group" /* GROUP */ || channelType === "WORLD" /* WORLD */) && // Then, check if we have a server ID
       !!serverId
     );
   },
@@ -2685,24 +2558,27 @@ var updateRoleAction = {
 				\`\`\`
 			`
     });
-    const result = await runtime.useModel(ModelType.OBJECT_LARGE, {
-      prompt: extractionPrompt,
-      schema: {
-        type: "array",
-        items: {
-          type: "object",
-          properties: {
-            entityId: { type: "string" },
-            newRole: {
-              type: "string",
-              enum: Object.values(Role)
-            }
-          },
-          required: ["entityId", "newRole"]
-        }
-      },
-      output: "array"
-    });
+    const result = await runtime.useModel(
+      ModelType.OBJECT_LARGE,
+      {
+        prompt: extractionPrompt,
+        schema: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              entityId: { type: "string" },
+              newRole: {
+                type: "string",
+                enum: Object.values(Role)
+              }
+            },
+            required: ["entityId", "newRole"]
+          }
+        },
+        output: "array"
+      }
+    );
     if (!result?.length) {
       await callback({
         text: "No valid role assignments found in the request.",
@@ -2715,11 +2591,7 @@ var updateRoleAction = {
     for (const assignment of result) {
       let targetEntity = entities.find((e) => e.id === assignment.entityId);
       if (!targetEntity) {
-        targetEntity = entities.find((e) => e.id === assignment.entityId);
-        console.log("Trying to write to generated tenant ID");
-      }
-      if (!targetEntity) {
-        console.log("Could not find an ID ot assign to");
+        logger.error("Could not find an ID ot assign to");
       }
       const currentRole = world.metadata.roles[assignment.entityId];
       if (!canModifyRole(requesterRole, currentRole, assignment.newRole)) {
@@ -2890,7 +2762,12 @@ var sendMessageAction = {
           });
           return;
         }
-        const userComponent = await runtime.getComponent(targetEntity.id, source, worldId, sourceEntityId);
+        const userComponent = await runtime.getComponent(
+          targetEntity.id,
+          source,
+          worldId,
+          sourceEntityId
+        );
         if (!userComponent) {
           await callback({
             text: `I couldn't find ${source} information for that user. Could you please provide their ${source} details?`,
@@ -2909,13 +2786,7 @@ var sendMessageAction = {
           return;
         }
         try {
-          await sendDirectMessage(
-            runtime,
-            targetEntity.id,
-            source,
-            message.content.text,
-            worldId
-          );
+          await sendDirectMessage(runtime, targetEntity.id, source, message.content.text, worldId);
           await callback({
             text: `Message sent to ${targetEntity.names[0]} on ${source}.`,
             actions: ["SEND_MESSAGE"],
@@ -2952,13 +2823,7 @@ var sendMessageAction = {
           return;
         }
         try {
-          await sendRoomMessage(
-            runtime,
-            targetRoom.id,
-            source,
-            message.content.text,
-            worldId
-          );
+          await sendRoomMessage(runtime, targetRoom.id, source, message.content.text, worldId);
           await callback({
             text: `Message sent to ${targetRoom.name} on ${source}.`,
             actions: ["SEND_MESSAGE"],
@@ -3158,12 +3023,12 @@ async function updateWorldSettings(runtime, serverId, worldSettings) {
   }
 }
 function formatSettingsList(worldSettings) {
-  const settings2 = Object.entries(worldSettings).filter(([key]) => !key.startsWith("_")).map(([key, setting]) => {
+  const settings = Object.entries(worldSettings).filter(([key]) => !key.startsWith("_")).map(([key, setting]) => {
     const status = setting.value !== null ? "Configured" : "Not configured";
     const required = setting.required ? "Required" : "Optional";
     return `- ${setting.name} (${key}): ${status}, ${required}`;
   }).join("\n");
-  return settings2 || "No settings available";
+  return settings || "No settings available";
 }
 function categorizeSettings(worldSettings) {
   const configured = [];
@@ -3201,21 +3066,24 @@ async function extractSettingValues(runtime, _message, state, worldSettings) {
     If a setting is mentioned but no clear value is provided, do not include it.
     `;
   try {
-    const result = await runtime.useModel(ModelType.OBJECT_LARGE, {
-      prompt: basePrompt,
-      output: "array",
-      schema: {
-        type: "array",
-        items: {
-          type: "object",
-          properties: {
-            key: { type: "string" },
-            value: { type: "string" }
-          },
-          required: ["key", "value"]
+    const result = await runtime.useModel(
+      ModelType.OBJECT_LARGE,
+      {
+        prompt: basePrompt,
+        output: "array",
+        schema: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              key: { type: "string" },
+              value: { type: "string" }
+            },
+            required: ["key", "value"]
+          }
         }
       }
-    });
+    );
     if (!result || !Array.isArray(result)) {
       return [];
     }
@@ -3239,9 +3107,7 @@ async function processSettingUpdates(runtime, serverId, worldSettings, updates)
       const setting = updatedState[update.key];
       if (!setting) continue;
       if (setting.dependsOn?.length) {
-        const dependenciesMet = setting.dependsOn.every(
-          (dep) => updatedState[dep]?.value !== null
-        );
+        const dependenciesMet = setting.dependsOn.every((dep) => updatedState[dep]?.value !== null);
         if (!dependenciesMet) {
           messages.push(`Cannot update ${setting.name} - dependencies not met`);
           continue;
@@ -3402,10 +3268,8 @@ var updateSettingsAction = {
   description: "Saves a configuration setting during the onboarding process, or update an existing setting. Use this when you are onboarding with a world owner or admin.",
   validate: async (runtime, message, _state) => {
     try {
-      if (message.content.channelType !== "DM" /* DM */) {
-        logger.info(
-          `Skipping settings in non-DM channel (type: ${message.content.channelType})`
-        );
+      if (message.content.channelType !== "dm" /* DM */) {
+        logger.info(`Skipping settings in non-DM channel (type: ${message.content.channelType})`);
         return false;
       }
       logger.info(`Looking for server where user ${message.entityId} is owner`);
@@ -3429,10 +3293,7 @@ var updateSettingsAction = {
   handler: async (runtime, message, state, _options, callback) => {
     try {
       logger.info(`Handler looking for server for user ${message.entityId}`);
-      const serverOwnership = await findWorldForOwner(
-        runtime,
-        message.entityId
-      );
+      const serverOwnership = await findWorldForOwner(runtime, message.entityId);
       if (!serverOwnership) {
         logger.error(`No server found for user ${message.entityId} in handler`);
         await generateErrorResponse(runtime, state, callback);
@@ -3442,9 +3303,7 @@ var updateSettingsAction = {
       logger.info(`Using server ID: ${serverId}`);
       const worldSettings = await getWorldSettings(runtime, serverId);
       if (!worldSettings) {
-        logger.error(
-          `No settings state found for server ${serverId} in handler`
-        );
+        logger.error(`No settings state found for server ${serverId} in handler`);
         await generateErrorResponse(runtime, state, callback);
         return;
       }
@@ -3455,12 +3314,7 @@ var updateSettingsAction = {
         return;
       }
       logger.info(`Extracting settings from message: ${message.content.text}`);
-      const extractedSettings = await extractSettingValues(
-        runtime,
-        message,
-        state,
-        worldSettings
-      );
+      const extractedSettings = await extractSettingValues(runtime, message, state, worldSettings);
       logger.info(`Extracted ${extractedSettings.length} settings`);
       const updateResults = await processSettingUpdates(
         runtime,
@@ -3469,9 +3323,7 @@ var updateSettingsAction = {
         extractedSettings
       );
       if (updateResults.updatedAny) {
-        logger.info(
-          `Successfully updated settings: ${updateResults.messages.join(", ")}`
-        );
+        logger.info(`Successfully updated settings: ${updateResults.messages.join(", ")}`);
         const updatedWorldSettings = await getWorldSettings(runtime, serverId);
         if (!updatedWorldSettings) {
           logger.error("Failed to retrieve updated settings state");
@@ -3684,12 +3536,7 @@ Otherwise, respond with NO.
 ${booleanFooter}`;
 var unfollowRoomAction = {
   name: "UNFOLLOW_ROOM",
-  similes: [
-    "UNFOLLOW_CHAT",
-    "UNFOLLOW_CONVERSATION",
-    "UNFOLLOW_ROOM",
-    "UNFOLLOW_THREAD"
-  ],
+  similes: ["UNFOLLOW_CHAT", "UNFOLLOW_CONVERSATION", "UNFOLLOW_ROOM", "UNFOLLOW_THREAD"],
   description: "Stop following this channel. You can still respond if explicitly mentioned, but you won't automatically chime in anymore. Unfollow if you're annoying people or have been asked to.",
   validate: async (runtime, message) => {
     const roomId = message.roomId;
@@ -3712,29 +3559,35 @@ var unfollowRoomAction = {
     if (await _shouldUnfollow(state)) {
       await runtime.setParticipantUserState(message.roomId, runtime.agentId, null);
       const room = state.data.room ?? await runtime.getRoom(message.roomId);
-      await runtime.createMemory({
-        entityId: message.entityId,
-        agentId: message.agentId,
-        roomId: message.roomId,
-        content: {
-          thought: `I unfollowed the room ${room.name}`,
-          actions: ["UNFOLLOW_ROOM_START"]
-        }
-      }, "messages");
+      await runtime.createMemory(
+        {
+          entityId: message.entityId,
+          agentId: message.agentId,
+          roomId: message.roomId,
+          content: {
+            thought: `I unfollowed the room ${room.name}`,
+            actions: ["UNFOLLOW_ROOM_START"]
+          }
+        },
+        "messages"
+      );
     } else {
-      await runtime.createMemory({
-        entityId: message.entityId,
-        agentId: message.agentId,
-        roomId: message.roomId,
-        content: {
-          source: message.content.source,
-          thought: "I tried to unfollow a room but I'm not in a room",
-          actions: ["UNFOLLOW_ROOM_FAILED"]
+      await runtime.createMemory(
+        {
+          entityId: message.entityId,
+          agentId: message.agentId,
+          roomId: message.roomId,
+          content: {
+            source: message.content.source,
+            thought: "I tried to unfollow a room but I'm not in a room",
+            actions: ["UNFOLLOW_ROOM_FAILED"]
+          },
+          metadata: {
+            type: "UNFOLLOW_ROOM"
+          }
         },
-        metadata: {
-          type: "UNFOLLOW_ROOM"
-        }
-      }, "messages");
+        "messages"
+      );
     }
   },
   examples: [
@@ -3999,12 +3852,7 @@ Otherwise, respond with NO.
 ${booleanFooter}`;
 var unmuteRoomAction = {
   name: "UNMUTE_ROOM",
-  similes: [
-    "UNMUTE_CHAT",
-    "UNMUTE_CONVERSATION",
-    "UNMUTE_ROOM",
-    "UNMUTE_THREAD"
-  ],
+  similes: ["UNMUTE_CHAT", "UNMUTE_CONVERSATION", "UNMUTE_ROOM", "UNMUTE_THREAD"],
   description: "Unmutes a room, allowing the agent to consider responding to messages again.",
   validate: async (runtime, message) => {
     const roomId = message.roomId;
@@ -4025,35 +3873,41 @@ var unmuteRoomAction = {
       });
       const cleanedResponse = response.trim().toLowerCase();
       if (cleanedResponse === "true" || cleanedResponse === "yes" || cleanedResponse === "y" || cleanedResponse.includes("true") || cleanedResponse.includes("yes")) {
-        await runtime.createMemory({
-          entityId: message.entityId,
-          agentId: message.agentId,
-          roomId: message.roomId,
-          content: {
-            source: message.content.source,
-            thought: "I will now unmute this room and start considering it for responses again",
-            actions: ["UNMUTE_ROOM_STARTED"]
-          },
-          metadata: {
-            type: "UNMUTE_ROOM"
-          }
-        }, "messages");
+        await runtime.createMemory(
+          {
+            entityId: message.entityId,
+            agentId: message.agentId,
+            roomId: message.roomId,
+            content: {
+              source: message.content.source,
+              thought: "I will now unmute this room and start considering it for responses again",
+              actions: ["UNMUTE_ROOM_STARTED"]
+            },
+            metadata: {
+              type: "UNMUTE_ROOM"
+            }
+          },
+          "messages"
+        );
         return true;
       }
       if (cleanedResponse === "false" || cleanedResponse === "no" || cleanedResponse === "n" || cleanedResponse.includes("false") || cleanedResponse.includes("no")) {
-        await runtime.createMemory({
-          entityId: message.entityId,
-          agentId: message.agentId,
-          roomId: message.roomId,
-          content: {
-            source: message.content.source,
-            thought: "I tried to unmute a room but I decided not to",
-            actions: ["UNMUTE_ROOM_FAILED"]
+        await runtime.createMemory(
+          {
+            entityId: message.entityId,
+            agentId: message.agentId,
+            roomId: message.roomId,
+            content: {
+              source: message.content.source,
+              thought: "I tried to unmute a room but I decided not to",
+              actions: ["UNMUTE_ROOM_FAILED"]
+            },
+            metadata: {
+              type: "UNMUTE_ROOM"
+            }
           },
-          metadata: {
-            type: "UNMUTE_ROOM"
-          }
-        }, "messages");
+          "messages"
+        );
         return false;
       }
       logger_default.warn(`Unclear boolean response: ${response}, defaulting to false`);
@@ -4063,15 +3917,18 @@ var unmuteRoomAction = {
       await runtime.setParticipantUserState(message.roomId, runtime.agentId, null);
     }
     const room = await runtime.getRoom(message.roomId);
-    await runtime.createMemory({
-      entityId: message.entityId,
-      agentId: message.agentId,
-      roomId: message.roomId,
-      content: {
-        thought: `I unmuted the room ${room.name}`,
-        actions: ["UNMUTE_ROOM_START"]
-      }
-    }, "messages");
+    await runtime.createMemory(
+      {
+        entityId: message.entityId,
+        agentId: message.agentId,
+        roomId: message.roomId,
+        content: {
+          thought: `I unmuted the room ${room.name}`,
+          actions: ["UNMUTE_ROOM_START"]
+        }
+      },
+      "messages"
+    );
   },
   examples: [
     [
@@ -4277,7 +4134,12 @@ var updateEntityAction = {
       }
       const componentType = parsedResult.source.toLowerCase();
       const componentData = parsedResult.data;
-      existingComponent = await runtime.getComponent(entity.id, componentType, worldId, sourceEntityId);
+      existingComponent = await runtime.getComponent(
+        entity.id,
+        componentType,
+        worldId,
+        sourceEntityId
+      );
       if (existingComponent) {
         await runtime.updateComponent({
           id: existingComponent.id,
@@ -4370,26 +4232,26 @@ var updateEntityAction = {
 };
 
 // src/evaluators/reflection.ts
-import { z as z2 } from "zod";
-var relationshipSchema = z2.object({
-  sourceEntityId: z2.string(),
-  targetEntityId: z2.string(),
-  tags: z2.array(z2.string()),
-  metadata: z2.object({
-    interactions: z2.number()
+import { z } from "zod";
+var relationshipSchema = z.object({
+  sourceEntityId: z.string(),
+  targetEntityId: z.string(),
+  tags: z.array(z.string()),
+  metadata: z.object({
+    interactions: z.number()
   }).optional()
 });
-var reflectionSchema = z2.object({
+var reflectionSchema = z.object({
   // reflection: z.string(),
-  facts: z2.array(
-    z2.object({
-      claim: z2.string(),
-      type: z2.string(),
-      in_bio: z2.boolean(),
-      already_known: z2.boolean()
+  facts: z.array(
+    z.object({
+      claim: z.string(),
+      type: z.string(),
+      in_bio: z.boolean(),
+      already_known: z.boolean()
     })
   ),
-  relationships: z2.array(relationshipSchema)
+  relationships: z.array(relationshipSchema)
 });
 var reflectionTemplate = `# Task: Generate Agent Reflection, Extract Facts and Relationships
 
@@ -4444,9 +4306,7 @@ Generate a response in the following format:
 }
 \`\`\``;
 function resolveEntity(entityId, entities) {
-  if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(
-    entityId
-  )) {
+  if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(entityId)) {
     return entityId;
   }
   let entity;
@@ -4491,93 +4351,98 @@ async function handler(runtime, message, state) {
     },
     template: runtime.character.templates?.reflectionTemplate || reflectionTemplate
   });
-  const reflection = await runtime.useModel(ModelType.OBJECT_SMALL, {
-    prompt,
-    schema: reflectionSchema
-  });
-  if (!reflection) {
-    logger_default.warn("Getting reflection failed", prompt);
-    return;
-  }
-  const newFacts = reflection?.facts.filter(
-    (fact) => !fact.already_known && !fact.in_bio && fact.claim && fact.claim.trim() !== ""
-  ) || [];
-  await Promise.all(
-    newFacts.map(async (fact) => {
-      const factMemory = await runtime.addEmbeddingToMemory({
-        entityId: agentId,
-        agentId,
-        content: { text: fact.claim },
-        roomId,
-        createdAt: Date.now()
-      });
-      return runtime.createMemory(factMemory, "facts", true);
-    })
-  );
-  for (const relationship of reflection.relationships) {
-    let sourceId;
-    let targetId;
-    try {
-      sourceId = resolveEntity(relationship.sourceEntityId, entities);
-      targetId = resolveEntity(relationship.targetEntityId, entities);
-    } catch (error) {
-      console.warn("Failed to resolve relationship entities:", error);
-      console.warn("relationship:\n", relationship);
-      continue;
-    }
-    const existingRelationship = existingRelationships.find((r) => {
-      return r.sourceEntityId === sourceId && r.targetEntityId === targetId;
+  try {
+    const reflection = await runtime.useModel(ModelType.OBJECT_SMALL, {
+      prompt
+      // Remove schema validation to avoid zod issues
     });
-    if (existingRelationship) {
-      const updatedMetadata = {
-        ...existingRelationship.metadata,
-        interactions: (existingRelationship.metadata?.interactions || 0) + 1
-      };
-      const updatedTags = Array.from(
-        /* @__PURE__ */ new Set([...existingRelationship.tags || [], ...relationship.tags])
-      );
-      await runtime.updateRelationship({
-        ...existingRelationship,
-        tags: updatedTags,
-        metadata: updatedMetadata
-      });
-    } else {
-      await runtime.createRelationship({
-        sourceEntityId: sourceId,
-        targetEntityId: targetId,
-        tags: relationship.tags,
-        metadata: {
-          interactions: 1,
-          ...relationship.metadata
-        }
+    if (!reflection) {
+      logger_default.warn("Getting reflection failed - empty response", prompt);
+      return;
+    }
+    if (!reflection.facts || !Array.isArray(reflection.facts)) {
+      logger_default.warn("Getting reflection failed - invalid facts structure", reflection);
+      return;
+    }
+    if (!reflection.relationships || !Array.isArray(reflection.relationships)) {
+      logger_default.warn("Getting reflection failed - invalid relationships structure", reflection);
+      return;
+    }
+    const newFacts = reflection.facts.filter(
+      (fact) => fact && typeof fact === "object" && !fact.already_known && !fact.in_bio && fact.claim && typeof fact.claim === "string" && fact.claim.trim() !== ""
+    ) || [];
+    await Promise.all(
+      newFacts.map(async (fact) => {
+        const factMemory = await runtime.addEmbeddingToMemory({
+          entityId: agentId,
+          agentId,
+          content: { text: fact.claim },
+          roomId,
+          createdAt: Date.now()
+        });
+        return runtime.createMemory(factMemory, "facts", true);
+      })
+    );
+    for (const relationship of reflection.relationships) {
+      let sourceId;
+      let targetId;
+      try {
+        sourceId = resolveEntity(relationship.sourceEntityId, entities);
+        targetId = resolveEntity(relationship.targetEntityId, entities);
+      } catch (error) {
+        console.warn("Failed to resolve relationship entities:", error);
+        console.warn("relationship:\n", relationship);
+        continue;
+      }
+      const existingRelationship = existingRelationships.find((r) => {
+        return r.sourceEntityId === sourceId && r.targetEntityId === targetId;
       });
+      if (existingRelationship) {
+        const updatedMetadata = {
+          ...existingRelationship.metadata,
+          interactions: (existingRelationship.metadata?.interactions || 0) + 1
+        };
+        const updatedTags = Array.from(
+          /* @__PURE__ */ new Set([...existingRelationship.tags || [], ...relationship.tags])
+        );
+        await runtime.updateRelationship({
+          ...existingRelationship,
+          tags: updatedTags,
+          metadata: updatedMetadata
+        });
+      } else {
+        await runtime.createRelationship({
+          sourceEntityId: sourceId,
+          targetEntityId: targetId,
+          tags: relationship.tags,
+          metadata: {
+            interactions: 1,
+            ...relationship.metadata
+          }
+        });
+      }
     }
+    await runtime.setCache(`${message.roomId}-reflection-last-processed`, message.id);
+    return reflection;
+  } catch (error) {
+    logger_default.error("Error in reflection handler:", error);
+    return;
   }
-  await runtime.setCache(
-    `${message.roomId}-reflection-last-processed`,
-    message.id
-  );
-  return reflection;
 }
 var reflectionEvaluator = {
   name: "REFLECTION",
-  similes: [
-    "REFLECT",
-    "SELF_REFLECT",
-    "EVALUATE_INTERACTION",
-    "ASSESS_SITUATION"
-  ],
+  similes: ["REFLECT", "SELF_REFLECT", "EVALUATE_INTERACTION", "ASSESS_SITUATION"],
   validate: async (runtime, message) => {
-    const lastMessageId = await runtime.getCache(`${message.roomId}-reflection-last-processed`);
+    const lastMessageId = await runtime.getCache(
+      `${message.roomId}-reflection-last-processed`
+    );
     const messages = await runtime.getMemories({
       tableName: "messages",
       roomId: message.roomId,
       count: runtime.getConversationLength()
     });
     if (lastMessageId) {
-      const lastMessageIndex = messages.findIndex(
-        (msg) => msg.id === lastMessageId
-      );
+      const lastMessageIndex = messages.findIndex((msg) => msg.id === lastMessageId);
       if (lastMessageIndex !== -1) {
         messages.splice(0, lastMessageIndex + 1);
       }
@@ -4771,9 +4636,7 @@ var actionsProvider = {
     });
     const resolvedActions = await Promise.all(actionPromises);
     const actionsData = resolvedActions.filter(Boolean);
-    const actionNames = `Possible response actions: ${formatActionNames(
-      actionsData
-    )}`;
+    const actionNames = `Possible response actions: ${formatActionNames(actionsData)}`;
     const actions = actionsData.length > 0 ? addHeader("# Available Actions", formatActions(actionsData)) : "";
     const actionExamples = actionsData.length > 0 ? addHeader("# Action Examples", composeActionExamples(actionsData, 10)) : "";
     const data = {
@@ -4850,9 +4713,9 @@ var anxietyProvider = {
       "Keep voice channel interactions brief and purposeful."
     ];
     let anxietyExamples = [];
-    if (channelType === "GROUP" /* GROUP */) {
+    if (channelType === "group" /* GROUP */) {
       anxietyExamples = groupAnxietyExamples;
-    } else if (channelType === "DM" /* DM */) {
+    } else if (channelType === "dm" /* DM */) {
       anxietyExamples = dmAnxietyExamples;
     } else if (channelType === "VOICE_GROUP" /* VOICE_GROUP */ || channelType === "VOICE_DM" /* VOICE_DM */) {
       anxietyExamples = voiceAnxietyExamples;
@@ -5003,10 +4866,7 @@ var characterProvider = {
       const messageString = `${post}`;
       return messageString;
     }).slice(0, 50).join("\n");
-    const characterPostExamples = formattedCharacterPostExamples && formattedCharacterPostExamples.replaceAll("\n", "").length > 0 ? addHeader(
-      `# Example Posts for ${character.name}`,
-      formattedCharacterPostExamples
-    ) : "";
+    const characterPostExamples = formattedCharacterPostExamples && formattedCharacterPostExamples.replaceAll("\n", "").length > 0 ? addHeader(`# Example Posts for ${character.name}`, formattedCharacterPostExamples) : "";
     const formattedCharacterMessageExamples = !character.messageExamples ? "" : character.messageExamples.sort(() => 0.5 - Math.random()).slice(0, 5).map((example) => {
       const exampleNames = Array.from(
         { length: 5 },
@@ -5069,16 +4929,7 @@ var characterProvider = {
       examples,
       system
     };
-    const text = [
-      bio,
-      adjective,
-      topic,
-      topics,
-      adjective,
-      directions,
-      examples,
-      system
-    ].filter(Boolean).join("\n\n");
+    const text = [bio, adjective, topic, topics, adjective, directions, examples, system].filter(Boolean).join("\n\n");
     return {
       values,
       data,
@@ -5107,9 +4958,7 @@ var choiceProvider = {
           text: "No pending choices for the moment."
         };
       }
-      const tasksWithOptions = pendingTasks.filter(
-        (task) => task.metadata?.options
-      );
+      const tasksWithOptions = pendingTasks.filter((task) => task.metadata?.options);
       if (tasksWithOptions.length === 0) {
         return {
           data: {
@@ -5180,9 +5029,7 @@ var entitiesProvider = {
     const { roomId, entityId } = message;
     const entitiesData = await getEntityDetails({ runtime, roomId });
     const formattedEntities = formatEntities({ entities: entitiesData ?? [] });
-    const senderName = entitiesData?.find(
-      (entity) => entity.id === entityId
-    )?.names[0];
+    const senderName = entitiesData?.find((entity) => entity.id === entityId)?.names[0];
     const entities = formattedEntities && formattedEntities.length > 0 ? addHeader("# People in the Room", formattedEntities) : "";
     const data = {
       entitiesData,
@@ -5238,32 +5085,25 @@ ${formattedOutcome}`;
   }).join("\n\n");
 }
 function formatEvaluators(evaluators) {
-  return evaluators.map(
-    (evaluator) => `'${evaluator.name}: ${evaluator.description}'`
-  ).join(",\n");
+  return evaluators.map((evaluator) => `'${evaluator.name}: ${evaluator.description}'`).join(",\n");
 }
 var evaluatorsProvider = {
   name: "EVALUATORS",
   description: "Evaluators that can be used to evaluate the conversation after responding",
   private: true,
   get: async (runtime, message, state) => {
-    const evaluatorPromises = runtime.evaluators.map(
-      async (evaluator) => {
-        const result = await evaluator.validate(runtime, message, state);
-        if (result) {
-          return evaluator;
-        }
-        return null;
+    const evaluatorPromises = runtime.evaluators.map(async (evaluator) => {
+      const result = await evaluator.validate(runtime, message, state);
+      if (result) {
+        return evaluator;
       }
-    );
+      return null;
+    });
     const resolvedEvaluators = await Promise.all(evaluatorPromises);
     const evaluatorsData = resolvedEvaluators.filter(Boolean);
     const evaluators = evaluatorsData.length > 0 ? addHeader("# Available Evaluators", formatEvaluators(evaluatorsData)) : "";
     const evaluatorNames = evaluatorsData.length > 0 ? formatEvaluatorNames(evaluatorsData) : "";
-    const evaluatorExamples = evaluatorsData.length > 0 ? addHeader(
-      "# Evaluator Examples",
-      formatEvaluatorExamples(evaluatorsData)
-    ) : "";
+    const evaluatorExamples = evaluatorsData.length > 0 ? addHeader("# Evaluator Examples", formatEvaluatorExamples(evaluatorsData)) : "";
     const values = {
       evaluatorsData,
       evaluators,
@@ -5368,19 +5208,14 @@ var providersProvider = {
   name: "PROVIDERS",
   description: "List of all data providers the agent can use to get additional information",
   get: async (runtime, _message) => {
-    const dynamicProviders = runtime.providers.filter(
-      (provider) => provider.dynamic === true
-    );
+    const dynamicProviders = runtime.providers.filter((provider) => provider.dynamic === true);
     const providerDescriptions = dynamicProviders.map((provider) => {
       return `- **${provider.name}**: ${provider.description || "No description available"}`;
     });
     const headerText = "# Providers\n\nThese providers are available for the agent to select and use:";
     if (providerDescriptions.length === 0) {
       return {
-        text: addHeader(
-          headerText,
-          "No dynamic providers are currently available."
-        )
+        text: addHeader(headerText, "No dynamic providers are currently available.")
       };
     }
     const providersText = providerDescriptions.join("\n");
@@ -5424,12 +5259,7 @@ var recentMessagesProvider = {
         count: conversationLength,
         unique: false
       }),
-      message.entityId !== runtime.agentId ? getRecentInteractions2(
-        runtime,
-        message.entityId,
-        runtime.agentId,
-        roomId
-      ) : Promise.resolve([])
+      message.entityId !== runtime.agentId ? getRecentInteractions2(runtime, message.entityId, runtime.agentId, roomId) : Promise.resolve([])
     ]);
     const isPostFormat = room?.type === "FEED" /* FEED */ || room?.type === "THREAD" /* THREAD */;
     const [formattedRecentMessages, formattedRecentPosts] = await Promise.all([
@@ -5460,14 +5290,10 @@ var recentMessagesProvider = {
           entitiesDataIdSet.add(entity.id);
         }
       });
-      const remainingEntityIds = uniqueEntityIds.filter(
-        (id) => !entitiesDataIdSet.has(id)
-      );
+      const remainingEntityIds = uniqueEntityIds.filter((id) => !entitiesDataIdSet.has(id));
       if (remainingEntityIds.length > 0) {
         const entities = await Promise.all(
-          remainingEntityIds.map(
-            (entityId) => runtime.getEntityById(entityId)
-          )
+          remainingEntityIds.map((entityId) => runtime.getEntityById(entityId))
         );
         entities.forEach((entity, index) => {
           if (entity) {
@@ -5530,18 +5356,14 @@ var recentMessagesProvider = {
 
 // src/providers/relationships.ts
 async function formatRelationships(runtime, relationships) {
-  const sortedRelationships = relationships.filter((rel) => rel.metadata?.interactions).sort(
-    (a, b) => (b.metadata?.interactions || 0) - (a.metadata?.interactions || 0)
-  ).slice(0, 30);
+  const sortedRelationships = relationships.filter((rel) => rel.metadata?.interactions).sort((a, b) => (b.metadata?.interactions || 0) - (a.metadata?.interactions || 0)).slice(0, 30);
   if (sortedRelationships.length === 0) {
     return "";
   }
   const uniqueEntityIds = Array.from(
     new Set(sortedRelationships.map((rel) => rel.targetEntityId))
   );
-  const entities = await Promise.all(
-    uniqueEntityIds.map((id) => runtime.getEntityById(id))
-  );
+  const entities = await Promise.all(uniqueEntityIds.map((id) => runtime.getEntityById(id)));
   const entityMap = /* @__PURE__ */ new Map();
   entities.forEach((entity, index) => {
     if (entity) {
@@ -5588,10 +5410,7 @@ var relationshipsProvider = {
         text: "No relationships found."
       };
     }
-    const formattedRelationships = await formatRelationships(
-      runtime,
-      relationships
-    );
+    const formattedRelationships = await formatRelationships(runtime, relationships);
     if (!formattedRelationships) {
       return {
         data: {
@@ -5625,7 +5444,7 @@ var roleProvider = {
     if (!room) {
       throw new Error("No room found");
     }
-    if (room.type !== "GROUP" /* GROUP */) {
+    if (room.type !== "group" /* GROUP */) {
       return {
         data: {
           roles: []
@@ -5767,9 +5586,7 @@ function getSalt(runtime) {
     logger.warn("AgentId is missing when generating encryption salt");
   }
   const salt = secretSalt + (agentId || "");
-  logger.debug(
-    `Generated salt with length: ${salt.length} (truncated for security)`
-  );
+  logger.debug(`Generated salt with length: ${salt.length} (truncated for security)`);
   return salt;
 }
 function saltSettingValue(setting, salt) {
@@ -5781,9 +5598,7 @@ function saltSettingValue(setting, salt) {
         try {
           const possibleIv = Buffer.from(parts[0], "hex");
           if (possibleIv.length === 16) {
-            logger.debug(
-              "Value appears to be already encrypted, skipping re-encryption"
-            );
+            logger.debug("Value appears to be already encrypted, skipping re-encryption");
             return settingCopy;
           }
         } catch (e) {
@@ -5808,9 +5623,7 @@ function unsaltSettingValue(setting, salt) {
     try {
       const parts = setting.value.split(":");
       if (parts.length !== 2) {
-        logger.warn(
-          `Invalid encrypted value format for setting - expected 'iv:encrypted'`
-        );
+        logger.warn(`Invalid encrypted value format for setting - expected 'iv:encrypted'`);
         return settingCopy;
       }
       const iv = Buffer.from(parts[0], "hex");
@@ -5880,19 +5693,17 @@ async function getWorldSettings2(runtime, serverId) {
     return null;
   }
 }
-async function initializeOnboarding(runtime, world, config2) {
+async function initializeOnboarding(runtime, world, config) {
   try {
     if (world.metadata?.settings) {
-      logger.info(
-        `Onboarding state already exists for server ${world.serverId}`
-      );
+      logger.info(`Onboarding state already exists for server ${world.serverId}`);
       const saltedSettings = world.metadata.settings;
       const salt = getSalt(runtime);
       return unsaltWorldSettings(saltedSettings, salt);
     }
     const worldSettings = {};
-    if (config2.settings) {
-      for (const [key, configSetting] of Object.entries(config2.settings)) {
+    if (config.settings) {
+      for (const [key, configSetting] of Object.entries(config.settings)) {
         worldSettings[key] = createSettingFromConfig(configSetting);
       }
     }
@@ -5945,9 +5756,7 @@ ${runtime.character.name} still needs to configure ${requiredUnconfigured} requi
 ${formattedSettings.filter((s) => s.required && !s.configured).map((s) => `${s.key}: ${s.value}
 (${s.name}) ${s.usageDescription}`).join("\n\n")}
 
-Valid settings keys: ${Object.keys(
-          worldSettings
-        ).join(
+Valid settings keys: ${Object.keys(worldSettings).join(
           ", "
         )}
 
@@ -5962,11 +5771,9 @@ Value: ${s.value}`).join("\n")}`;
 
 ${requiredUnconfigured > 0 ? `IMPORTANT!: ${requiredUnconfigured} required settings still need configuration. ${runtime.character.name} should get onboarded with the OWNER as soon as possible.
 
-` : "All required settings are configured.\n\n"}${formattedSettings.map(
-      (s) => `### ${s.name}
+` : "All required settings are configured.\n\n"}${formattedSettings.map((s) => `### ${s.name}
 **Value:** ${s.value}
-**Description:** ${s.description}`
-    ).join("\n\n")}`;
+**Description:** ${s.description}`).join("\n\n")}`;
   } catch (error) {
     logger.error(`Error generating status message: ${error}`);
     return "Error generating configuration status.";
@@ -5997,7 +5804,7 @@ var settingsProvider = {
         };
       }
       const type = room.type;
-      const isOnboarding = type === "DM" /* DM */;
+      const isOnboarding = type === "dm" /* DM */;
       let world;
       let serverId;
       let worldSettings;
@@ -6017,8 +5824,6 @@ var settingsProvider = {
       } else {
         try {
           world = await runtime.getWorld(room.worldId);
-          console.log("*** world", world);
-          console.log("*** room", room);
           serverId = world.serverId;
           if (serverId) {
             worldSettings = await getWorldSettings2(runtime, serverId);
@@ -6072,12 +5877,7 @@ var settingsProvider = {
           text: "Configuration has not been completed yet."
         };
       }
-      const output = generateStatusMessage(
-        runtime,
-        worldSettings,
-        isOnboarding,
-        state
-      );
+      const output = generateStatusMessage(runtime, worldSettings, isOnboarding, state);
       return {
         data: {
           settings: worldSettings
@@ -6112,9 +5912,7 @@ var timeProvider = {
       dateStyle: "full",
       timeStyle: "long"
     };
-    const humanReadable = new Intl.DateTimeFormat("en-US", options2).format(
-      currentDate
-    );
+    const humanReadable = new Intl.DateTimeFormat("en-US", options2).format(currentDate);
     return {
       data: {
         time: currentDate
@@ -6138,16 +5936,14 @@ var ScenarioService = class _ScenarioService extends Service {
   constructor(runtime) {
     super(runtime);
     this.runtime = runtime;
-    this.capabilityDescription = "The agent is currently in a scenario testing environment. It can create rooms, send messages, and talk to other agents in a live interactive testing environment.";
-    this.messageHandlers = /* @__PURE__ */ new Map();
-    this.worlds = /* @__PURE__ */ new Map();
-    this.activeActions = /* @__PURE__ */ new Map();
-    this.activeEvaluators = /* @__PURE__ */ new Map();
     this.setupEventListeners();
   }
-  static {
-    this.serviceType = "scenario";
-  }
+  static serviceType = "scenario";
+  capabilityDescription = "The agent is currently in a scenario testing environment. It can create rooms, send messages, and talk to other agents in a live interactive testing environment.";
+  messageHandlers = /* @__PURE__ */ new Map();
+  worlds = /* @__PURE__ */ new Map();
+  activeActions = /* @__PURE__ */ new Map();
+  activeEvaluators = /* @__PURE__ */ new Map();
   setupEventListeners() {
     this.runtime.registerEvent("ACTION_STARTED" /* ACTION_STARTED */, async (data) => {
       this.activeActions.set(data.actionId, {
@@ -6176,15 +5972,18 @@ var ScenarioService = class _ScenarioService extends Service {
       logger_default.debug("Evaluator started", data);
       return Promise.resolve();
     });
-    this.runtime.registerEvent("EVALUATOR_COMPLETED" /* EVALUATOR_COMPLETED */, async (data) => {
-      const evaluator = this.activeEvaluators.get(data.evaluatorId);
-      if (evaluator) {
-        evaluator.completed = true;
-        evaluator.error = data.error;
+    this.runtime.registerEvent(
+      "EVALUATOR_COMPLETED" /* EVALUATOR_COMPLETED */,
+      async (data) => {
+        const evaluator = this.activeEvaluators.get(data.evaluatorId);
+        if (evaluator) {
+          evaluator.completed = true;
+          evaluator.error = data.error;
+        }
+        logger_default.debug("Evaluator completed", data);
+        return Promise.resolve();
       }
-      logger_default.debug("Evaluator completed", data);
-      return Promise.resolve();
-    });
+    );
   }
   /**
    * Start the scenario service with the given runtime.
@@ -6260,7 +6059,7 @@ var ScenarioService = class _ScenarioService extends Service {
       id: roomId,
       name,
       source: "scenario",
-      type: "GROUP" /* GROUP */,
+      type: "group" /* GROUP */,
       channelId: roomId,
       serverId: worldId
     });
@@ -6304,7 +6103,7 @@ var ScenarioService = class _ScenarioService extends Service {
         source: "scenario",
         name: sender.character.name,
         userName: sender.character.name,
-        channelType: "GROUP" /* GROUP */
+        channelType: "group" /* GROUP */
       }
     };
     const participants = await this.runtime.getParticipantsForRoom(roomId);
@@ -6315,7 +6114,7 @@ var ScenarioService = class _ScenarioService extends Service {
         roomId,
         entityId: participantId,
         source: "scenario",
-        type: "GROUP" /* GROUP */
+        type: "group" /* GROUP */
       });
     }
   }
@@ -6362,16 +6161,11 @@ var ScenarioService = class _ScenarioService extends Service {
 
 // src/services/task.ts
 var TaskService = class _TaskService extends Service {
-  constructor() {
-    super(...arguments);
-    this.timer = null;
-    this.TICK_INTERVAL = 1e3;
-    this.capabilityDescription = "The agent is able to schedule and execute tasks";
-  }
-  static {
-    // Check every second
-    this.serviceType = ServiceType.TASK;
-  }
+  timer = null;
+  TICK_INTERVAL = 1e3;
+  // Check every second
+  static serviceType = ServiceType.TASK;
+  capabilityDescription = "The agent is able to schedule and execute tasks";
   /**
    * Start the TaskService with the given runtime.
    * @param {IAgentRuntime} runtime - The runtime for the TaskService.
@@ -6465,11 +6259,7 @@ var TaskService = class _TaskService extends Service {
       }
       if (worker.validate) {
         try {
-          const isValid = await worker.validate(
-            this.runtime,
-            {},
-            {}
-          );
+          const isValid = await worker.validate(this.runtime, {}, {});
           if (!isValid) {
             continue;
           }
@@ -6493,9 +6283,6 @@ var TaskService = class _TaskService extends Service {
         tags: ["queue"]
       });
       const tasks = await this.validateTasks(allTasks);
-      if (tasks.length > 0) {
-        logger_default.debug(`Found ${tasks.length} queued tasks`);
-      }
       const now = Date.now();
       for (const task of tasks) {
         let taskStartTime;
@@ -6550,14 +6337,10 @@ var TaskService = class _TaskService extends Service {
             updatedAt: Date.now()
           }
         });
-        logger_default.debug(
-          `Updated repeating task ${task.name} (${task.id}) with new timestamp`
-        );
+        logger_default.debug(`Updated repeating task ${task.name} (${task.id}) with new timestamp`);
       } else {
         await this.runtime.deleteTask(task.id);
-        logger_default.debug(
-          `Deleted non-repeating task ${task.name} (${task.id}) after execution`
-        );
+        logger_default.debug(`Deleted non-repeating task ${task.name} (${task.id}) after execution`);
       }
     } catch (error) {
       logger_default.error(`Error executing task ${task.id}:`, error);
@@ -6593,7 +6376,6 @@ var messageReceivedHandler = async ({
   message,
   callback
 }) => {
-  console.log("*** messageReceivedHandler for " + runtime.character.name + " ***", message);
   const responseId = v4();
   if (!latestResponseIds.has(runtime.agentId)) {
     latestResponseIds.set(runtime.agentId, /* @__PURE__ */ new Map());
@@ -6643,7 +6425,7 @@ var messageReceivedHandler = async ({
       ]);
       const agentUserState = await runtime.getParticipantUserState(message.roomId, runtime.agentId);
       if (agentUserState === "MUTED" && !message.content.text?.toLowerCase().includes(runtime.character.name.toLowerCase())) {
-        console.log("Ignoring muted room");
+        logger.debug("Ignoring muted room");
         return;
       }
       let state = await runtime.composeState(message, [
@@ -6658,16 +6440,15 @@ var messageReceivedHandler = async ({
         template: runtime.character.templates?.shouldRespondTemplate || shouldRespondTemplate
       });
       logger.debug(
-        `*** Should Respond Prompt for ${runtime.character.name} ***`,
+        `*** Should Respond Prompt for ${runtime.character.name} ***
+`,
         shouldRespondPrompt
       );
       const response = await runtime.useModel(ModelType.TEXT_SMALL, {
         prompt: shouldRespondPrompt
       });
-      logger.debug(
-        `*** Should Respond Response for ${runtime.character.name} ***`,
-        response
-      );
+      logger.debug(`*** Should Respond Response for ${runtime.character.name} ***
+`, response);
       const responseObject = parseJSONObjectFromText(response);
       const providers = responseObject.providers;
       const shouldRespond = responseObject?.action && responseObject.action === "RESPOND";
@@ -6689,7 +6470,6 @@ var messageReceivedHandler = async ({
           retries++;
           if ((!responseContent?.thought || !responseContent?.plan) && !responseContent?.actions) {
             logger.warn("*** Missing required fields, retrying... ***");
-            console.log("*** responseContent is", responseContent);
           }
         }
         const currentResponseId = agentResponses.get(message.roomId);
@@ -6712,18 +6492,21 @@ var messageReceivedHandler = async ({
               createdAt: Date.now()
             }
           ];
-          await runtime.createMemory({
-            entityId: runtime.agentId,
-            agentId: runtime.agentId,
-            content: {
-              thought: responseContent.thought,
-              plan: responseContent.plan,
-              actions: responseContent.actions,
-              providers: responseContent.providers
+          await runtime.createMemory(
+            {
+              entityId: runtime.agentId,
+              agentId: runtime.agentId,
+              content: {
+                thought: responseContent.thought,
+                plan: responseContent.plan,
+                actions: responseContent.actions,
+                providers: responseContent.providers
+              },
+              roomId: message.roomId,
+              createdAt: Date.now()
             },
-            roomId: message.roomId,
-            createdAt: Date.now()
-          }, "messages");
+            "messages"
+          );
         }
         agentResponses.delete(message.roomId);
         if (agentResponses.size === 0) {
@@ -6731,13 +6514,7 @@ var messageReceivedHandler = async ({
         }
         await runtime.processActions(message, responseMessages, state, callback);
       }
-      await runtime.evaluate(
-        message,
-        state,
-        shouldRespond,
-        callback,
-        responseMessages
-      );
+      await runtime.evaluate(message, state, shouldRespond, callback, responseMessages);
       await runtime.emitEvent("RUN_ENDED" /* RUN_ENDED */, {
         runtime,
         runId,
@@ -6839,7 +6616,6 @@ var postGeneratedHandler = async ({
     return cleanedText2;
   }
   const cleanedText = cleanupTweetText(jsonResponse.post);
-  console.log("creating memory");
   const responseMessages = [
     {
       id: v4(),
@@ -6858,8 +6634,6 @@ var postGeneratedHandler = async ({
     }
   ];
   for (const message2 of responseMessages) {
-    console.log("message is", message2);
-    console.log("message.content is", message2.content);
     await callback(message2.content);
   }
 };
@@ -6886,23 +6660,12 @@ var syncSingleUser = async (entityId, runtime, serverId, channelId, type, source
     });
     logger.success(`Successfully synced user: ${entity.id}`);
   } catch (error) {
-    logger.error(
-      `Error syncing user: ${error instanceof Error ? error.message : String(error)}`
-    );
+    logger.error(`Error syncing user: ${error instanceof Error ? error.message : String(error)}`);
   }
 };
-var handleServerSync = async ({
-  runtime,
-  world,
-  rooms,
-  entities,
-  source
-}) => {
-  logger.info(`Handling server sync event for server: ${world.name}`);
+var handleServerSync = async ({ runtime, world, rooms, entities, source }) => {
+  logger.debug(`Handling server sync event for server: ${world.name}`);
   try {
-    console.log("world.id", world.id);
-    console.log("agentId", runtime.agentId);
-    console.log("runtime.serverId", runtime.agentId);
     await runtime.ensureWorldExists({
       id: world.id,
       name: world.name,
@@ -6945,9 +6708,7 @@ var handleServerSync = async ({
                 worldId: world.id
               });
             } catch (err) {
-              logger.warn(
-                `Failed to sync user ${entity.metadata.username}: ${err}`
-              );
+              logger.warn(`Failed to sync user ${entity.metadata.username}: ${err}`);
             }
           })
         );
@@ -6956,9 +6717,7 @@ var handleServerSync = async ({
         }
       }
     }
-    logger.success(
-      `Successfully synced standardized world structure for ${world.name}`
-    );
+    logger.debug(`Successfully synced standardized world structure for ${world.name}`);
   } catch (error) {
     logger.error(
       `Error processing standardized server data: ${error instanceof Error ? error.message : String(error)}`
@@ -7107,8 +6866,8 @@ var bootstrapPlugin = {
 
 // src/uuid.ts
 import { sha1 } from "js-sha1";
-import { z as z3 } from "zod";
-var uuidSchema = z3.string().uuid();
+import { z as z2 } from "zod";
+var uuidSchema = z2.string().uuid();
 function validateUuid(value) {
   const result = uuidSchema.safeParse(value);
   return result.success ? result.data : null;
@@ -7147,9 +6906,69 @@ function stringToUuid(target) {
 }
 
 // src/runtime.ts
+import fs2 from "node:fs";
+import path2 from "node:path";
+var environmentSettings = {};
+function loadEnvConfig() {
+  if (typeof window !== "undefined" && typeof window.document !== "undefined") {
+    return environmentSettings;
+  }
+  let dotenv = null;
+  try {
+    if (typeof process !== "undefined" && process.versions && process.versions.node) {
+      dotenv = __require("dotenv");
+    }
+  } catch (err) {
+    logger_default.debug("dotenv module not available");
+  }
+  function findNearestEnvFile(startDir = process.cwd()) {
+    let currentDir = startDir;
+    while (currentDir !== path2.parse(currentDir).root) {
+      const envPath2 = path2.join(currentDir, ".env");
+      if (fs2.existsSync(envPath2)) {
+        return envPath2;
+      }
+      currentDir = path2.dirname(currentDir);
+    }
+    const rootEnvPath = path2.join(path2.parse(currentDir).root, ".env");
+    return fs2.existsSync(rootEnvPath) ? rootEnvPath : null;
+  }
+  const envPath = findNearestEnvFile();
+  try {
+    if (dotenv) {
+      const result = dotenv.config(envPath ? { path: envPath } : {});
+      if (!result.error && envPath) {
+        logger_default.log(`Loaded .env file from: ${envPath}`);
+      }
+    }
+  } catch (err) {
+    logger_default.warn("Failed to load .env file:", err);
+  }
+  const env = typeof process !== "undefined" ? process.env : import.meta.env;
+  const namespacedSettings = parseNamespacedSettings(env);
+  if (typeof process !== "undefined") {
+    Object.entries(namespacedSettings).forEach(([namespace, settings]) => {
+      process.env[`__namespaced_${namespace}`] = JSON.stringify(settings);
+    });
+  }
+  return env;
+}
+function parseNamespacedSettings(env) {
+  const namespaced = {};
+  for (const [key, value] of Object.entries(env)) {
+    if (!value) continue;
+    const [namespace, ...rest] = key.split(".");
+    if (!namespace || rest.length === 0) continue;
+    const settingKey = rest.join(".");
+    namespaced[namespace] = namespaced[namespace] || {};
+    namespaced[namespace][settingKey] = value;
+  }
+  return namespaced;
+}
 var Semaphore = class {
+  permits;
+  waiting = [];
   constructor(count) {
-    this.waiting = [];
     this.permits = count;
   }
   async acquire() {
@@ -7171,44 +6990,54 @@ var Semaphore = class {
   }
 };
 var AgentRuntime = class {
+  #conversationLength = 32;
+  agentId;
+  character;
+  adapter;
+  actions = [];
+  evaluators = [];
+  providers = [];
+  plugins = [];
+  events = /* @__PURE__ */ new Map();
+  stateCache = /* @__PURE__ */ new Map();
+  fetch = fetch;
+  services = /* @__PURE__ */ new Map();
+  models = /* @__PURE__ */ new Map();
+  routes = [];
+  taskWorkers = /* @__PURE__ */ new Map();
+  // Event emitter methods
+  eventHandlers = /* @__PURE__ */ new Map();
+  runtimeLogger;
+  knowledgeProcessingSemaphore = new Semaphore(10);
+  settings;
   constructor(opts) {
-    this.#conversationLength = 32;
-    this.actions = [];
-    this.evaluators = [];
-    this.providers = [];
-    this.plugins = [];
-    this.events = /* @__PURE__ */ new Map();
-    this.stateCache = /* @__PURE__ */ new Map();
-    this.fetch = fetch;
-    this.services = /* @__PURE__ */ new Map();
-    this.models = /* @__PURE__ */ new Map();
-    this.routes = [];
-    this.taskWorkers = /* @__PURE__ */ new Map();
-    // Event emitter methods
-    this.eventHandlers = /* @__PURE__ */ new Map();
-    this.knowledgeProcessingSemaphore = new Semaphore(10);
     this.agentId = opts.character?.id ?? opts?.agentId ?? stringToUuid(opts.character?.name ?? uuidv43());
     this.character = opts.character;
+    const logLevel = process.env.LOG_LEVEL || "info";
     this.runtimeLogger = logger_default.child({
       agentName: this.character?.name,
-      agentId: this.agentId
+      agentId: this.agentId,
+      level: logLevel === "debug" ? "debug" : "error"
+      // Show only errors unless debug mode is enabled
     });
-    this.runtimeLogger.debug(
-      `[AgentRuntime] Process working directory: ${process.cwd()}`
-    );
+    this.runtimeLogger.debug(`[AgentRuntime] Process working directory: ${process.cwd()}`);
     this.#conversationLength = opts.conversationLength ?? this.#conversationLength;
     if (opts.adapter) {
       this.registerDatabaseAdapter(opts.adapter);
     }
-    this.runtimeLogger.success(`Agent ID: ${this.agentId}`);
     this.fetch = opts.fetch ?? this.fetch;
+    if (typeof window !== "undefined" && typeof window.document !== "undefined") {
+      this.settings = environmentSettings;
+    } else {
+      this.settings = loadEnvConfig();
+    }
     const plugins = opts?.plugins ?? [];
     if (!opts?.ignoreBootstrap) {
       plugins.push(bootstrapPlugin);
     }
     this.plugins = plugins;
+    this.runtimeLogger.debug(`Success: Agent ID: ${this.agentId}`);
   }
-  #conversationLength;
   /**
    * Registers a plugin with the runtime and initializes its components
    * @param plugin The plugin to register
@@ -7220,22 +7049,16 @@ var AgentRuntime = class {
     }
     if (!this.plugins.some((p) => p.name === plugin.name)) {
       this.plugins.push(plugin);
-      this.runtimeLogger.success(
-        `Plugin ${plugin.name} registered successfully`
-      );
+      this.runtimeLogger.debug(`Success: Plugin ${plugin.name} registered successfully`);
     }
     if (plugin.init) {
       try {
         await plugin.init(plugin.config || {}, this);
-        this.runtimeLogger.success(
-          `Plugin ${plugin.name} initialized successfully`
-        );
+        this.runtimeLogger.debug(`Success: Plugin ${plugin.name} initialized successfully`);
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         if (errorMessage.includes("API key") || errorMessage.includes("environment variables") || errorMessage.includes("Invalid plugin configuration")) {
-          console.warn(
-            `Plugin ${plugin.name} requires configuration. ${errorMessage}`
-          );
+          console.warn(`Plugin ${plugin.name} requires configuration. ${errorMessage}`);
           console.warn(
             "Please check your environment variables and ensure all required API keys are set."
           );
@@ -7246,9 +7069,7 @@ var AgentRuntime = class {
       }
     }
     if (plugin.adapter) {
-      this.runtimeLogger.debug(
-        `Registering database adapter for plugin ${plugin.name}`
-      );
+      this.runtimeLogger.debug(`Registering database adapter for plugin ${plugin.name}`);
       this.registerDatabaseAdapter(plugin.adapter);
     }
     if (plugin.actions) {
@@ -7268,10 +7089,7 @@ var AgentRuntime = class {
     }
     if (plugin.models) {
       for (const [modelType, handler2] of Object.entries(plugin.models)) {
-        this.registerModel(
-          modelType,
-          handler2
-        );
+        this.registerModel(modelType, handler2);
       }
     }
     if (plugin.routes) {
@@ -7287,22 +7105,16 @@ var AgentRuntime = class {
       }
     }
     if (plugin.services) {
-      await Promise.all(
-        plugin.services.map((service) => this.registerService(service))
-      );
+      await Promise.all(plugin.services.map((service) => this.registerService(service)));
     }
   }
   getAllServices() {
     return this.services;
   }
   async stop() {
-    this.runtimeLogger.debug(
-      `runtime::stop - character ${this.character.name}`
-    );
+    this.runtimeLogger.debug(`runtime::stop - character ${this.character.name}`);
     for (const [serviceName, service] of this.services) {
-      this.runtimeLogger.log(
-        `runtime::stop - requesting service stop for ${serviceName}`
-      );
+      this.runtimeLogger.debug(`runtime::stop - requesting service stop for ${serviceName}`);
       await service.stop();
     }
   }
@@ -7310,9 +7122,7 @@ var AgentRuntime = class {
     const registeredPluginNames = /* @__PURE__ */ new Set();
     const pluginRegistrationPromises = [];
     if (this.character.plugins) {
-      const characterPlugins = await handlePluginImporting(
-        this.character.plugins
-      );
+      const characterPlugins = await handlePluginImporting(this.character.plugins);
       for (const plugin of characterPlugins) {
         if (plugin && !registeredPluginNames.has(plugin.name)) {
           registeredPluginNames.add(plugin.name);
@@ -7328,9 +7138,7 @@ var AgentRuntime = class {
     }
     await this.adapter.init();
     try {
-      const agentExists = await this.adapter.ensureAgentExists(
-        this.character
-      );
+      const agentExists = await this.adapter.ensureAgentExists(this.character);
       const agent = await this.adapter.getAgent(this.agentId);
       if (!agent) {
         throw new Error(
@@ -7339,19 +7147,17 @@ var AgentRuntime = class {
       }
       const agentEntity = await this.adapter.getEntityById(this.agentId);
       if (!agentEntity) {
-        const created = await this.adapter.createEntity({
+        const created = await this.createEntity({
           id: this.agentId,
           agentId: this.agentId,
-          names: Array.from(
-            new Set([this.character.name].filter(Boolean))
-          ),
+          names: Array.from(new Set([this.character.name].filter(Boolean))),
           metadata: {}
         });
         if (!created) {
           throw new Error(`Failed to create entity for agent ${this.agentId}`);
         }
-        this.runtimeLogger.success(
-          `Agent entity created successfully for ${this.character.name}`
+        this.runtimeLogger.debug(
+          `Success: Agent entity created successfully for ${this.character.name}`
         );
       }
     } catch (error) {
@@ -7377,20 +7183,13 @@ var AgentRuntime = class {
       throw error;
     }
     try {
-      const participants = await this.adapter.getParticipantsForRoom(
-        this.agentId
-      );
+      const participants = await this.adapter.getParticipantsForRoom(this.agentId);
       if (!participants.includes(this.agentId)) {
-        const added = await this.adapter.addParticipant(
-          this.agentId,
-          this.agentId
-        );
+        const added = await this.adapter.addParticipant(this.agentId, this.agentId);
         if (!added) {
-          throw new Error(
-            `Failed to add agent ${this.agentId} as participant to its own room`
-          );
+          throw new Error(`Failed to add agent ${this.agentId} as participant to its own room`);
         }
-        this.runtimeLogger.success(
+        this.runtimeLogger.debug(
           `Agent ${this.character.name} linked to its own room successfully`
         );
       }
@@ -7416,10 +7215,7 @@ var AgentRuntime = class {
     }
   }
   async handleProcessingError(error, context) {
-    this.runtimeLogger.error(
-      `Error ${context}:`,
-      error?.message || error || "Unknown error"
-    );
+    this.runtimeLogger.error(`Error ${context}:`, error?.message || error || "Unknown error");
     throw error;
   }
   async checkExistingKnowledge(knowledgeId) {
@@ -7452,7 +7248,7 @@ var AgentRuntime = class {
     const uniqueSources = [
       ...new Set(
         fragments.map((memory) => {
-          this.runtimeLogger.log(
+          this.runtimeLogger.debug(
             `Matched fragment: ${memory.content.text} with similarity: ${memory.similarity}`
           );
           return memory.content.source;
@@ -7481,16 +7277,9 @@ var AgentRuntime = class {
       }
     };
     await this.createMemory(documentMemory, "documents");
-    const fragments = await splitChunks(
-      item.content.text,
-      options2.targetTokens,
-      options2.overlap
-    );
+    const fragments = await splitChunks(item.content.text, options2.targetTokens, options2.overlap);
     for (let i = 0; i < fragments.length; i++) {
-      const embedding = await this.useModel(
-        ModelType.TEXT_EMBEDDING,
-        fragments[i]
-      );
+      const embedding = await this.useModel(ModelType.TEXT_EMBEDDING, fragments[i]);
       const fragmentMemory = {
         id: createUniqueUuid(this, `${item.id}-fragment-${i}`),
         agentId: this.agentId,
@@ -7518,7 +7307,7 @@ var AgentRuntime = class {
         if (await this.checkExistingKnowledge(knowledgeId)) {
           return;
         }
-        this.runtimeLogger.info(
+        this.runtimeLogger.debug(
           "Processing knowledge for ",
           this.character.name,
           " - ",
@@ -7531,10 +7320,7 @@ var AgentRuntime = class {
           }
         });
       } catch (error) {
-        await this.handleProcessingError(
-          error,
-          "processing character knowledge"
-        );
+        await this.handleProcessingError(error, "processing character knowledge");
       } finally {
         this.knowledgeProcessingSemaphore.release();
       }
@@ -7555,7 +7341,7 @@ var AgentRuntime = class {
     }
   }
   getSetting(key) {
-    const value = this.character.secrets?.[key] || this.character.settings?.[key] || this.character.settings?.secrets?.[key] || settings[key];
+    const value = this.character.secrets?.[key] || this.character.settings?.[key] || this.character.settings?.secrets?.[key] || this.settings[key];
     if (value === "true") return true;
     if (value === "false") return false;
     return value || null;
@@ -7574,7 +7360,7 @@ var AgentRuntime = class {
       );
     } else {
       this.adapter = adapter;
-      this.runtimeLogger.success("Database adapter registered successfully.");
+      this.runtimeLogger.debug("Success: Database adapter registered successfully.");
     }
   }
   /**
@@ -7583,9 +7369,7 @@ var AgentRuntime = class {
    */
   registerProvider(provider) {
     this.providers.push(provider);
-    this.runtimeLogger.success(
-      `Provider ${provider.name} registered successfully.`
-    );
+    this.runtimeLogger.debug(`Success: Provider ${provider.name} registered successfully.`);
   }
   /**
    * Register an action for the agent to perform.
@@ -7601,7 +7385,7 @@ var AgentRuntime = class {
       );
     } else {
       this.actions.push(action);
-      this.runtimeLogger.success(
+      this.runtimeLogger.debug(
         `${this.character.name}(${this.agentId}) - Action ${action.name} registered successfully.`
       );
     }
@@ -7637,12 +7421,12 @@ var AgentRuntime = class {
         continue;
       }
       const actions = response.content.actions;
-      this.runtimeLogger.success(
+      this.runtimeLogger.debug(
         `Found actions: ${this.actions.map((a) => normalizeAction(a.name))}`
       );
       for (const responseAction of actions) {
         state = await this.composeState(message, ["RECENT_MESSAGES"]);
-        this.runtimeLogger.success(`Calling action: ${responseAction}`);
+        this.runtimeLogger.debug(`Success: Calling action: ${responseAction}`);
         const normalizedResponseAction = normalizeAction(responseAction);
         let action = this.actions.find(
           (a) => normalizeAction(a.name).includes(normalizedResponseAction) || // the || is kind of a fuzzy match
@@ -7650,32 +7434,22 @@ var AgentRuntime = class {
           //
         );
         if (action) {
-          this.runtimeLogger.success(`Found action: ${action?.name}`);
+          this.runtimeLogger.debug(`Success: Found action: ${action?.name}`);
         } else {
-          this.runtimeLogger.error(`No action found for: ${responseAction}`);
-        }
-        if (!action) {
-          this.runtimeLogger.info("Attempting to find action in similes.");
+          this.runtimeLogger.debug("Attempting to find action in similes.");
           for (const _action of this.actions) {
             const simileAction = _action.similes?.find(
-              (simile) => simile.toLowerCase().replace("_", "").includes(normalizedResponseAction) || normalizedResponseAction.includes(
-                simile.toLowerCase().replace("_", "")
-              )
+              (simile) => simile.toLowerCase().replace("_", "").includes(normalizedResponseAction) || normalizedResponseAction.includes(simile.toLowerCase().replace("_", ""))
             );
             if (simileAction) {
               action = _action;
-              this.runtimeLogger.success(
-                `Action found in similes: ${action.name}`
-              );
+              this.runtimeLogger.debug(`Success: Action found in similes: ${action.name}`);
               break;
             }
           }
         }
         if (!action) {
-          this.runtimeLogger.error(
-            "No action found in",
-            JSON.stringify(response)
-          );
+          this.runtimeLogger.error(`No action found for: ${responseAction}`);
           continue;
         }
         if (!action.handler) {
@@ -7683,13 +7457,9 @@ var AgentRuntime = class {
           continue;
         }
         try {
-          this.runtimeLogger.info(
-            `Executing handler for action: ${action.name}`
-          );
+          this.runtimeLogger.debug(`Executing handler for action: ${action.name}`);
           await action.handler(this, message, state, {}, callback, responses);
-          this.runtimeLogger.success(
-            `Action ${action.name} executed successfully.`
-          );
+          this.runtimeLogger.debug(`Success: Action ${action.name} executed successfully.`);
           this.adapter.log({
             entityId: message.entityId,
             roomId: message.roomId,
@@ -7718,24 +7488,20 @@ var AgentRuntime = class {
    * @returns The results of the evaluation.
    */
   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;
-        }
+    const evaluatorPromises = this.evaluators.map(async (evaluator) => {
+      if (!evaluator.handler) {
         return null;
       }
-    );
-    const evaluators = (await Promise.all(evaluatorPromises)).filter(
-      Boolean
-    );
+      if (!didRespond && !evaluator.alwaysRun) {
+        return null;
+      }
+      const result = await evaluator.validate(this, message, state);
+      if (result) {
+        return evaluator;
+      }
+      return null;
+    });
+    const evaluators = (await Promise.all(evaluatorPromises)).filter(Boolean);
     if (evaluators.length === 0) {
       return [];
     }
@@ -7743,14 +7509,7 @@ var AgentRuntime = class {
     await Promise.all(
       evaluators.map(async (evaluator) => {
         if (evaluator.handler) {
-          await evaluator.handler(
-            this,
-            message,
-            state,
-            {},
-            callback,
-            responses
-          );
+          await evaluator.handler(this, message, state, {}, callback, responses);
           this.adapter.log({
             entityId: message.entityId,
             roomId: message.roomId,
@@ -7767,30 +7526,6 @@ var AgentRuntime = class {
     );
     return evaluators;
   }
-  async ensureParticipantInRoom(entityId, roomId) {
-    const entity = await this.adapter.getEntityById(entityId);
-    if (!entity) {
-      throw new Error(`User ${entityId} not found`);
-    }
-    const participants = await this.adapter.getParticipantsForRoom(roomId);
-    if (!participants.includes(entityId)) {
-      const added = await this.adapter.addParticipant(entityId, roomId);
-      if (!added) {
-        throw new Error(
-          `Failed to add participant ${entityId} to room ${roomId}`
-        );
-      }
-      if (entityId === this.agentId) {
-        this.runtimeLogger.log(
-          `Agent ${this.character.name} linked to room ${roomId} successfully.`
-        );
-      } else {
-        this.runtimeLogger.log(
-          `User ${entityId} linked to room ${roomId} successfully.`
-        );
-      }
-    }
-  }
   async ensureConnection({
     entityId,
     roomId,
@@ -7808,57 +7543,142 @@ var AgentRuntime = class {
     if (!worldId && serverId) {
       worldId = createUniqueUuid(this, serverId);
     }
-    const names4 = [name, userName];
+    const names4 = [name, userName].filter(Boolean);
     const metadata = {
       [source]: {
         name,
         userName
       }
     };
-    const entity = await this.adapter.getEntityById(entityId);
-    if (!entity) {
-      await this.adapter.createEntity({
-        id: entityId,
-        names: names4,
-        metadata,
-        agentId: this.agentId
-      });
-    }
-    if (worldId) {
-      await this.ensureWorldExists({
-        id: worldId,
-        name: serverId ? `World for server ${serverId}` : `World for room ${roomId}`,
-        agentId: this.agentId,
-        serverId: serverId || "default",
-        metadata
-      });
-    }
-    await this.ensureRoomExists({
-      id: roomId,
-      source,
-      type,
-      channelId,
-      serverId,
-      worldId
-    });
     try {
-      await this.ensureParticipantInRoom(entityId, roomId);
+      let entity = await this.adapter.getEntityById(entityId);
+      if (!entity) {
+        try {
+          const success = await this.adapter.createEntity({
+            id: entityId,
+            names: names4,
+            metadata,
+            agentId: this.agentId
+          });
+          if (success) {
+            this.runtimeLogger.debug(
+              `Created new entity ${entityId} for user ${name || userName || "unknown"}`
+            );
+          } else {
+            throw new Error(`Failed to create entity ${entityId}`);
+          }
+        } catch (error) {
+          if (error.message?.includes("duplicate key") || error.code === "23505") {
+            this.runtimeLogger.debug(
+              `Entity ${entityId} exists in database but not for this agent. This is normal in multi-agent setups.`
+            );
+          } else {
+            throw error;
+          }
+        }
+      } else {
+        await this.adapter.updateEntity({
+          id: entityId,
+          names: [.../* @__PURE__ */ new Set([...entity.names || [], ...names4])].filter(Boolean),
+          metadata: {
+            ...entity.metadata,
+            [source]: {
+              ...entity.metadata?.[source],
+              name,
+              userName
+            }
+          },
+          agentId: this.agentId
+        });
+      }
+      if (worldId) {
+        await this.ensureWorldExists({
+          id: worldId,
+          name: serverId ? `World for server ${serverId}` : `World for room ${roomId}`,
+          agentId: this.agentId,
+          serverId: serverId || "default",
+          metadata
+        });
+      }
+      await this.ensureRoomExists({
+        id: roomId,
+        name,
+        source,
+        type,
+        channelId,
+        serverId,
+        worldId
+      });
+      try {
+        await this.ensureParticipantInRoom(entityId, roomId);
+      } catch (error) {
+        if (error.message?.includes("not found")) {
+          const added = await this.adapter.addParticipant(entityId, roomId);
+          if (!added) {
+            throw new Error(`Failed to add participant ${entityId} to room ${roomId}`);
+          }
+          this.runtimeLogger.debug(`Added participant ${entityId} to room ${roomId} directly`);
+        } else {
+          throw error;
+        }
+      }
       await this.ensureParticipantInRoom(this.agentId, roomId);
+      this.runtimeLogger.debug(
+        `Success: Successfully connected entity ${entityId} in room ${roomId}`
+      );
     } catch (error) {
       this.runtimeLogger.error(
-        `Failed to add participants: ${error instanceof Error ? error.message : String(error)}`
+        `Failed to ensure connection: ${error instanceof Error ? error.message : String(error)}`
       );
       throw error;
     }
   }
+  /**
+   * Ensures a participant is added to a room, checking that the entity exists first
+   */
+  async ensureParticipantInRoom(entityId, roomId) {
+    const entity = await this.adapter.getEntityById(entityId);
+    if (!entity && entityId !== this.agentId) {
+      this.runtimeLogger.warn(
+        `Entity ${entityId} not directly accessible to agent ${this.agentId}. Will attempt to add as participant anyway.`
+      );
+    } else if (!entity) {
+      throw new Error(`User ${entityId} not found`);
+    }
+    const participants = await this.adapter.getParticipantsForRoom(roomId);
+    if (!participants.includes(entityId)) {
+      const added = await this.adapter.addParticipant(entityId, roomId);
+      if (!added) {
+        throw new Error(`Failed to add participant ${entityId} to room ${roomId}`);
+      }
+      if (entityId === this.agentId) {
+        this.runtimeLogger.debug(
+          `Agent ${this.character.name} linked to room ${roomId} successfully.`
+        );
+      } else {
+        this.runtimeLogger.debug(`User ${entityId} linked to room ${roomId} successfully.`);
+      }
+    }
+  }
+  async removeParticipant(entityId, roomId) {
+    return await this.adapter.removeParticipant(entityId, roomId);
+  }
+  async getParticipantsForEntity(entityId) {
+    return await this.adapter.getParticipantsForEntity(entityId);
+  }
+  async getParticipantsForRoom(roomId) {
+    return await this.adapter.getParticipantsForRoom(roomId);
+  }
+  async addParticipant(entityId, roomId) {
+    return await this.adapter.addParticipant(entityId, roomId);
+  }
   /**
    * Ensure the existence of a world.
    */
   async ensureWorldExists({ id, name, serverId, metadata }) {
-    console.trace("ensureWorldExists");
     const world = await this.getWorld(id);
     if (!world) {
-      this.runtimeLogger.info("Creating world:", {
+      this.runtimeLogger.debug("Creating world:", {
         id,
         name,
         serverId,
@@ -7871,7 +7691,7 @@ var AgentRuntime = class {
         serverId: serverId || "default",
         metadata
       });
-      this.runtimeLogger.info(`World ${id} created successfully.`);
+      this.runtimeLogger.debug(`World ${id} created successfully.`);
     }
   }
   /**
@@ -7881,15 +7701,7 @@ var AgentRuntime = class {
    * @returns The room ID of the room between the agent and the user.
    * @throws An error if the room cannot be created.
    */
-  async ensureRoomExists({
-    id,
-    name,
-    source,
-    type,
-    channelId,
-    serverId,
-    worldId
-  }) {
+  async ensureRoomExists({ id, name, source, type, channelId, serverId, worldId }) {
     const room = await this.adapter.getRoom(id);
     if (!room) {
       await this.adapter.createRoom({
@@ -7902,7 +7714,7 @@ var AgentRuntime = class {
         serverId,
         worldId
       });
-      this.runtimeLogger.log(`Room ${id} created successfully.`);
+      this.runtimeLogger.debug(`Room ${id} created successfully.`);
     }
   }
   /**
@@ -7923,9 +7735,7 @@ var AgentRuntime = class {
     if (filterList && filterList.length > 0) {
       filterList.forEach((name) => providerNames.add(name));
     } else {
-      this.providers.filter(
-        (p) => !p.private && !p.dynamic && !existingProviderNames.includes(p.name)
-      ).forEach((p) => providerNames.add(p.name));
+      this.providers.filter((p) => !p.private && !p.dynamic && !existingProviderNames.includes(p.name)).forEach((p) => providerNames.add(p.name));
     }
     if (includeList && includeList.length > 0) {
       includeList.forEach((name) => providerNames.add(name));
@@ -7938,9 +7748,7 @@ var AgentRuntime = class {
         const start = Date.now();
         const result = await provider.get(this, message, cachedState);
         const duration = Date.now() - start;
-        this.runtimeLogger.warn(
-          `${provider.name} Provider took ${duration}ms to respond`
-        );
+        this.runtimeLogger.debug(`${provider.name} Provider took ${duration}ms to respond`);
         return {
           ...result,
           providerName: provider.name
@@ -7998,7 +7806,7 @@ ${newProvidersText}`;
     if (!serviceType) {
       return;
     }
-    this.runtimeLogger.log(
+    this.runtimeLogger.debug(
       `${this.character.name}(${this.agentId}) - Registering service:`,
       serviceType
     );
@@ -8010,7 +7818,7 @@ ${newProvidersText}`;
     }
     const serviceInstance = await service.start(this);
     this.services.set(serviceType, serviceInstance);
-    this.runtimeLogger.success(
+    this.runtimeLogger.debug(
       `${this.character.name}(${this.agentId}) - Service ${serviceType} registered successfully`
     );
   }
@@ -8043,10 +7851,7 @@ ${newProvidersText}`;
     if (!model) {
       throw new Error(`No handler found for delegate type: ${modelKey}`);
     }
-    this.runtimeLogger.debug(
-      `[useModel] ${modelKey} input:`,
-      JSON.stringify(params, null, 2)
-    );
+    this.runtimeLogger.debug(`[useModel] ${modelKey} input:`, JSON.stringify(params, null, 2));
     let paramsWithRuntime;
     if (params === null || params === void 0 || typeof params !== "object" || Array.isArray(params) || typeof Buffer !== "undefined" && Buffer.isBuffer(params)) {
       paramsWithRuntime = params;
@@ -8059,9 +7864,7 @@ ${newProvidersText}`;
     const startTime = performance.now();
     const response = await model(this, paramsWithRuntime);
     const elapsedTime = performance.now() - startTime;
-    this.runtimeLogger.info(
-      `[useModel] ${modelKey} completed in ${elapsedTime.toFixed(2)}ms`
-    );
+    this.runtimeLogger.debug(`[useModel] ${modelKey} completed in ${elapsedTime.toFixed(2)}ms`);
     this.runtimeLogger.debug(
       `[useModel] ${modelKey} output:`,
       // if response is an array, should the first and last 5 items with a "..." in the middle, and a (x items) at the end
@@ -8121,9 +7924,7 @@ ${newProvidersText}`;
       );
       const embedding = await this.useModel(ModelType.TEXT_EMBEDDING, null);
       if (!embedding || !embedding.length) {
-        throw new Error(
-          `[AgentRuntime][${this.character.name}] Invalid embedding received`
-        );
+        throw new Error(`[AgentRuntime][${this.character.name}] Invalid embedding received`);
       }
       this.runtimeLogger.debug(
         `[AgentRuntime][${this.character.name}] Setting embedding dimension: ${embedding.length}`
@@ -8133,7 +7934,7 @@ ${newProvidersText}`;
         `[AgentRuntime][${this.character.name}] Successfully set embedding dimension`
       );
     } catch (error) {
-      this.runtimeLogger.info(
+      this.runtimeLogger.debug(
         `[AgentRuntime][${this.character.name}] Error in ensureEmbeddingDimension:`,
         error
       );
@@ -8189,18 +7990,16 @@ ${newProvidersText}`;
     return await this.adapter.getEntitiesForRoom(roomId, includeComponents);
   }
   async createEntity(entity) {
+    if (!entity.agentId) {
+      entity.agentId = this.agentId;
+    }
     return await this.adapter.createEntity(entity);
   }
   async updateEntity(entity) {
     await this.adapter.updateEntity(entity);
   }
   async getComponent(entityId, type, worldId, sourceEntityId) {
-    return await this.adapter.getComponent(
-      entityId,
-      type,
-      worldId,
-      sourceEntityId
-    );
+    return await this.adapter.getComponent(entityId, type, worldId, sourceEntityId);
   }
   async getComponents(entityId, worldId, sourceEntityId) {
     return await this.adapter.getComponents(entityId, worldId, sourceEntityId);
@@ -8256,6 +8055,9 @@ ${newProvidersText}`;
   async createMemory(memory, tableName, unique) {
     return await this.adapter.createMemory(memory, tableName, unique);
   }
+  async updateMemory(memory) {
+    return await this.adapter.updateMemory(memory);
+  }
   async deleteMemory(memoryId) {
     await this.adapter.deleteMemory(memoryId);
   }
@@ -8286,15 +8088,7 @@ ${newProvidersText}`;
   async getRoom(roomId) {
     return await this.adapter.getRoom(roomId);
   }
-  async createRoom({
-    id,
-    name,
-    source,
-    type,
-    channelId,
-    serverId,
-    worldId
-  }) {
+  async createRoom({ id, name, source, type, channelId, serverId, worldId }) {
     return await this.adapter.createRoom({
       id,
       name,
@@ -8320,18 +8114,6 @@ ${newProvidersText}`;
   async getRooms(worldId) {
     return await this.adapter.getRooms(worldId);
   }
-  async addParticipant(entityId, roomId) {
-    return await this.adapter.addParticipant(entityId, roomId);
-  }
-  async removeParticipant(entityId, roomId) {
-    return await this.adapter.removeParticipant(entityId, roomId);
-  }
-  async getParticipantsForEntity(entityId) {
-    return await this.adapter.getParticipantsForEntity(entityId);
-  }
-  async getParticipantsForRoom(roomId) {
-    return await this.adapter.getParticipantsForRoom(roomId);
-  }
   async getParticipantUserState(roomId, entityId) {
     return await this.adapter.getParticipantUserState(roomId, entityId);
   }
@@ -8408,15 +8190,12 @@ export {
   AgentStatus,
   CacheKeyPrefix,
   ChannelType,
-  CharacterSchema,
   DatabaseAdapter,
-  EventTypes,
+  EventType,
   KnowledgeScope,
   MemoryType,
-  MessageExampleSchema,
   ModelType,
   PlatformPrefix,
-  PluginSchema,
   Role,
   SOCKET_MESSAGE_TYPE,
   Semaphore,
@@ -8433,7 +8212,6 @@ export {
   composePrompt,
   composePromptFromState,
   composeRandomUser,
-  configureSettings,
   createMessageMemory,
   createServiceError,
   createUniqueUuid,
@@ -8441,7 +8219,6 @@ export {
   elizaLogger,
   extractAttributes,
   findEntityByName,
-  findNearestEnvFile,
   findWorldForOwner,
   formatActionNames,
   formatActions,
@@ -8451,7 +8228,6 @@ export {
   formatTimestamp,
   getBrowserService,
   getEntityDetails,
-  getEnvVariable,
   getFileService,
   getMemoryText,
   getPdfService,
@@ -8460,7 +8236,6 @@ export {
   getVideoService,
   getWorldSettings2 as getWorldSettings,
   handlePluginImporting,
-  hasEnvVariable,
   initializeOnboarding,
   isCustomMetadata,
   isDescriptionMetadata,
@@ -8480,7 +8255,6 @@ export {
   postActionResponseFooter,
   postCreationTemplate,
   registerDynamicImport,
-  settings,
   shouldRespondTemplate,
   splitChunks,
   stringArrayFooter,
@@ -8489,6 +8263,5 @@ export {
   truncateToCompleteSentence,
   updateWorldSettings2 as updateWorldSettings,
   uuidSchema,
-  validateCharacterConfig,
   validateUuid
 };