@elizaos/core 1.6.5 → 1.7.0-beta.0

package/dist/node/index.node.js

@@ -25135,6 +25135,45 @@ https://github.com/browserify/crypto-browserify`);
   };
 });
 
+// src/streaming-context.ts
+class NoopContextManager {
+  run(_context, fn) {
+    return fn();
+  }
+  active() {
+    return;
+  }
+}
+var globalContextManager = new NoopContextManager;
+function setStreamingContextManager(manager) {
+  globalContextManager = manager;
+}
+function getStreamingContextManager() {
+  return globalContextManager;
+}
+function runWithStreamingContext(context, fn) {
+  return globalContextManager.run(context, fn);
+}
+function getStreamingContext() {
+  return globalContextManager.active();
+}
+
+// src/streaming-context.node.ts
+import { AsyncLocalStorage } from "async_hooks";
+
+class AsyncLocalStorageContextManager {
+  storage = new AsyncLocalStorage;
+  run(context, fn) {
+    return this.storage.run(context, fn);
+  }
+  active() {
+    return this.storage.getStore();
+  }
+}
+function createNodeStreamingContextManager() {
+  return new AsyncLocalStorageContextManager;
+}
+
 // src/types/primitives.ts
 function asUUID(id) {
   if (!id || !/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(id)) {
@@ -25151,16 +25190,6 @@ var ContentType;
   ContentType2["LINK"] = "link";
 })(ContentType ||= {});
 
-// src/types/memory.ts
-var MemoryType;
-((MemoryType2) => {
-  MemoryType2["DOCUMENT"] = "document";
-  MemoryType2["FRAGMENT"] = "fragment";
-  MemoryType2["MESSAGE"] = "message";
-  MemoryType2["DESCRIPTION"] = "description";
-  MemoryType2["CUSTOM"] = "custom";
-})(MemoryType ||= {});
-
 // src/types/environment.ts
 var Role;
 ((Role2) => {
@@ -25182,6 +25211,16 @@ var ChannelType;
   ChannelType2["API"] = "API";
 })(ChannelType ||= {});
 
+// src/types/memory.ts
+var MemoryType;
+((MemoryType2) => {
+  MemoryType2["DOCUMENT"] = "document";
+  MemoryType2["FRAGMENT"] = "fragment";
+  MemoryType2["MESSAGE"] = "message";
+  MemoryType2["DESCRIPTION"] = "description";
+  MemoryType2["CUSTOM"] = "custom";
+})(MemoryType ||= {});
+
 // src/types/agent.ts
 var AgentStatus;
 ((AgentStatus2) => {
@@ -25342,6 +25381,15 @@ var MODEL_SETTINGS = {
   MODEL_FREQ_PENALTY: "MODEL_FREQ_PENALTY",
   MODEL_PRESENCE_PENALTY: "MODEL_PRESENCE_PENALTY"
 };
+function isStreamableModelType(modelType) {
+  return [
+    ModelType.TEXT_SMALL,
+    ModelType.TEXT_LARGE,
+    ModelType.TEXT_REASONING_SMALL,
+    ModelType.TEXT_REASONING_LARGE,
+    ModelType.TEXT_COMPLETION
+  ].includes(modelType);
+}
 
 // src/types/database.ts
 var VECTOR_DIMS = {
@@ -25384,6 +25432,7 @@ var EventType;
   EventType2["EMBEDDING_GENERATION_REQUESTED"] = "EMBEDDING_GENERATION_REQUESTED";
   EventType2["EMBEDDING_GENERATION_COMPLETED"] = "EMBEDDING_GENERATION_COMPLETED";
   EventType2["EMBEDDING_GENERATION_FAILED"] = "EMBEDDING_GENERATION_FAILED";
+  EventType2["CONTROL_MESSAGE"] = "CONTROL_MESSAGE";
 })(EventType ||= {});
 var PlatformPrefix;
 ((PlatformPrefix2) => {
@@ -25415,6 +25464,11 @@ var SOCKET_MESSAGE_TYPE;
   SOCKET_MESSAGE_TYPE2[SOCKET_MESSAGE_TYPE2["THINKING"] = 5] = "THINKING";
   SOCKET_MESSAGE_TYPE2[SOCKET_MESSAGE_TYPE2["CONTROL"] = 6] = "CONTROL";
 })(SOCKET_MESSAGE_TYPE ||= {});
+var MESSAGE_STREAM_EVENT = {
+  messageStreamChunk: "messageStreamChunk",
+  messageStreamError: "messageStreamError",
+  messageBroadcast: "messageBroadcast"
+};
 // ../../node_modules/@langchain/core/dist/_virtual/rolldown_runtime.js
 var __defProp2 = Object.defineProperty;
 var __export = (target, all) => {
@@ -41565,7 +41619,7 @@ function detectEnvironment() {
   if (typeof process !== "undefined" && process.versions && process.versions.node) {
     return "node";
   }
-  if (typeof globalThis !== "undefined" && typeof globalThis.window !== "undefined" && typeof globalThis.window.document !== "undefined") {
+  if (typeof globalThis !== "undefined" && typeof globalThis.window !== "undefined" && typeof globalThis.window?.document !== "undefined") {
     return "browser";
   }
   return "unknown";
@@ -41574,11 +41628,13 @@ function detectEnvironment() {
 class BrowserEnvironmentStore {
   store = {};
   constructor() {
-    if (typeof globalThis !== "undefined" && globalThis.window && globalThis.window.ENV) {
-      this.store = { ...globalThis.window.ENV };
+    const windowWithEnv = globalThis;
+    if (typeof globalThis !== "undefined" && windowWithEnv.window && windowWithEnv.window.ENV) {
+      this.store = { ...windowWithEnv.window.ENV };
     }
-    if (typeof globalThis !== "undefined" && globalThis.__ENV__) {
-      this.store = { ...this.store, ...globalThis.__ENV__ };
+    const globalWithEnv = globalThis;
+    if (typeof globalThis !== "undefined" && globalWithEnv.__ENV__) {
+      this.store = { ...this.store, ...globalWithEnv.__ENV__ };
     }
   }
   get(key) {
@@ -41751,26 +41807,19 @@ function loadEnvFile(envPath) {
   if (typeof process === "undefined" || !process.cwd) {
     return false;
   }
-  try {
-    const dotenv = __require("dotenv");
-    const resolvedPath = envPath || findEnvFile();
-    if (!resolvedPath) {
-      return false;
-    }
-    const result = dotenv.config({ path: resolvedPath });
-    if (result.error) {
-      if (typeof console !== "undefined" && console.warn) {
-        console.warn(`Failed to parse .env file at ${resolvedPath}:`, result.error);
-      }
-      return false;
-    }
-    return true;
-  } catch (error) {
+  const dotenv = __require("dotenv");
+  const resolvedPath = envPath || findEnvFile();
+  if (!resolvedPath) {
+    return false;
+  }
+  const result = dotenv.config({ path: resolvedPath });
+  if (result.error) {
     if (typeof console !== "undefined" && console.warn) {
-      console.warn("Failed to load .env file:", error);
+      console.warn(`Failed to parse .env file at ${resolvedPath}:`, result.error);
     }
     return false;
   }
+  return true;
 }
 // ../../node_modules/adze/dist/tools.js
 class Tools {
@@ -43491,6 +43540,14 @@ var import_fast_redact = __toESM(require_fast_redact(), 1);
 var __loggerTestHooks = {
   __noop: () => {}
 };
+var logListeners = new Set;
+function addLogListener(listener) {
+  logListeners.add(listener);
+  return () => logListeners.delete(listener);
+}
+function removeLogListener(listener) {
+  logListeners.delete(listener);
+}
 var LOG_LEVEL_PRIORITY = {
   trace: 10,
   verbose: 10,
@@ -43635,6 +43692,11 @@ function createInMemoryDestination(maxLogs = 100) {
       if (logs.length > maxLogs) {
         logs.shift();
       }
+      for (const listener of logListeners) {
+        try {
+          listener(entry);
+        } catch {}
+      }
     },
     clear() {
       logs.length = 0;
@@ -43790,12 +43852,8 @@ function sealAdze(base) {
   if (raw && !metaBase.hostname) {
     let hostname = "unknown";
     if (typeof process !== "undefined" && process.platform) {
-      try {
-        const os = __require("os");
-        hostname = os.hostname();
-      } catch {
-        hostname = "localhost";
-      }
+      const os = __require("os");
+      hostname = os.hostname();
     } else if (typeof window !== "undefined" && window.location) {
       hostname = window.location.hostname || "browser";
     }
@@ -43849,9 +43907,10 @@ function createLogger(bindings = false) {
         return;
       }
       const message = formatArgs(...args);
-      const consoleMethod = method === "fatal" ? "error" : method === "trace" || method === "verbose" ? "debug" : method === "success" || method === "progress" ? "info" : method === "log" ? "log" : console[method] ? method : "log";
-      if (typeof console[consoleMethod] === "function") {
-        console[consoleMethod](message);
+      const consoleMethod = method === "fatal" ? "error" : method === "trace" || method === "verbose" ? "debug" : method === "success" || method === "progress" ? "info" : method === "log" ? "log" : (method in console) && typeof console[method] === "function" ? method : "log";
+      const consoleFn = console[consoleMethod];
+      if (consoleFn && typeof consoleFn === "function") {
+        consoleFn(message);
       }
     };
     const safeRedact2 = (obj) => {
@@ -43905,27 +43964,25 @@ function createLogger(bindings = false) {
       return;
     }
     captureIfError(method, args);
-    try {
-      let msg = "";
-      if (args.length > 0) {
-        msg = args.map((arg) => {
-          if (typeof arg === "string")
-            return arg;
-          if (arg instanceof Error)
-            return arg.message;
-          return safeStringify(arg);
-        }).join(" ");
-      }
-      if (base.namespace) {
-        msg = `#${base.namespace}  ${msg}`;
-      }
-      const entry = {
-        time: Date.now(),
-        level: LOG_LEVEL_PRIORITY[method.toLowerCase()] || LOG_LEVEL_PRIORITY.info,
-        msg
-      };
-      globalInMemoryDestination.write(entry);
-    } catch {}
+    let msg = "";
+    if (args.length > 0) {
+      msg = args.map((arg) => {
+        if (typeof arg === "string")
+          return arg;
+        if (arg instanceof Error)
+          return arg.message;
+        return safeStringify(arg);
+      }).join(" ");
+    }
+    if (base.namespace) {
+      msg = `#${base.namespace}  ${msg}`;
+    }
+    const entry = {
+      time: Date.now(),
+      level: LOG_LEVEL_PRIORITY[method.toLowerCase()] || LOG_LEVEL_PRIORITY.info,
+      msg
+    };
+    globalInMemoryDestination.write(entry);
     let adzeMethod = method;
     let adzeArgs = args;
     if (method === "fatal") {
@@ -43940,8 +43997,11 @@ function createLogger(bindings = false) {
       adzeMethod = "verbose";
     }
     try {
-      sealed[adzeMethod](...adzeArgs);
-    } catch (error2) {
+      const sealedRecord = sealed;
+      if (adzeMethod in sealedRecord && typeof sealedRecord[adzeMethod] === "function") {
+        sealedRecord[adzeMethod](...adzeArgs);
+      }
+    } catch {
       console.log(`[${method.toUpperCase()}]`, ...args);
     }
   };
@@ -43985,11 +44045,9 @@ function createLogger(bindings = false) {
   const progress = (obj, msg, ...args) => invoke("progress", ...adaptArgs(obj, msg, ...args));
   const logFn = (obj, msg, ...args) => invoke("log", ...adaptArgs(obj, msg, ...args));
   const clear = () => {
-    try {
-      if (typeof console?.clear === "function") {
-        console.clear();
-      }
-    } catch {}
+    if (typeof console?.clear === "function") {
+      console.clear();
+    }
     globalInMemoryDestination.clear();
   };
   const child = (childBindings) => {
@@ -44163,11 +44221,16 @@ var jsonBlockPattern = /```json\n([\s\S]*?)\n```/;
 function parseKeyValueXml(text) {
   if (!text)
     return null;
-  let xmlBlockMatch = text.match(/<response>([\s\S]*?)<\/response>/);
-  let xmlContent;
-  if (xmlBlockMatch) {
-    xmlContent = xmlBlockMatch[1];
-  } else {
+  let xmlContent = null;
+  const responseStart = text.indexOf("<response>");
+  if (responseStart !== -1) {
+    const contentStart = responseStart + "<response>".length;
+    const responseEnd = text.indexOf("</response>", contentStart);
+    if (responseEnd !== -1) {
+      xmlContent = text.slice(contentStart, responseEnd);
+    }
+  }
+  if (!xmlContent) {
     const findFirstXmlBlock = (input) => {
       let i = 0;
       const length = input.length;
@@ -44333,15 +44396,15 @@ function parseKeyValueXml(text) {
   return result;
 }
 function parseJSONObjectFromText(text) {
-  let jsonData = null;
   const jsonBlockMatch = text.match(jsonBlockPattern);
+  let jsonData = null;
   try {
     if (jsonBlockMatch) {
       jsonData = JSON.parse(normalizeJsonString(jsonBlockMatch[1].trim()));
     } else {
       jsonData = JSON.parse(normalizeJsonString(text.trim()));
     }
-  } catch (_e) {
+  } catch {
     return null;
   }
   if (jsonData && typeof jsonData === "object" && !Array.isArray(jsonData)) {
@@ -44394,14 +44457,16 @@ async function trimTokens(prompt, maxTokens, runtime) {
   if (maxTokens <= 0)
     throw new Error("maxTokens must be positive");
   const tokens = await runtime.useModel(ModelType.TEXT_TOKENIZER_ENCODE, {
-    prompt
+    prompt,
+    modelType: ModelType.TEXT_TOKENIZER_ENCODE
   });
   if (tokens.length <= maxTokens) {
     return prompt;
   }
   const truncatedTokens = tokens.slice(-maxTokens);
   return await runtime.useModel(ModelType.TEXT_TOKENIZER_DECODE, {
-    tokens: truncatedTokens
+    tokens: truncatedTokens,
+    modelType: ModelType.TEXT_TOKENIZER_DECODE
   });
 }
 function safeReplacer() {
@@ -44469,12 +44534,10 @@ var webCryptoAvailable = null;
 function checkWebCrypto() {
   if (webCryptoAvailable !== null)
     return webCryptoAvailable;
-  try {
-    if (typeof globalThis !== "undefined" && globalThis.crypto && globalThis.crypto.subtle && typeof globalThis.crypto.subtle.digest === "function") {
-      webCryptoAvailable = true;
-      return true;
-    }
-  } catch {}
+  if (typeof globalThis !== "undefined" && globalThis.crypto && globalThis.crypto.subtle && typeof globalThis.crypto.subtle.digest === "function") {
+    webCryptoAvailable = true;
+    return true;
+  }
   webCryptoAvailable = false;
   return false;
 }
@@ -44497,12 +44560,10 @@ function getCachedSha1(message) {
 }
 async function sha1BytesAsync(message) {
   if (checkWebCrypto()) {
-    try {
-      const encoder2 = new TextEncoder;
-      const data2 = encoder2.encode(message);
-      const hashBuffer = await globalThis.crypto.subtle.digest("SHA-1", data2);
-      return new Uint8Array(hashBuffer);
-    } catch {}
+    const encoder2 = new TextEncoder;
+    const data2 = encoder2.encode(message);
+    const hashBuffer = await globalThis.crypto.subtle.digest("SHA-1", data2);
+    return new Uint8Array(hashBuffer);
   }
   return sha1Bytes(message);
 }
@@ -44667,7 +44728,7 @@ var styleSchema = z3.object({
   chat: z3.array(z3.string()).optional().describe("Style guidelines specific to chat/conversation responses"),
   post: z3.array(z3.string()).optional().describe("Style guidelines specific to social media posts")
 }).optional().describe("Style configuration defining how the character communicates across different contexts");
-var settingsSchema = z3.record(z3.string(), z3.union([z3.string(), z3.boolean(), z3.number(), z3.object({}).loose(), z3.array(z3.any())])).optional().describe("Character-specific settings like avatar URL, preferences, and configuration");
+var settingsSchema = z3.record(z3.string(), z3.union([z3.string(), z3.boolean(), z3.number(), z3.object({}).loose(), z3.array(z3.unknown())])).optional().describe("Character-specific settings like avatar URL, preferences, and configuration");
 var secretsSchema = z3.record(z3.string(), z3.union([z3.string(), z3.boolean(), z3.number()])).optional().describe("Secret values and API keys (should not be committed to version control)");
 var characterSchema = z3.object({
   id: uuidSchema2.optional().describe("Unique identifier for the character"),
@@ -44787,7 +44848,14 @@ function isBuffer(obj) {
   if (hasNativeBuffer() && Buffer.isBuffer(obj)) {
     return true;
   }
-  return obj instanceof Uint8Array || obj instanceof ArrayBuffer || typeof obj === "object" && obj.buffer instanceof ArrayBuffer && typeof obj.byteLength === "number" && !Array.isArray(obj);
+  if (obj instanceof Uint8Array || obj instanceof ArrayBuffer) {
+    return true;
+  }
+  if (typeof obj === "object" && obj !== null && !Array.isArray(obj)) {
+    const typedObj = obj;
+    return typedObj.buffer instanceof ArrayBuffer && typeof typedObj.byteLength === "number";
+  }
+  return false;
 }
 function alloc(size) {
   if (hasNativeBuffer()) {
@@ -44867,13 +44935,267 @@ var BufferUtils = {
   byteLength,
   randomBytes
 };
+// src/utils/streaming.ts
+class StreamError extends Error {
+  code;
+  details;
+  constructor(code, message, details) {
+    super(message);
+    this.name = "StreamError";
+    this.code = code;
+    this.details = details;
+  }
+  static isStreamError(error) {
+    return error instanceof StreamError;
+  }
+}
+var SAFE_MARGIN = 10;
+var MAX_BUFFER = 100 * 1024;
+var MAX_CHUNK_SIZE = 1024 * 1024;
+var ACTIONS_REGEX = /<actions>([\s\S]*?)<\/actions>/;
+function extractTagContent(buffer, openTag, closeTag, insideTag, safeMargin = SAFE_MARGIN) {
+  let currentBuffer = buffer;
+  let currentInsideTag = insideTag;
+  if (!currentInsideTag) {
+    const idx = currentBuffer.indexOf(openTag);
+    if (idx !== -1) {
+      currentInsideTag = true;
+      currentBuffer = currentBuffer.slice(idx + openTag.length);
+    } else {
+      return { content: "", closed: false, buffer: currentBuffer, insideTag: false };
+    }
+  }
+  const closeIdx = currentBuffer.indexOf(closeTag);
+  if (closeIdx !== -1) {
+    const content = currentBuffer.slice(0, closeIdx);
+    const newBuffer = currentBuffer.slice(closeIdx + closeTag.length);
+    return { content, closed: true, buffer: newBuffer, insideTag: false };
+  }
+  if (currentBuffer.length > safeMargin) {
+    const content = currentBuffer.slice(0, -safeMargin);
+    const newBuffer = currentBuffer.slice(-safeMargin);
+    return { content, closed: false, buffer: newBuffer, insideTag: true };
+  }
+  return { content: "", closed: false, buffer: currentBuffer, insideTag: true };
+}
+function validateChunkSize(chunk) {
+  if (chunk.length > MAX_CHUNK_SIZE) {
+    throw new StreamError("CHUNK_TOO_LARGE", `Chunk size ${chunk.length} exceeds maximum allowed ${MAX_CHUNK_SIZE}`, {
+      chunkSize: chunk.length,
+      maxAllowed: MAX_CHUNK_SIZE
+    });
+  }
+}
+function trimBuffer(buffer, maxSize = MAX_BUFFER, keepSize = 1024) {
+  if (buffer.length > maxSize) {
+    return buffer.slice(-keepSize);
+  }
+  return buffer;
+}
+
+class PassthroughExtractor {
+  get done() {
+    return false;
+  }
+  push(chunk) {
+    validateChunkSize(chunk);
+    return chunk;
+  }
+  reset() {}
+}
+
+class XmlTagExtractor {
+  openTag;
+  closeTag;
+  buffer = "";
+  insideTag = false;
+  finished = false;
+  constructor(tagName) {
+    this.openTag = `<${tagName}>`;
+    this.closeTag = `</${tagName}>`;
+  }
+  get done() {
+    return this.finished;
+  }
+  push(chunk) {
+    if (this.finished)
+      return "";
+    validateChunkSize(chunk);
+    this.buffer += chunk;
+    if (!this.insideTag) {
+      this.buffer = trimBuffer(this.buffer);
+    }
+    const result = extractTagContent(this.buffer, this.openTag, this.closeTag, this.insideTag, SAFE_MARGIN);
+    this.buffer = result.buffer;
+    this.insideTag = result.insideTag;
+    if (result.closed) {
+      this.finished = true;
+    }
+    return result.content;
+  }
+  reset() {
+    this.buffer = "";
+    this.insideTag = false;
+    this.finished = false;
+  }
+}
+
+class ResponseStreamExtractor {
+  static STREAM_TAGS = ["text"];
+  buffer = "";
+  insideTag = false;
+  currentTag = null;
+  finished = false;
+  responseStrategy = "pending";
+  get done() {
+    return this.finished;
+  }
+  reset() {
+    this.buffer = "";
+    this.insideTag = false;
+    this.currentTag = null;
+    this.finished = false;
+    this.responseStrategy = "pending";
+  }
+  push(chunk) {
+    validateChunkSize(chunk);
+    this.buffer += chunk;
+    if (this.responseStrategy === "pending") {
+      this.detectResponseStrategy();
+    }
+    if (!this.insideTag) {
+      for (const tag of ResponseStreamExtractor.STREAM_TAGS) {
+        const openTag = `<${tag}>`;
+        const closeTag2 = `</${tag}>`;
+        const idx = this.buffer.indexOf(openTag);
+        if (idx !== -1) {
+          if (!this.shouldStreamTag(tag)) {
+            const closeIdx2 = this.buffer.indexOf(closeTag2);
+            if (closeIdx2 !== -1) {
+              this.buffer = this.buffer.slice(closeIdx2 + closeTag2.length);
+              continue;
+            }
+            break;
+          }
+          this.insideTag = true;
+          this.currentTag = tag;
+          this.buffer = this.buffer.slice(idx + openTag.length);
+          break;
+        }
+      }
+    }
+    if (!this.insideTag) {
+      this.buffer = trimBuffer(this.buffer);
+      return "";
+    }
+    const closeTag = `</${this.currentTag}>`;
+    const closeIdx = this.buffer.indexOf(closeTag);
+    if (closeIdx !== -1) {
+      const content = this.buffer.slice(0, closeIdx);
+      this.buffer = this.buffer.slice(closeIdx + closeTag.length);
+      this.insideTag = false;
+      this.currentTag = null;
+      this.finished = true;
+      return content;
+    }
+    if (this.buffer.length > SAFE_MARGIN) {
+      const toStream = this.buffer.slice(0, -SAFE_MARGIN);
+      this.buffer = this.buffer.slice(-SAFE_MARGIN);
+      return toStream;
+    }
+    return "";
+  }
+  detectResponseStrategy() {
+    const match = this.buffer.match(ACTIONS_REGEX);
+    if (match) {
+      const actions = this.parseActions(match[1]);
+      this.responseStrategy = this.isDirectReply(actions) ? "direct" : "delegated";
+    }
+  }
+  parseActions(raw2) {
+    return raw2.split(",").map((a) => a.trim().toUpperCase()).filter(Boolean);
+  }
+  isDirectReply(actions) {
+    return actions.length === 1 && actions[0] === "REPLY";
+  }
+  shouldStreamTag(tag) {
+    return tag === "text" && this.responseStrategy === "direct";
+  }
+}
+
+class ActionStreamFilter {
+  buffer = "";
+  decided = false;
+  contentType = null;
+  insideTextTag = false;
+  finished = false;
+  get done() {
+    return this.finished;
+  }
+  reset() {
+    this.buffer = "";
+    this.decided = false;
+    this.contentType = null;
+    this.insideTextTag = false;
+    this.finished = false;
+  }
+  push(chunk) {
+    validateChunkSize(chunk);
+    this.buffer += chunk;
+    if (!this.decided) {
+      const contentType = this.detectContentType();
+      if (contentType) {
+        this.contentType = contentType;
+        this.decided = true;
+      } else {
+        return "";
+      }
+    }
+    switch (this.contentType) {
+      case "json":
+        return "";
+      case "text":
+        return this.handlePlainText();
+      case "xml":
+        return this.handleXml();
+      default:
+        return "";
+    }
+  }
+  detectContentType() {
+    const trimmed = this.buffer.trimStart();
+    if (trimmed.length === 0)
+      return null;
+    const firstChar = trimmed[0];
+    if (firstChar === "{" || firstChar === "[")
+      return "json";
+    if (firstChar === "<")
+      return "xml";
+    return "text";
+  }
+  handlePlainText() {
+    const toStream = this.buffer;
+    this.buffer = "";
+    return toStream;
+  }
+  handleXml() {
+    const result = extractTagContent(this.buffer, "<text>", "</text>", this.insideTextTag, SAFE_MARGIN);
+    this.buffer = result.buffer;
+    this.insideTextTag = result.insideTag;
+    if (result.closed) {
+      this.finished = true;
+    }
+    if (!this.insideTextTag && !result.closed) {
+      this.buffer = trimBuffer(this.buffer, 1024, 1024);
+    }
+    return result.content;
+  }
+}
 // src/utils/paths.ts
 var pathJoin = (...parts) => {
   if (typeof process !== "undefined" && process.platform) {
-    try {
-      const path = __require("node:path");
-      return path.join(...parts);
-    } catch {}
+    const path = __require("node:path");
+    return path.join(...parts);
   }
   return parts.filter((part) => part).join("/").replace(/\/+/g, "/").replace(/\/$/, "");
 };
@@ -44993,28 +45315,22 @@ async function waitForServerReady(options) {
   while (Date.now() - startTime < maxWaitTime) {
     let controller;
     let timeoutId;
-    try {
-      controller = new AbortController;
-      timeoutId = setTimeout(() => {
-        if (controller) {
-          controller.abort();
-        }
-      }, requestTimeout);
-      const response = await fetch(url, {
-        signal: controller.signal
-      });
-      if (timeoutId) {
-        clearTimeout(timeoutId);
-        timeoutId = undefined;
-      }
-      if (response.ok) {
-        await new Promise((resolve) => setTimeout(resolve, 1000));
-        return;
-      }
-    } catch (error) {} finally {
-      if (timeoutId) {
-        clearTimeout(timeoutId);
+    controller = new AbortController;
+    timeoutId = setTimeout(() => {
+      if (controller) {
+        controller.abort();
       }
+    }, requestTimeout);
+    const response = await fetch(url, {
+      signal: controller.signal
+    });
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+      timeoutId = undefined;
+    }
+    if (response.ok) {
+      await new Promise((resolve) => setTimeout(resolve, 1000));
+      return;
     }
     await new Promise((resolve) => setTimeout(resolve, pollInterval));
   }
@@ -45031,28 +45347,20 @@ async function pingServer(options) {
   const url = `${protocol}://${host}:${port}${endpoint}`;
   let controller;
   let timeoutId;
-  try {
-    controller = new AbortController;
-    timeoutId = setTimeout(() => {
-      if (controller) {
-        controller.abort();
-      }
-    }, requestTimeout);
-    const response = await fetch(url, {
-      signal: controller.signal
-    });
-    if (timeoutId) {
-      clearTimeout(timeoutId);
-      timeoutId = undefined;
-    }
-    return response.ok;
-  } catch (error) {
-    return false;
-  } finally {
-    if (timeoutId) {
-      clearTimeout(timeoutId);
-    }
+  controller = new AbortController;
+  timeoutId = setTimeout(() => {
+    if (controller) {
+      controller.abort();
+    }
+  }, requestTimeout);
+  const response = await fetch(url, {
+    signal: controller.signal
+  });
+  if (timeoutId) {
+    clearTimeout(timeoutId);
+    timeoutId = undefined;
   }
+  return response.ok;
 }
 // src/actions.ts
 var import_unique_names_generator2 = __toESM(require_dist4(), 1);
@@ -45469,9 +45777,6 @@ async function getUserServerRole(runtime, entityId, serverId2) {
   if (world.metadata.roles[entityId]) {
     return world.metadata.roles[entityId];
   }
-  if (world.metadata.roles[entityId]) {
-    return world.metadata.roles[entityId];
-  }
   return "NONE" /* NONE */;
 }
 async function findWorldsForOwner(runtime, entityId) {
@@ -45592,11 +45897,12 @@ class DefaultMessageService {
     const opts = {
       maxRetries: options?.maxRetries ?? 3,
       timeoutDuration: options?.timeoutDuration ?? 60 * 60 * 1000,
-      useMultiStep: options?.useMultiStep ?? parseBooleanFromText2(runtime.getSetting("USE_MULTI_STEP")),
-      maxMultiStepIterations: options?.maxMultiStepIterations ?? parseInt(runtime.getSetting("MAX_MULTISTEP_ITERATIONS") || "6")
+      useMultiStep: options?.useMultiStep ?? parseBooleanFromText2(String(runtime.getSetting("USE_MULTI_STEP") || "")),
+      maxMultiStepIterations: options?.maxMultiStepIterations ?? parseInt(String(runtime.getSetting("MAX_MULTISTEP_ITERATIONS") || "6")),
+      onStreamChunk: options?.onStreamChunk
     };
     let timeoutId = undefined;
-    const responseId = v4_default();
+    const responseId = asUUID(v4_default());
     try {
       runtime.logger.info({
         src: "service:message",
@@ -45619,19 +45925,19 @@ class DefaultMessageService {
       const startTime = Date.now();
       await runtime.emitEvent("RUN_STARTED" /* RUN_STARTED */, {
         runtime,
+        source: "messageHandler",
         runId,
         messageId: message.id,
         roomId: message.roomId,
         entityId: message.entityId,
         startTime,
-        status: "started",
-        source: "messageHandler",
-        metadata: message.content
+        status: "started"
       });
       const timeoutPromise = new Promise((_, reject) => {
         timeoutId = setTimeout(async () => {
           await runtime.emitEvent("RUN_TIMEOUT" /* RUN_TIMEOUT */, {
             runtime,
+            source: "messageHandler",
             runId,
             messageId: message.id,
             roomId: message.roomId,
@@ -45640,20 +45946,32 @@ class DefaultMessageService {
             status: "timeout",
             endTime: Date.now(),
             duration: Date.now() - startTime,
-            error: "Run exceeded timeout",
-            source: "messageHandler"
+            error: "Run exceeded timeout"
           });
           reject(new Error("Run exceeded timeout"));
         }, opts.timeoutDuration);
       });
-      const processingPromise = this.processMessage(runtime, message, callback, responseId, runId, startTime, opts);
+      let streamingContext;
+      if (opts.onStreamChunk) {
+        const extractor = new ResponseStreamExtractor;
+        streamingContext = {
+          onStreamChunk: async (chunk, msgId) => {
+            if (extractor.done)
+              return;
+            const textToStream = extractor.push(chunk);
+            if (textToStream) {
+              await opts.onStreamChunk(textToStream, msgId);
+            }
+          },
+          messageId: responseId
+        };
+      }
+      const processingPromise = runWithStreamingContext(streamingContext, () => this.processMessage(runtime, message, callback, responseId, runId, startTime, opts));
       const result = await Promise.race([processingPromise, timeoutPromise]);
       clearTimeout(timeoutId);
       return result;
-    } catch (error) {
+    } finally {
       clearTimeout(timeoutId);
-      runtime.logger.error({ src: "service:message", agentId: runtime.agentId, error }, "Error in handleMessage");
-      throw error;
     }
   }
   async processMessage(runtime, message, callback, responseId, runId, startTime, opts) {
@@ -45668,7 +45986,7 @@ class DefaultMessageService {
           didRespond: false,
           responseContent: null,
           responseMessages: [],
-          state: {},
+          state: { values: {}, data: {}, text: "" },
           mode: "none"
         };
       }
@@ -45695,7 +46013,7 @@ class DefaultMessageService {
         await runtime.queueEmbeddingGeneration(memoryToQueue, "normal");
       }
       const agentUserState = await runtime.getParticipantUserState(message.roomId, runtime.agentId);
-      const defLllmOff = parseBooleanFromText2(runtime.getSetting("BOOTSTRAP_DEFLLMOFF"));
+      const defLllmOff = parseBooleanFromText2(String(runtime.getSetting("BOOTSTRAP_DEFLLMOFF") || ""));
       if (defLllmOff && agentUserState === null) {
         runtime.logger.debug({ src: "service:message" }, "LLM is off by default");
         await this.emitRunEnded(runtime, runId, message, startTime, "off");
@@ -45703,7 +46021,7 @@ class DefaultMessageService {
           didRespond: false,
           responseContent: null,
           responseMessages: [],
-          state: {},
+          state: { values: {}, data: {}, text: "" },
           mode: "none"
         };
       }
@@ -45714,7 +46032,7 @@ class DefaultMessageService {
           didRespond: false,
           responseContent: null,
           responseMessages: [],
-          state: {},
+          state: { values: {}, data: {}, text: "" },
           mode: "none"
         };
       }
@@ -45754,13 +46072,14 @@ class DefaultMessageService {
         const responseObject = parseKeyValueXml(response);
         runtime.logger.debug({ src: "service:message", responseObject }, "Parsed evaluation result");
         const nonResponseActions = ["IGNORE", "NONE"];
-        shouldRespondToMessage = responseObject?.action && !nonResponseActions.includes(responseObject.action.toUpperCase());
+        const actionValue = responseObject?.action;
+        shouldRespondToMessage = typeof actionValue === "string" && !nonResponseActions.includes(actionValue.toUpperCase());
       }
       let responseContent = null;
       let responseMessages = [];
       let mode = "none";
       if (shouldRespondToMessage) {
-        const result = opts.useMultiStep ? await this.runMultiStepCore(runtime, message, state, callback, opts) : await this.runSingleShotCore(runtime, message, state, opts);
+        const result = opts.useMultiStep ? await this.runMultiStepCore(runtime, message, state, callback, opts, responseId) : await this.runSingleShotCore(runtime, message, state, opts, responseId);
         responseContent = result.responseContent;
         responseMessages = result.responseMessages;
         state = result.state;
@@ -45798,13 +46117,13 @@ class DefaultMessageService {
                 return callback(content);
               }
               return [];
-            });
+            }, { onStreamChunk: opts.onStreamChunk });
           }
         }
       } else {
         runtime.logger.debug({ src: "service:message" }, "Agent decided not to respond");
         const currentResponseId = agentResponses.get(message.roomId);
-        const keepResp = parseBooleanFromText2(runtime.getSetting("BOOTSTRAP_KEEP_RESP"));
+        const keepResp = parseBooleanFromText2(String(runtime.getSetting("BOOTSTRAP_KEEP_RESP") || ""));
         if (currentResponseId !== responseId && !keepResp) {
           runtime.logger.info({ src: "service:message", agentId: runtime.agentId, roomId: message.roomId }, "Ignore response discarded - newer message being processed");
           await this.emitRunEnded(runtime, runId, message, startTime, "replaced");
@@ -45862,7 +46181,7 @@ class DefaultMessageService {
         return [];
       }, responseMessages);
       let entityName = "noname";
-      if (message.metadata && "entityName" in message.metadata) {
+      if (message.metadata && "entityName" in message.metadata && typeof message.metadata.entityName === "string") {
         entityName = message.metadata.entityName;
       }
       const isDM = message.content?.channelType === "DM" /* DM */;
@@ -45883,7 +46202,10 @@ class DefaultMessageService {
         }
       }
       const date2 = new Date;
-      const availableActions = state.data?.providers?.ACTIONS?.data?.actionsData?.map((a) => a.name) || [-1];
+      const providersData = state.data?.providers;
+      const actionsProvider = typeof providersData === "object" && providersData !== null && "ACTIONS" in providersData ? providersData.ACTIONS : undefined;
+      const actionsData = actionsProvider?.data?.actionsData;
+      const availableActions = Array.isArray(actionsData) ? actionsData.map((a) => a.name) : [-1];
       const logData = {
         at: date2.toString(),
         timestamp: parseInt("" + date2.getTime() / 1000),
@@ -45904,6 +46226,7 @@ class DefaultMessageService {
       };
       await runtime.emitEvent("RUN_ENDED" /* RUN_ENDED */, {
         runtime,
+        source: "messageHandler",
         runId,
         messageId: message.id,
         roomId: message.roomId,
@@ -45911,11 +46234,7 @@ class DefaultMessageService {
         startTime,
         status: "completed",
         endTime: Date.now(),
-        duration: Date.now() - startTime,
-        source: "messageHandler",
-        entityName,
-        responseContent,
-        metadata: logData
+        duration: Date.now() - startTime
       });
       return {
         didRespond: shouldRespondToMessage,
@@ -45925,19 +46244,20 @@ class DefaultMessageService {
         mode
       };
     } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
       runtime.logger.error({ src: "service:message", agentId: runtime.agentId, error }, "Error processing message");
       await runtime.emitEvent("RUN_ENDED" /* RUN_ENDED */, {
         runtime,
+        source: "messageHandler",
         runId,
         messageId: message.id,
         roomId: message.roomId,
         entityId: message.entityId,
         startTime,
-        status: "error",
+        status: "completed",
         endTime: Date.now(),
         duration: Date.now() - startTime,
-        error: error.message,
-        source: "messageHandler"
+        error: errorMessage
       });
       throw error;
     }
@@ -45989,93 +46309,85 @@ class DefaultMessageService {
     runtime.logger.debug({ src: "service:message", count: attachments.length }, "Processing attachments");
     const processedAttachments = [];
     for (const attachment of attachments) {
-      try {
-        const processedAttachment = { ...attachment };
-        const isRemote = /^(http|https):\/\//.test(attachment.url);
-        const url = isRemote ? attachment.url : getLocalServerUrl(attachment.url);
-        if (attachment.contentType === "image" /* IMAGE */ && !attachment.description) {
-          runtime.logger.debug({ src: "service:message", imageUrl: attachment.url }, "Generating image description");
-          let imageUrl = url;
-          if (!isRemote) {
-            const res = await fetch(url);
-            if (!res.ok)
-              throw new Error(`Failed to fetch image: ${res.statusText}`);
-            const arrayBuffer = await res.arrayBuffer();
-            const buffer = Buffer.from(arrayBuffer);
-            const contentType = res.headers.get("content-type") || "application/octet-stream";
-            imageUrl = `data:${contentType};base64,${buffer.toString("base64")}`;
-          }
-          try {
-            const response = await runtime.useModel(ModelType.IMAGE_DESCRIPTION, {
-              prompt: imageDescriptionTemplate,
-              imageUrl
-            });
-            if (typeof response === "string") {
-              const parsedXml = parseKeyValueXml(response);
-              if (parsedXml && (parsedXml.description || parsedXml.text)) {
-                processedAttachment.description = parsedXml.description || "";
-                processedAttachment.title = parsedXml.title || "Image";
-                processedAttachment.text = parsedXml.text || parsedXml.description || "";
-                runtime.logger.debug({
-                  src: "service:message",
-                  descriptionPreview: processedAttachment.description?.substring(0, 100)
-                }, "Generated image description");
-              } else {
-                const responseStr = response;
-                const titleMatch = responseStr.match(/<title>([^<]+)<\/title>/);
-                const descMatch = responseStr.match(/<description>([^<]+)<\/description>/);
-                const textMatch = responseStr.match(/<text>([^<]+)<\/text>/);
-                if (titleMatch || descMatch || textMatch) {
-                  processedAttachment.title = titleMatch?.[1] || "Image";
-                  processedAttachment.description = descMatch?.[1] || "";
-                  processedAttachment.text = textMatch?.[1] || descMatch?.[1] || "";
-                  runtime.logger.debug({
-                    src: "service:message",
-                    descriptionPreview: processedAttachment.description?.substring(0, 100)
-                  }, "Used fallback XML parsing for description");
-                } else {
-                  runtime.logger.warn({ src: "service:message" }, "Failed to parse XML response for image description");
-                }
-              }
-            } else if (response && typeof response === "object" && "description" in response) {
-              processedAttachment.description = response.description;
-              processedAttachment.title = response.title || "Image";
-              processedAttachment.text = response.description;
+      const processedAttachment = { ...attachment };
+      const isRemote = /^(http|https):\/\//.test(attachment.url);
+      const url = isRemote ? attachment.url : getLocalServerUrl(attachment.url);
+      if (attachment.contentType === "image" /* IMAGE */ && !attachment.description) {
+        runtime.logger.debug({ src: "service:message", imageUrl: attachment.url }, "Generating image description");
+        let imageUrl = url;
+        if (!isRemote) {
+          const res = await fetch(url);
+          if (!res.ok)
+            throw new Error(`Failed to fetch image: ${res.statusText}`);
+          const arrayBuffer = await res.arrayBuffer();
+          const buffer = Buffer.from(arrayBuffer);
+          const contentType = res.headers.get("content-type") || "application/octet-stream";
+          imageUrl = `data:${contentType};base64,${buffer.toString("base64")}`;
+        }
+        const response = await runtime.useModel(ModelType.IMAGE_DESCRIPTION, {
+          prompt: imageDescriptionTemplate,
+          imageUrl
+        });
+        if (typeof response === "string") {
+          const parsedXml = parseKeyValueXml(response);
+          if (parsedXml && (parsedXml.description || parsedXml.text)) {
+            processedAttachment.description = (typeof parsedXml.description === "string" ? parsedXml.description : "") || "";
+            processedAttachment.title = (typeof parsedXml.title === "string" ? parsedXml.title : "Image") || "Image";
+            processedAttachment.text = (typeof parsedXml.text === "string" ? parsedXml.text : "") || (typeof parsedXml.description === "string" ? parsedXml.description : "") || "";
+            runtime.logger.debug({
+              src: "service:message",
+              descriptionPreview: processedAttachment.description?.substring(0, 100)
+            }, "Generated image description");
+          } else {
+            const responseStr = response;
+            const titleMatch = responseStr.match(/<title>([^<]+)<\/title>/);
+            const descMatch = responseStr.match(/<description>([^<]+)<\/description>/);
+            const textMatch = responseStr.match(/<text>([^<]+)<\/text>/);
+            if (titleMatch || descMatch || textMatch) {
+              processedAttachment.title = titleMatch?.[1] || "Image";
+              processedAttachment.description = descMatch?.[1] || "";
+              processedAttachment.text = textMatch?.[1] || descMatch?.[1] || "";
               runtime.logger.debug({
                 src: "service:message",
                 descriptionPreview: processedAttachment.description?.substring(0, 100)
-              }, "Generated image description");
+              }, "Used fallback XML parsing for description");
             } else {
-              runtime.logger.warn({ src: "service:message" }, "Unexpected response format for image description");
+              runtime.logger.warn({ src: "service:message" }, "Failed to parse XML response for image description");
             }
-          } catch (error) {
-            runtime.logger.error({ src: "service:message", error }, "Error generating image description");
-          }
-        } else if (attachment.contentType === "document" /* DOCUMENT */ && !attachment.text) {
-          const res = await fetch(url);
-          if (!res.ok)
-            throw new Error(`Failed to fetch document: ${res.statusText}`);
-          const contentType = res.headers.get("content-type") || "";
-          const isPlainText = contentType.startsWith("text/plain");
-          if (isPlainText) {
-            runtime.logger.debug({ src: "service:message", documentUrl: attachment.url }, "Processing plain text document");
-            const textContent = await res.text();
-            processedAttachment.text = textContent;
-            processedAttachment.title = processedAttachment.title || "Text File";
-            runtime.logger.debug({ src: "service:message", textPreview: processedAttachment.text?.substring(0, 100) }, "Extracted text content");
-          } else {
-            runtime.logger.warn({ src: "service:message", contentType }, "Skipping non-plain-text document");
           }
+        } else if (response && typeof response === "object" && "description" in response) {
+          const objResponse = response;
+          processedAttachment.description = objResponse.description;
+          processedAttachment.title = objResponse.title || "Image";
+          processedAttachment.text = objResponse.description;
+          runtime.logger.debug({
+            src: "service:message",
+            descriptionPreview: processedAttachment.description?.substring(0, 100)
+          }, "Generated image description");
+        } else {
+          runtime.logger.warn({ src: "service:message" }, "Unexpected response format for image description");
+        }
+      } else if (attachment.contentType === "document" /* DOCUMENT */ && !attachment.text) {
+        const res = await fetch(url);
+        if (!res.ok)
+          throw new Error(`Failed to fetch document: ${res.statusText}`);
+        const contentType = res.headers.get("content-type") || "";
+        const isPlainText = contentType.startsWith("text/plain");
+        if (isPlainText) {
+          runtime.logger.debug({ src: "service:message", documentUrl: attachment.url }, "Processing plain text document");
+          const textContent = await res.text();
+          processedAttachment.text = textContent;
+          processedAttachment.title = processedAttachment.title || "Text File";
+          runtime.logger.debug({ src: "service:message", textPreview: processedAttachment.text?.substring(0, 100) }, "Extracted text content");
+        } else {
+          runtime.logger.warn({ src: "service:message", contentType }, "Skipping non-plain-text document");
         }
-        processedAttachments.push(processedAttachment);
-      } catch (error) {
-        runtime.logger.error({ src: "service:message", error, attachmentUrl: attachment.url }, "Failed to process attachment");
-        processedAttachments.push(attachment);
       }
+      processedAttachments.push(processedAttachment);
     }
     return processedAttachments;
   }
-  async runSingleShotCore(runtime, message, state, opts) {
+  async runSingleShotCore(runtime, message, state, opts, responseId) {
     state = await runtime.composeState(message, ["ACTIONS"]);
     if (!state.values?.actionNames) {
       runtime.logger.warn({ src: "service:message" }, "actionNames data missing from state");
@@ -46087,25 +46399,54 @@ class DefaultMessageService {
     let responseContent = null;
     let retries = 0;
     while (retries < opts.maxRetries && (!responseContent?.thought || !responseContent?.actions)) {
-      const response = await runtime.useModel(ModelType.TEXT_LARGE, { prompt });
-      runtime.logger.debug({ src: "service:message", response }, "Raw LLM response");
+      const response = await runtime.useModel(ModelType.TEXT_LARGE, {
+        prompt
+      });
+      runtime.logger.info({
+        src: "service:message",
+        responseLength: response.length,
+        responsePreview: response.substring(0, 500)
+      }, "Raw LLM response received");
       const parsedXml = parseKeyValueXml(response);
-      runtime.logger.debug({ src: "service:message", parsedXml }, "Parsed XML content");
+      runtime.logger.info({
+        src: "service:message",
+        parsedXml: parsedXml ? {
+          hasThought: !!parsedXml.thought,
+          thoughtPreview: typeof parsedXml.thought === "string" ? parsedXml.thought.substring(0, 100) : null,
+          hasActions: !!parsedXml.actions,
+          actions: parsedXml.actions,
+          hasText: !!parsedXml.text,
+          textPreview: typeof parsedXml.text === "string" ? parsedXml.text.substring(0, 100) : null
+        } : null
+      }, "Parsed XML content");
       if (parsedXml) {
+        const thought = typeof parsedXml.thought === "string" ? parsedXml.thought : "";
+        const actions = Array.isArray(parsedXml.actions) ? parsedXml.actions.filter((a) => typeof a === "string") : typeof parsedXml.actions === "string" ? [parsedXml.actions] : ["IGNORE"];
+        const providers = Array.isArray(parsedXml.providers) ? parsedXml.providers.filter((p) => typeof p === "string") : [];
+        const text = typeof parsedXml.text === "string" ? parsedXml.text : "";
+        const simple = typeof parsedXml.simple === "boolean" ? parsedXml.simple : false;
         responseContent = {
           ...parsedXml,
-          thought: parsedXml.thought || "",
-          actions: parsedXml.actions || ["IGNORE"],
-          providers: parsedXml.providers || [],
-          text: parsedXml.text || "",
-          simple: parsedXml.simple || false
+          thought,
+          actions,
+          providers,
+          text,
+          simple
         };
       } else {
         responseContent = null;
+        runtime.logger.warn({ src: "service:message", responsePreview: response.substring(0, 300) }, "parseKeyValueXml returned null - XML parsing failed");
       }
       retries++;
       if (!responseContent?.thought || !responseContent?.actions) {
-        runtime.logger.warn({ src: "service:message", retries, maxRetries: opts.maxRetries }, "Missing required fields (thought or actions), retrying");
+        runtime.logger.warn({
+          src: "service:message",
+          retries,
+          maxRetries: opts.maxRetries,
+          hasThought: !!responseContent?.thought,
+          hasActions: !!responseContent?.actions,
+          actionsValue: responseContent?.actions
+        }, "Missing required fields (thought or actions), retrying");
       }
     }
     if (!responseContent) {
@@ -46125,9 +46466,10 @@ class DefaultMessageService {
     }
     const isSimple = responseContent.actions?.length === 1 && typeof responseContent.actions[0] === "string" && responseContent.actions[0].toUpperCase() === "REPLY" && (!responseContent.providers || responseContent.providers.length === 0);
     responseContent.simple = isSimple;
+    responseContent.responseId = responseId;
     const responseMessages = [
       {
-        id: asUUID(v4_default()),
+        id: responseId,
         entityId: runtime.agentId,
         agentId: runtime.agentId,
         content: responseContent,
@@ -46142,7 +46484,7 @@ class DefaultMessageService {
       mode: isSimple && responseContent.text ? "simple" : "actions"
     };
   }
-  async runMultiStepCore(runtime, message, state, callback, opts) {
+  async runMultiStepCore(runtime, message, state, callback, opts, responseId) {
     const traceActionResult = [];
     let accumulatedState = state;
     let iterationCount = 0;
@@ -46173,93 +46515,90 @@ class DefaultMessageService {
         });
         break;
       }
-      const { thought, providers = [], action, isFinish } = parsedStep;
+      const thought = typeof parsedStep.thought === "string" ? parsedStep.thought : undefined;
+      const providers = Array.isArray(parsedStep.providers) ? parsedStep.providers : [];
+      const action = typeof parsedStep.action === "string" ? parsedStep.action : undefined;
+      const isFinish = parsedStep.isFinish;
       if (isFinish === "true" || isFinish === true) {
         runtime.logger.info({ src: "service:message", agentId: runtime.agentId, iteration: iterationCount }, "Multi-step task completed");
         if (callback) {
           await callback({
             text: "",
-            thought: thought ?? ""
+            thought: typeof thought === "string" ? thought : ""
           });
         }
         break;
       }
-      if ((!providers || providers.length === 0) && !action) {
+      const providersArray = Array.isArray(providers) ? providers : [];
+      if ((!providersArray || providersArray.length === 0) && !action) {
         runtime.logger.warn({ src: "service:message", iteration: iterationCount }, "No providers or action specified, forcing completion");
         break;
       }
-      try {
-        for (const providerName of providers) {
-          const provider = runtime.providers.find((p) => p.name === providerName);
-          if (!provider) {
-            runtime.logger.warn({ src: "service:message", providerName }, "Provider not found");
-            traceActionResult.push({
-              data: { actionName: providerName },
-              success: false,
-              error: `Provider not found: ${providerName}`
-            });
-            continue;
-          }
-          const providerResult = await provider.get(runtime, message, state);
-          if (!providerResult) {
-            runtime.logger.warn({ src: "service:message", providerName }, "Provider returned no result");
-            traceActionResult.push({
-              data: { actionName: providerName },
-              success: false,
-              error: `Provider returned no result`
-            });
-            continue;
-          }
-          const success = !!providerResult.text;
+      for (const providerName of providersArray) {
+        if (typeof providerName !== "string")
+          continue;
+        const provider = runtime.providers.find((p) => p.name === providerName);
+        if (!provider) {
+          runtime.logger.warn({ src: "service:message", providerName }, "Provider not found");
           traceActionResult.push({
             data: { actionName: providerName },
-            success,
-            text: success ? providerResult.text : undefined,
-            error: success ? undefined : "Provider returned no result"
+            success: false,
+            error: `Provider not found: ${providerName}`
           });
-          if (callback) {
-            await callback({
-              text: `\uD83D\uDD0E Provider executed: ${providerName}`,
-              actions: [providerName],
-              thought: thought ?? ""
-            });
-          }
+          continue;
         }
-        if (action) {
-          const actionContent = {
-            text: `\uD83D\uDD0E Executing action: ${action}`,
-            actions: [action],
-            thought: thought ?? ""
-          };
-          await runtime.processActions(message, [
-            {
-              id: v4_default(),
-              entityId: runtime.agentId,
-              roomId: message.roomId,
-              createdAt: Date.now(),
-              content: actionContent
-            }
-          ], state, async () => {
-            return [];
-          });
-          const cachedState = runtime.stateCache?.get(`${message.id}_action_results`);
-          const actionResults = cachedState?.values?.actionResults || [];
-          const result = actionResults.length > 0 ? actionResults[0] : null;
-          const success = result?.success ?? false;
+        const providerResult = await provider.get(runtime, message, state);
+        if (!providerResult) {
+          runtime.logger.warn({ src: "service:message", providerName }, "Provider returned no result");
           traceActionResult.push({
-            data: { actionName: action },
-            success,
-            text: result?.text,
-            values: result?.values,
-            error: success ? undefined : result?.text
+            data: { actionName: providerName },
+            success: false,
+            error: `Provider returned no result`
           });
+          continue;
         }
-      } catch (err) {
-        runtime.logger.error({ src: "service:message", agentId: runtime.agentId, error: err }, "Error executing multi-step action");
+        const success = !!providerResult.text;
         traceActionResult.push({
-          data: { actionName: action || "unknown" },
-          success: false,
-          error: err instanceof Error ? err.message : String(err)
+          data: { actionName: providerName },
+          success,
+          text: success ? providerResult.text : undefined,
+          error: success ? undefined : "Provider returned no result"
+        });
+        if (callback) {
+          await callback({
+            text: `\uD83D\uDD0E Provider executed: ${providerName}`,
+            actions: [providerName],
+            thought: typeof thought === "string" ? thought : ""
+          });
+        }
+      }
+      if (action) {
+        const actionContent = {
+          text: `\uD83D\uDD0E Executing action: ${action}`,
+          actions: [action],
+          thought: thought || ""
+        };
+        await runtime.processActions(message, [
+          {
+            id: v4_default(),
+            entityId: runtime.agentId,
+            roomId: message.roomId,
+            createdAt: Date.now(),
+            content: actionContent
+          }
+        ], state, async () => {
+          return [];
+        });
+        const cachedState = runtime.stateCache?.get(`${message.id}_action_results`);
+        const actionResults = Array.isArray(cachedState?.values?.actionResults) ? cachedState.values.actionResults : [];
+        const result = actionResults.length > 0 && typeof actionResults[0] === "object" && actionResults[0] !== null ? actionResults[0] : null;
+        const success = result && "success" in result && typeof result.success === "boolean" ? result.success : false;
+        traceActionResult.push({
+          data: { actionName: typeof action === "string" ? action : "unknown" },
+          success,
+          text: result && "text" in result && typeof result.text === "string" ? result.text : undefined,
+          values: result && "values" in result && typeof result.values === "object" && result.values !== null ? result.values : undefined,
+          error: success ? undefined : result && ("text" in result) && typeof result.text === "string" ? result.text : undefined
         });
       }
     }
@@ -46274,20 +46613,24 @@ class DefaultMessageService {
       state: accumulatedState,
       template: runtime.character.templates?.multiStepSummaryTemplate || multiStepSummaryTemplate
     });
-    const finalOutput = await runtime.useModel(ModelType.TEXT_LARGE, { prompt: summaryPrompt });
+    const finalOutput = await runtime.useModel(ModelType.TEXT_LARGE, {
+      prompt: summaryPrompt
+    });
     const summary = parseKeyValueXml(finalOutput);
     let responseContent = null;
-    if (summary?.text) {
+    const summaryText = summary?.text;
+    if (typeof summaryText === "string" && summaryText) {
       responseContent = {
         actions: ["MULTI_STEP_SUMMARY"],
-        text: summary.text,
-        thought: summary.thought || "Final user-facing message after task completion.",
-        simple: true
+        text: summaryText,
+        thought: (typeof summary.thought === "string" ? summary.thought : "Final user-facing message after task completion.") || "Final user-facing message after task completion.",
+        simple: true,
+        responseId
       };
     }
     const responseMessages = responseContent ? [
       {
-        id: asUUID(v4_default()),
+        id: responseId,
         entityId: runtime.agentId,
         agentId: runtime.agentId,
         content: responseContent,
@@ -46305,6 +46648,7 @@ class DefaultMessageService {
   async emitRunEnded(runtime, runId, message, startTime, status) {
     await runtime.emitEvent("RUN_ENDED" /* RUN_ENDED */, {
       runtime,
+      source: "messageHandler",
       runId,
       messageId: message.id,
       roomId: message.roomId,
@@ -46312,8 +46656,7 @@ class DefaultMessageService {
       startTime,
       status,
       endTime: Date.now(),
-      duration: Date.now() - startTime,
-      source: "messageHandler"
+      duration: Date.now() - startTime
     });
   }
   async deleteMessage(runtime, message) {
@@ -47139,8 +47482,6 @@ class BM25 {
       this.termFrequencies.get(termIndexVal).set(docIndex, freq);
       if (termIndexVal < this.documentFrequency.length) {
         this.documentFrequency[termIndexVal]++;
-      } else {
-        console.error(`Error: termIndexVal ${termIndexVal} is out of bounds for documentFrequency (length ${this.documentFrequency.length}). This indicates an issue with array resizing or term indexing.`);
       }
     });
     this.recalculateAverageLength();
@@ -47311,19 +47652,16 @@ class AgentRuntime {
     this.plugins.push(plugin);
     this.logger.debug({ src: "agent", agentId: this.agentId, plugin: plugin.name }, "Plugin added");
     if (plugin.init) {
-      try {
-        await plugin.init(plugin.config || {}, this);
-        this.logger.debug({ src: "agent", agentId: this.agentId, plugin: plugin.name }, "Plugin initialized");
-      } 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("Please check your environment variables and ensure all required API keys are set.");
-          console.warn("You can set these in your .env file.");
-        } else {
-          throw error;
+      const config = {};
+      if (plugin.config) {
+        for (const [key, value] of Object.entries(plugin.config)) {
+          if (value !== null && value !== undefined) {
+            config[key] = String(value);
+          }
         }
       }
+      await plugin.init(config, this);
+      this.logger.debug({ src: "agent", agentId: this.agentId, plugin: plugin.name }, "Plugin initialized");
     }
     if (plugin.adapter) {
       this.logger.debug({ src: "agent", agentId: this.agentId, plugin: plugin.name }, "Registering database adapter");
@@ -47404,122 +47742,110 @@ class AgentRuntime {
     this.elizaOS = undefined;
   }
   async initialize(options) {
-    try {
-      const pluginRegistrationPromises = [];
-      const pluginsToLoad = this.characterPlugins;
-      for (const plugin of pluginsToLoad) {
-        if (plugin) {
-          pluginRegistrationPromises.push(this.registerPlugin(plugin));
-        }
-      }
-      await Promise.all(pluginRegistrationPromises);
-      if (!this.adapter) {
-        this.logger.error({ src: "agent", agentId: this.agentId }, "Database adapter not initialized");
-        throw new Error("Database adapter not initialized. The SQL plugin (@elizaos/plugin-sql) is required for agent initialization. Please ensure it is included in your character configuration.");
-      }
-      if (!await this.adapter.isReady()) {
-        await this.adapter.init();
+    const pluginRegistrationPromises = [];
+    const pluginsToLoad = this.characterPlugins;
+    for (const plugin of pluginsToLoad) {
+      if (plugin) {
+        pluginRegistrationPromises.push(this.registerPlugin(plugin));
       }
-      this.messageService = new DefaultMessageService;
-      const skipMigrations = options?.skipMigrations ?? false;
-      if (skipMigrations) {
-        this.logger.debug({ src: "agent", agentId: this.agentId }, "Skipping plugin migrations");
-      } else {
-        this.logger.debug({ src: "agent", agentId: this.agentId }, "Running plugin migrations");
-        await this.runPluginMigrations();
-        this.logger.debug({ src: "agent", agentId: this.agentId }, "Plugin migrations completed");
+    }
+    await Promise.all(pluginRegistrationPromises);
+    if (!this.adapter) {
+      this.logger.error({ src: "agent", agentId: this.agentId }, "Database adapter not initialized");
+      throw new Error("Database adapter not initialized. The SQL plugin (@elizaos/plugin-sql) is required for agent initialization. Please ensure it is included in your character configuration.");
+    }
+    if (!await this.adapter.isReady()) {
+      await this.adapter.init();
+    }
+    this.messageService = new DefaultMessageService;
+    const skipMigrations = options?.skipMigrations ?? false;
+    if (skipMigrations) {
+      this.logger.debug({ src: "agent", agentId: this.agentId }, "Skipping plugin migrations");
+    } else {
+      this.logger.debug({ src: "agent", agentId: this.agentId }, "Running plugin migrations");
+      await this.runPluginMigrations();
+      this.logger.debug({ src: "agent", agentId: this.agentId }, "Plugin migrations completed");
+    }
+    const existingAgent = await this.ensureAgentExists({
+      ...this.character,
+      id: this.agentId
+    });
+    if (!existingAgent) {
+      const errorMsg = `Agent ${this.agentId} does not exist in database after ensureAgentExists call`;
+      throw new Error(errorMsg);
+    }
+    if (existingAgent.settings) {
+      this.character.settings = {
+        ...existingAgent.settings,
+        ...this.character.settings
+      };
+      const dbSecrets = existingAgent.settings.secrets && typeof existingAgent.settings.secrets === "object" ? existingAgent.settings.secrets : {};
+      const settingsSecrets = this.character.settings.secrets && typeof this.character.settings.secrets === "object" ? this.character.settings.secrets : {};
+      const characterSecrets = this.character.secrets && typeof this.character.secrets === "object" ? this.character.secrets : {};
+      const mergedSecrets = {
+        ...dbSecrets,
+        ...characterSecrets,
+        ...settingsSecrets
+      };
+      if (Object.keys(mergedSecrets).length > 0) {
+        const filteredSecrets = {};
+        for (const [key, value] of Object.entries(mergedSecrets)) {
+          if (value !== null && value !== undefined) {
+            filteredSecrets[key] = value;
+          }
+        }
+        if (Object.keys(filteredSecrets).length > 0) {
+          this.character.secrets = filteredSecrets;
+          this.character.settings.secrets = filteredSecrets;
+        }
       }
-      const existingAgent = await this.ensureAgentExists({
-        ...this.character,
-        id: this.agentId
+    }
+    let agentEntity = await this.getEntityById(this.agentId);
+    if (!agentEntity) {
+      const created = await this.createEntity({
+        id: this.agentId,
+        names: [this.character.name],
+        metadata: {},
+        agentId: existingAgent.id
       });
-      if (!existingAgent) {
-        const errorMsg = `Agent ${this.agentId} does not exist in database after ensureAgentExists call`;
+      if (!created) {
+        const errorMsg = `Failed to create entity for agent ${this.agentId}`;
         throw new Error(errorMsg);
       }
-      if (existingAgent.settings) {
-        this.character.settings = {
-          ...existingAgent.settings,
-          ...this.character.settings
-        };
-        const dbSecrets = existingAgent.settings.secrets && typeof existingAgent.settings.secrets === "object" ? existingAgent.settings.secrets : {};
-        const settingsSecrets = this.character.settings.secrets && typeof this.character.settings.secrets === "object" ? this.character.settings.secrets : {};
-        const characterSecrets = this.character.secrets && typeof this.character.secrets === "object" ? this.character.secrets : {};
-        const mergedSecrets = {
-          ...dbSecrets,
-          ...characterSecrets,
-          ...settingsSecrets
-        };
-        if (Object.keys(mergedSecrets).length > 0) {
-          this.character.secrets = mergedSecrets;
-          this.character.settings.secrets = mergedSecrets;
-        }
-      }
-      let agentEntity = await this.getEntityById(this.agentId);
-      if (!agentEntity) {
-        const created = await this.createEntity({
-          id: this.agentId,
-          names: [this.character.name],
-          metadata: {},
-          agentId: existingAgent.id
-        });
-        if (!created) {
-          const errorMsg = `Failed to create entity for agent ${this.agentId}`;
-          throw new Error(errorMsg);
-        }
-        agentEntity = await this.getEntityById(this.agentId);
-        if (!agentEntity)
-          throw new Error(`Agent entity not found for ${this.agentId}`);
-        this.logger.debug({ src: "agent", agentId: this.agentId }, "Agent entity created");
-      }
-      const room = await this.getRoom(this.agentId);
-      if (!room) {
-        await this.createRoom({
-          id: this.agentId,
-          name: this.character.name,
-          source: "elizaos",
-          type: "SELF" /* SELF */,
-          channelId: this.agentId,
-          messageServerId: this.agentId,
-          worldId: this.agentId
-        });
-      }
-      const participants = await this.adapter.getParticipantsForRoom(this.agentId);
-      if (!participants.includes(this.agentId)) {
-        const added = await this.addParticipant(this.agentId, this.agentId);
-        if (!added) {
-          throw new Error(`Failed to add agent ${this.agentId} as participant to its own room`);
-        }
-        this.logger.debug({ src: "agent", agentId: this.agentId }, "Agent linked to room");
-      }
-      const embeddingModel = this.getModel(ModelType.TEXT_EMBEDDING);
-      if (!embeddingModel) {
-        this.logger.warn({ src: "agent", agentId: this.agentId }, "No TEXT_EMBEDDING model registered, skipping embedding setup");
-      } else {
-        await this.ensureEmbeddingDimension();
-      }
-      if (this.initResolver) {
-        this.initResolver();
-        this.initResolver = undefined;
-      }
-    } catch (error) {
-      const errorMsg = error instanceof Error ? error.message : String(error);
-      this.logger.error({ src: "agent", agentId: this.agentId, error: errorMsg }, "Runtime initialization failed");
-      if (this.initRejecter) {
-        this.initRejecter(error);
-        this.initRejecter = undefined;
-      }
-      for (const [serviceType, promise] of this.servicePromises) {
-        const handler = this.servicePromiseHandlers.get(serviceType);
-        if (handler) {
-          const serviceError = new Error(`Service ${serviceType} failed to start due to runtime initialization failure: ${errorMsg}`);
-          handler.reject(serviceError);
-          this.servicePromiseHandlers.delete(serviceType);
-          this.servicePromises.delete(serviceType);
-          this.serviceRegistrationStatus.set(serviceType, "failed");
-        }
+      agentEntity = await this.getEntityById(this.agentId);
+      if (!agentEntity)
+        throw new Error(`Agent entity not found for ${this.agentId}`);
+      this.logger.debug({ src: "agent", agentId: this.agentId }, "Agent entity created");
+    }
+    const room = await this.getRoom(this.agentId);
+    if (!room) {
+      await this.createRoom({
+        id: this.agentId,
+        name: this.character.name,
+        source: "elizaos",
+        type: "SELF" /* SELF */,
+        channelId: this.agentId,
+        messageServerId: this.agentId,
+        worldId: this.agentId
+      });
+    }
+    const participants = await this.adapter.getParticipantsForRoom(this.agentId);
+    if (!participants.includes(this.agentId)) {
+      const added = await this.addParticipant(this.agentId, this.agentId);
+      if (!added) {
+        throw new Error(`Failed to add agent ${this.agentId} as participant to its own room`);
       }
-      throw error;
+      this.logger.debug({ src: "agent", agentId: this.agentId }, "Agent linked to room");
+    }
+    const embeddingModel = this.getModel(ModelType.TEXT_EMBEDDING);
+    if (!embeddingModel) {
+      this.logger.warn({ src: "agent", agentId: this.agentId }, "No TEXT_EMBEDDING model registered, skipping embedding setup");
+    } else {
+      await this.ensureEmbeddingDimension();
+    }
+    if (this.initResolver) {
+      this.initResolver();
+      this.initResolver = undefined;
     }
   }
   async runPluginMigrations() {
@@ -47531,29 +47857,29 @@ class AgentRuntime {
       this.logger.warn({ src: "agent", agentId: this.agentId }, "Database adapter does not support plugin migrations");
       return;
     }
-    const pluginsWithSchemas = this.plugins.filter((p) => p.schema).map((p) => ({ name: p.name, schema: p.schema }));
+    const pluginsWithSchemas = this.plugins.filter((p) => p.schema).map((p) => {
+      const schema = p.schema || {};
+      const normalizedSchema = {};
+      for (const [key, value] of Object.entries(schema)) {
+        if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value === null || typeof value === "object" && value !== null && !Array.isArray(value)) {
+          normalizedSchema[key] = value;
+        }
+      }
+      return { name: p.name, schema: normalizedSchema };
+    });
     if (pluginsWithSchemas.length === 0) {
       this.logger.debug({ src: "agent", agentId: this.agentId }, "No plugins with schemas, skipping migrations");
       return;
     }
     this.logger.debug({ src: "agent", agentId: this.agentId, count: pluginsWithSchemas.length }, "Found plugins with schemas");
-    try {
-      const isProduction = false;
-      const forceDestructive = process.env.ELIZA_ALLOW_DESTRUCTIVE_MIGRATIONS === "true";
-      await this.adapter.runPluginMigrations(pluginsWithSchemas, {
-        verbose: !isProduction,
-        force: forceDestructive,
-        dryRun: false
-      });
-      this.logger.debug({ src: "agent", agentId: this.agentId }, "Plugin migrations completed");
-    } catch (error) {
-      this.logger.error({
-        src: "agent",
-        agentId: this.agentId,
-        error: error instanceof Error ? error.message : String(error)
-      }, "Plugin migrations failed");
-      throw error;
-    }
+    const isProduction = false;
+    const forceDestructive = process.env.ELIZA_ALLOW_DESTRUCTIVE_MIGRATIONS === "true";
+    await this.adapter.runPluginMigrations(pluginsWithSchemas, {
+      verbose: !isProduction,
+      force: forceDestructive,
+      dryRun: false
+    });
+    this.logger.debug({ src: "agent", agentId: this.agentId }, "Plugin migrations completed");
   }
   async getConnection() {
     if (!this.adapter) {
@@ -47566,22 +47892,41 @@ class AgentRuntime {
       if (!this.character.secrets) {
         this.character.secrets = {};
       }
-      this.character.secrets[key] = value;
+      if (value !== null && value !== undefined) {
+        this.character.secrets[key] = value;
+      }
     } else {
       if (!this.character.settings) {
         this.character.settings = {};
       }
-      this.character.settings[key] = value;
+      if (value !== null && value !== undefined) {
+        this.character.settings[key] = value;
+      }
     }
   }
   getSetting(key) {
-    const value = this.character.secrets?.[key] || this.character.settings?.[key] || typeof this.character.settings === "object" && this.character.settings !== null && "secrets" in this.character.settings && this.character.settings.secrets?.[key] || this.settings[key];
-    const decryptedValue = decryptStringValue(value, getSalt());
-    if (decryptedValue === "true")
-      return true;
-    if (decryptedValue === "false")
-      return false;
-    return decryptedValue || null;
+    const settings = this.character.settings;
+    const secrets = this.character.secrets;
+    const nestedSecrets = typeof settings === "object" && settings !== null && "secrets" in settings && typeof settings.secrets === "object" && settings.secrets !== null ? settings.secrets : undefined;
+    const value = secrets?.[key] || settings?.[key] || nestedSecrets?.[key] || this.settings[key];
+    if (value === undefined || value === null) {
+      return null;
+    }
+    if (typeof value === "number") {
+      return value;
+    }
+    if (typeof value === "boolean") {
+      return value;
+    }
+    if (typeof value === "string") {
+      const decrypted = decryptStringValue(value, getSalt());
+      if (decrypted === "true")
+        return true;
+      if (decrypted === "false")
+        return false;
+      return decrypted;
+    }
+    return null;
   }
   getConversationLength() {
     return this.#conversationLength;
@@ -47622,7 +47967,7 @@ class AgentRuntime {
       steps: plan.steps.map((step, i) => i === index ? { ...step, ...stepUpdates } : step)
     };
   }
-  async processActions(message, responses, state, callback) {
+  async processActions(message, responses, state, callback, processOptions) {
     const allActions = [];
     for (const response of responses) {
       if (response.content?.actions && response.content.actions.length > 0) {
@@ -47632,7 +47977,7 @@ class AgentRuntime {
     const hasMultipleActions = allActions.length > 1;
     const parentRunId = this.getCurrentRunId();
     const runId = this.createRunId();
-    let actionPlan = null;
+    let actionPlan = undefined;
     const thought = responses[0]?.content?.thought || `Executing ${allActions.length} actions: ${allActions.join(", ")}`;
     if (hasMultipleActions) {
       actionPlan = {
@@ -47707,7 +48052,7 @@ class AgentRuntime {
               error: errorMsg
             });
           }
-          const actionMemory = {
+          const actionMemory2 = {
             id: v4_default(),
             entityId: message.entityId,
             roomId: message.roomId,
@@ -47721,7 +48066,7 @@ class AgentRuntime {
               runId
             }
           };
-          await this.createMemory(actionMemory, "messages");
+          await this.createMemory(actionMemory2, "messages");
           actionIndex++;
           continue;
         }
@@ -47736,255 +48081,214 @@ class AgentRuntime {
           actionIndex++;
           continue;
         }
-        try {
-          this.logger.debug({ src: "agent", agentId: this.agentId, action: action.name }, "Executing action");
-          const actionId = v4_default();
-          this.currentActionContext = {
-            actionName: action.name,
-            actionId,
-            prompts: []
-          };
-          const actionContext = {
-            previousResults: actionResults,
-            getPreviousResult: (actionName) => {
-              return actionResults.find((r) => r.data?.actionName === actionName);
-            }
-          };
-          const options = {
-            actionContext
+        this.logger.debug({ src: "agent", agentId: this.agentId, action: action.name }, "Executing action");
+        const actionId = v4_default();
+        const responseMessageId = v4_default();
+        this.currentActionContext = {
+          actionName: action.name,
+          actionId,
+          prompts: []
+        };
+        const actionContext = {
+          previousResults: actionResults,
+          getPreviousResult: (actionName) => {
+            return actionResults.find((r) => r.data?.actionName === actionName);
+          }
+        };
+        const options = {
+          actionContext
+        };
+        if (actionPlan) {
+          options.actionPlan = {
+            totalSteps: actionPlan.totalSteps,
+            currentStep: actionPlan.currentStep,
+            steps: actionPlan.steps,
+            thought: actionPlan.thought
           };
-          if (actionPlan) {
-            options.actionPlan = {
-              totalSteps: actionPlan.totalSteps,
-              currentStep: actionPlan.currentStep,
-              steps: actionPlan.steps,
-              thought: actionPlan.thought
-            };
+        }
+        if (processOptions?.onStreamChunk) {
+          options.onStreamChunk = processOptions.onStreamChunk;
+        }
+        await this.emitEvent("ACTION_STARTED" /* ACTION_STARTED */, {
+          messageId: actionId,
+          roomId: message.roomId,
+          world: message.worldId,
+          content: {
+            text: `Executing action: ${action.name}`,
+            actions: [action.name],
+            actionStatus: "executing",
+            actionId,
+            runId,
+            type: "agent_action",
+            thought,
+            source: message.content?.source
           }
-          try {
-            await this.emitEvent("ACTION_STARTED" /* ACTION_STARTED */, {
-              messageId: actionId,
-              roomId: message.roomId,
-              world: message.worldId,
-              content: {
-                text: `Executing action: ${action.name}`,
-                actions: [action.name],
-                actionStatus: "executing",
-                actionId,
-                runId,
-                type: "agent_action",
-                thought,
-                source: message.content?.source
+        });
+        let storedCallbackData = [];
+        const storageCallback = async (response2) => {
+          response2.responseId = responseMessageId;
+          storedCallbackData.push(response2);
+          return [];
+        };
+        let actionStreamingContext;
+        if (processOptions?.onStreamChunk) {
+          let currentFilter = null;
+          actionStreamingContext = {
+            messageId: responseMessageId,
+            onStreamChunk: async (chunk, msgId) => {
+              if (!currentFilter) {
+                currentFilter = new ActionStreamFilter;
               }
-            });
-          } catch (error) {
-            this.logger.error({ src: "agent", agentId: this.agentId, action: action.name, error: String(error) }, "Failed to emit action start event");
-          }
-          let storedCallbackData = [];
-          const storageCallback = async (response2) => {
-            storedCallbackData.push(response2);
-            return [];
-          };
-          const result = await action.handler(this, message, accumulatedState, options, storageCallback, responses);
-          const isLegacyReturn = result === undefined || result === null || typeof result === "boolean";
-          let actionResult = null;
-          if (!isLegacyReturn) {
-            if (typeof result === "object" && result !== null && (("values" in result) || ("data" in result) || ("text" in result))) {
-              actionResult = {
-                ...result,
-                success: "success" in result ? result.success : true
-              };
-            } else {
-              actionResult = {
-                success: true,
-                data: {
-                  actionName: action.name,
-                  legacyResult: result
-                }
-              };
-            }
-            actionResults.push(actionResult);
-            if (actionResult.values) {
-              accumulatedState = {
-                ...accumulatedState,
-                values: { ...accumulatedState.values, ...actionResult.values },
-                data: {
-                  ...accumulatedState.data || {},
-                  actionResults: [...accumulatedState.data?.actionResults || [], actionResult],
-                  actionPlan
-                }
-              };
+              const textToStream = currentFilter.push(chunk);
+              if (textToStream) {
+                await processOptions.onStreamChunk(textToStream, msgId);
+              }
+            },
+            onStreamEnd: () => {
+              currentFilter = null;
             }
-            if (actionResult && accumulatedState.data) {
-              if (!accumulatedState.data.workingMemory)
-                accumulatedState.data.workingMemory = {};
-              const memoryKey = `action_${responseAction}_${v4_default()}`;
-              const memoryEntry = {
+          };
+        }
+        const result = await runWithStreamingContext(actionStreamingContext, () => action.handler(this, message, accumulatedState, options, storageCallback, responses));
+        const isLegacyReturn = result === undefined || result === null || typeof result === "boolean";
+        let actionResult = null;
+        if (!isLegacyReturn) {
+          if (typeof result === "object" && result !== null && (("values" in result) || ("data" in result) || ("text" in result))) {
+            actionResult = {
+              ...result,
+              success: "success" in result ? result.success : true
+            };
+          } else {
+            actionResult = {
+              success: true,
+              data: {
                 actionName: action.name,
-                result: actionResult,
-                timestamp: Date.now()
-              };
-              accumulatedState.data.workingMemory[memoryKey] = memoryEntry;
-              const entries = Object.entries(accumulatedState.data.workingMemory);
-              if (entries.length > this.maxWorkingMemoryEntries) {
-                const sorted = entries.sort((a, b) => {
-                  const entryA = a[1];
-                  const entryB = b[1];
-                  const timestampA = entryA?.timestamp ?? 0;
-                  const timestampB = entryB?.timestamp ?? 0;
-                  return timestampB - timestampA;
-                });
-                accumulatedState.data.workingMemory = Object.fromEntries(sorted.slice(0, this.maxWorkingMemoryEntries));
+                legacyResult: result
               }
-            }
-            if (actionPlan && actionPlan.steps[actionIndex]) {
-              actionPlan = this.updateActionStep(actionPlan, actionIndex, {
-                status: "completed",
-                result: actionResult
-              });
-            }
+            };
           }
-          try {
-            const isSuccess = actionResult?.success !== false;
-            const statusText = isSuccess ? "completed" : "failed";
-            await this.emitEvent("ACTION_COMPLETED" /* ACTION_COMPLETED */, {
-              messageId: actionId,
-              roomId: message.roomId,
-              world: message.worldId,
-              content: {
-                text: `Action ${action.name} ${statusText}`,
-                actions: [action.name],
-                actionStatus: statusText,
-                actionId,
-                type: "agent_action",
-                thought,
-                actionResult,
-                source: message.content?.source
+          actionResults.push(actionResult);
+          if (actionResult.values) {
+            const existingActionResults = Array.isArray(accumulatedState.data?.actionResults) ? accumulatedState.data.actionResults : [];
+            accumulatedState = {
+              ...accumulatedState,
+              values: { ...accumulatedState.values, ...actionResult.values },
+              data: {
+                ...accumulatedState.data || {},
+                actionResults: [...existingActionResults, actionResult],
+                actionPlan
               }
-            });
-          } catch (error) {
-            this.logger.error({
-              src: "agent",
-              agentId: this.agentId,
-              action: action.name,
-              error: error instanceof Error ? error.message : String(error)
-            }, "Failed to emit ACTION_COMPLETED event");
-          }
-          if (callback) {
-            for (const content of storedCallbackData) {
-              await callback(content);
-            }
+            };
           }
-          const actionMemory = {
-            id: actionId,
-            entityId: this.agentId,
-            roomId: message.roomId,
-            worldId: message.worldId,
-            content: {
-              text: actionResult?.text || `Executed action: ${action.name}`,
-              source: "action",
-              type: "action_result",
-              actionName: action.name,
-              actionStatus: actionResult?.success ? "completed" : "failed",
-              actionResult: isLegacyReturn ? { legacy: result } : actionResult,
-              runId,
-              ...actionPlan && {
-                planStep: `${actionPlan.currentStep}/${actionPlan.totalSteps}`,
-                planThought: actionPlan.thought
-              }
-            },
-            metadata: {
-              type: "action_result",
+          if (actionResult && accumulatedState.data) {
+            if (!accumulatedState.data.workingMemory)
+              accumulatedState.data.workingMemory = {};
+            const responseAction2 = actionResult.data?.actionName || action.name;
+            const memoryKey = `action_${responseAction2}_${v4_default()}`;
+            const memoryEntry = {
               actionName: action.name,
-              runId,
-              parentRunId,
-              actionId,
-              ...actionPlan && {
-                totalSteps: actionPlan.totalSteps,
-                currentStep: actionPlan.currentStep
-              }
-            }
-          };
-          await this.createMemory(actionMemory, "messages");
-          this.logger.debug({ src: "agent", agentId: this.agentId, action: action.name }, "Action completed");
-          await this.adapter.log({
-            entityId: message.entityId,
-            roomId: message.roomId,
-            type: "action",
-            body: {
-              action: action.name,
-              actionId,
-              message: message.content.text,
-              messageId: message.id,
-              state: accumulatedState,
-              responses,
-              result: isLegacyReturn ? { legacy: result } : actionResult,
-              isLegacyReturn,
-              prompts: this.currentActionContext?.prompts || [],
-              promptCount: this.currentActionContext?.prompts.length || 0,
-              runId,
-              parentRunId,
-              ...actionPlan && {
-                planStep: `${actionPlan.currentStep}/${actionPlan.totalSteps}`,
-                planThought: actionPlan.thought
-              }
+              result: actionResult,
+              timestamp: Date.now()
+            };
+            const workingMemory = accumulatedState.data.workingMemory;
+            workingMemory[memoryKey] = memoryEntry;
+            const entries = Object.entries(workingMemory);
+            if (entries.length > this.maxWorkingMemoryEntries) {
+              const sorted = entries.sort((a, b) => {
+                const entryA = a[1];
+                const entryB = b[1];
+                const timestampA = entryA?.timestamp ?? 0;
+                const timestampB = entryB?.timestamp ?? 0;
+                return timestampB - timestampA;
+              });
+              accumulatedState.data.workingMemory = Object.fromEntries(sorted.slice(0, this.maxWorkingMemoryEntries));
             }
-          });
-          this.currentActionContext = undefined;
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          this.logger.error({ src: "agent", agentId: this.agentId, action: action.name, error: errorMessage }, "Action execution failed");
+          }
           if (actionPlan && actionPlan.steps[actionIndex]) {
             actionPlan = this.updateActionStep(actionPlan, actionIndex, {
-              status: "failed",
-              error: errorMessage
+              status: "completed",
+              result: actionResult
             });
           }
-          this.currentActionContext = undefined;
-          const errorResult = {
-            success: false,
-            data: {
-              actionName: action.name,
-              error: errorMessage,
-              errorObject: error
+        }
+        const isSuccess = actionResult?.success !== false;
+        const statusText = isSuccess ? "completed" : "failed";
+        await this.emitEvent("ACTION_COMPLETED" /* ACTION_COMPLETED */, {
+          messageId: actionId,
+          roomId: message.roomId,
+          world: message.worldId,
+          content: {
+            text: actionResult?.text || "",
+            actions: [action.name],
+            actionStatus: statusText,
+            actionId,
+            type: "agent_action",
+            thought,
+            actionResult,
+            source: message.content?.source
+          }
+        });
+        if (callback) {
+          for (const content of storedCallbackData) {
+            await callback(content);
+          }
+        }
+        const actionMemory = {
+          id: actionId,
+          entityId: this.agentId,
+          roomId: message.roomId,
+          worldId: message.worldId,
+          content: {
+            text: actionResult?.text || `Executed action: ${action.name}`,
+            source: "action",
+            type: "action_result",
+            actionName: action.name,
+            actionStatus: actionResult?.success ? "completed" : "failed",
+            actionResult: isLegacyReturn ? { legacy: result } : actionResult,
+            runId,
+            ...actionPlan && {
+              planStep: `${actionPlan.currentStep}/${actionPlan.totalSteps}`,
+              planThought: actionPlan.thought
             }
-          };
-          actionResults.push(errorResult);
-          const actionMemory = {
-            id: v4_default(),
-            content: {
-              thought: errorMessage,
-              source: "auto",
-              type: "action_result",
-              actionName: action.name,
-              actionStatus: "failed",
-              error: errorMessage,
-              runId,
-              ...actionPlan && {
-                planStep: `${actionPlan.currentStep}/${actionPlan.totalSteps}`,
-                planThought: actionPlan.thought
-              }
-            },
-            entityId: this.agentId,
-            roomId: message.roomId,
-            worldId: message.worldId,
-            metadata: {
-              type: "action_result",
-              actionName: action.name,
-              runId,
-              parentRunId,
-              error: true,
-              ...actionPlan && {
-                totalSteps: actionPlan.totalSteps,
-                currentStep: actionPlan.currentStep
-              }
+          },
+          metadata: {
+            type: "action_result",
+            actionName: action.name,
+            runId,
+            parentRunId,
+            actionId,
+            ...actionPlan && {
+              totalSteps: actionPlan.totalSteps,
+              currentStep: actionPlan.currentStep
             }
-          };
-          await this.createMemory(actionMemory, "messages");
-          if (error?.critical || error?.code === "CRITICAL_ERROR") {
-            throw error;
           }
-        }
+        };
+        await this.createMemory(actionMemory, "messages");
+        this.logger.debug({ src: "agent", agentId: this.agentId, action: action.name }, "Action completed");
+        await this.adapter.log({
+          entityId: message.entityId,
+          roomId: message.roomId,
+          type: "action",
+          body: {
+            action: action.name,
+            actionId,
+            message: message.content.text,
+            messageId: message.id,
+            state: accumulatedState,
+            responses,
+            result: isLegacyReturn ? { legacy: result } : actionResult,
+            isLegacyReturn,
+            prompts: this.currentActionContext?.prompts || [],
+            promptCount: this.currentActionContext?.prompts.length || 0,
+            runId,
+            parentRunId,
+            ...actionPlan && {
+              planStep: `${actionPlan.currentStep}/${actionPlan.totalSteps}`,
+              planThought: actionPlan.thought
+            }
+          }
+        });
+        this.currentActionContext = undefined;
         actionIndex++;
       }
       if (message.id) {
@@ -48001,81 +48305,49 @@ class AgentRuntime {
     return cachedState?.data?.actionResults || [];
   }
   async evaluate(message, state, didRespond, callback, responses) {
-    try {
-      const evaluatorPromises = this.evaluators.map(async (evaluator) => {
-        try {
-          if (!evaluator.handler) {
-            return null;
-          }
-          if (!didRespond && !evaluator.alwaysRun) {
-            return null;
-          }
-          const result = await evaluator.validate(this, message, state);
-          if (result) {
-            return evaluator;
-          }
-          return null;
-        } catch (error) {
-          this.logger.error({
-            src: "agent",
-            agentId: this.agentId,
-            evaluator: evaluator.name,
-            error: error instanceof Error ? error.message : String(error)
-          }, "Evaluator validation failed");
-          return null;
-        }
-      });
-      const evaluators = (await Promise.all(evaluatorPromises)).filter(Boolean);
-      if (evaluators.length === 0) {
-        return [];
+    const evaluatorPromises = this.evaluators.map(async (evaluator) => {
+      if (!evaluator.handler) {
+        return null;
       }
-      state = await this.composeState(message, ["RECENT_MESSAGES", "EVALUATORS"]);
-      await Promise.all(evaluators.map(async (evaluator) => {
-        try {
-          if (evaluator.handler) {
-            await evaluator.handler(this, message, state, {}, callback, responses);
-            this.adapter.log({
-              entityId: message.entityId,
-              roomId: message.roomId,
-              type: "evaluator",
-              body: {
-                evaluator: evaluator.name,
-                messageId: message.id,
-                message: message.content.text,
-                state,
-                runId: this.getCurrentRunId()
-              }
-            });
-          }
-        } catch (error) {
-          this.logger.error({
-            src: "agent",
-            agentId: this.agentId,
-            evaluator: evaluator.name,
-            error: error instanceof Error ? error.message : String(error)
-          }, "Evaluator execution failed");
-        }
-      }));
-      return evaluators;
-    } catch (error) {
-      this.logger.error({
-        src: "agent",
-        agentId: this.agentId,
-        messageId: message.id,
-        channelId: message.roomId,
-        error: error instanceof Error ? error.message : String(error)
-      }, "Evaluate method failed");
+      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 [];
     }
+    state = await this.composeState(message, ["RECENT_MESSAGES", "EVALUATORS"]);
+    await Promise.all(evaluators.map(async (evaluator) => {
+      if (evaluator.handler) {
+        await evaluator.handler(this, message, state, {}, callback, responses);
+        this.adapter.log({
+          entityId: message.entityId,
+          roomId: message.roomId,
+          type: "evaluator",
+          body: {
+            evaluator: evaluator.name,
+            messageId: message.id,
+            message: message.content.text,
+            state,
+            runId: this.getCurrentRunId()
+          }
+        });
+      }
+    }));
+    return evaluators;
   }
   async ensureConnections(entities, rooms, source, world) {
     if (!entities) {
-      console.trace();
       this.logger.error({ src: "agent", agentId: this.agentId }, "ensureConnections called without entities");
       return;
     }
     if (!rooms || rooms.length === 0) {
-      console.trace();
       this.logger.error({ src: "agent", agentId: this.agentId }, "ensureConnections called without rooms");
       return;
     }
@@ -48099,13 +48371,13 @@ class AgentRuntime {
     };
     if (roomsToCreate.length) {
       this.logger.debug({ src: "agent", agentId: this.agentId, count: roomsToCreate.length }, "Creating rooms");
-      const roomObjsToCreate = rooms.filter((r2) => roomsToCreate.includes(r2.id)).map((r2) => ({ ...r2, ...rf }));
+      const roomObjsToCreate = rooms.filter((r2) => roomsToCreate.includes(r2.id)).map((r2) => ({ ...r2, ...rf, type: r2.type || "GROUP" /* GROUP */ }));
       await this.createRooms(roomObjsToCreate);
     }
-    const entityIds = entities.map((e) => e.id);
+    const entityIds = entities.map((e) => e.id).filter((id) => id !== undefined);
     const entityExistsCheck = await this.adapter.getEntitiesByIds(entityIds);
-    const entitiesToUpdate = entityExistsCheck?.map((e) => e.id);
-    const entitiesToCreate = entities.filter((e) => !entitiesToUpdate?.includes(e.id));
+    const entitiesToUpdate = entityExistsCheck?.map((e) => e.id).filter((id) => id !== undefined) || [];
+    const entitiesToCreate = entities.filter((e) => e.id !== undefined && !entitiesToUpdate.includes(e.id));
     const r = {
       roomId: firstRoom.id,
       channelId: firstRoom.channelId,
@@ -48123,7 +48395,11 @@ class AgentRuntime {
         source,
         agentId: this.agentId
       };
-      const entitiesToCreateWFields = entitiesToCreate.map((e) => ({ ...e, ...ef }));
+      const entitiesToCreateWFields = entitiesToCreate.map((e) => ({
+        ...e,
+        ...ef,
+        metadata: e.metadata || {}
+      }));
       const batches = chunkArray(entitiesToCreateWFields, 5000);
       for (const batch of batches) {
         await this.createEntities(batch);
@@ -48131,7 +48407,7 @@ class AgentRuntime {
     }
     await this.ensureParticipantInRoom(this.agentId, firstRoom.id);
     const entityIdsInFirstRoom = await this.getParticipantsForRoom(firstRoom.id);
-    const entityIdsInFirstRoomFiltered = entityIdsInFirstRoom.filter(Boolean);
+    const entityIdsInFirstRoomFiltered = entityIdsInFirstRoom.filter((id) => id !== undefined);
     const missingIdsInRoom = entityIds.filter((id) => !entityIdsInFirstRoomFiltered.includes(id));
     if (missingIdsInRoom.length) {
       this.logger.debug({
@@ -48172,85 +48448,54 @@ class AgentRuntime {
         userName
       }
     };
-    try {
-      const entity = await this.getEntityById(entityId);
-      if (!entity) {
-        try {
-          const success = await this.createEntity({
-            id: entityId,
-            names: names3,
-            metadata: entityMetadata,
-            agentId: this.agentId
-          });
-          if (success) {
-            this.logger.debug({ src: "agent", agentId: this.agentId, entityId, userName: name || userName }, "Entity created");
-          } else {
-            throw new Error(`Failed to create entity ${entityId}`);
-          }
-        } catch (error) {
-          if (error.message?.includes("duplicate key") || error.code === "23505") {
-            this.logger.debug({ src: "agent", agentId: this.agentId, entityId }, "Entity exists in database (multi-agent setup)");
-          } else {
-            throw error;
-          }
-        }
+    const entity = await this.getEntityById(entityId);
+    if (!entity) {
+      const success = await this.createEntity({
+        id: entityId,
+        names: names3,
+        metadata: entityMetadata,
+        agentId: this.agentId
+      });
+      if (success) {
+        this.logger.debug({ src: "agent", agentId: this.agentId, entityId, userName: name || userName }, "Entity created");
       } else {
-        await this.adapter.updateEntity({
-          id: entityId,
-          names: [...new Set([...entity.names || [], ...names3])].filter(Boolean),
-          metadata: {
-            ...entity.metadata,
-            [source]: {
-              ...entity.metadata?.[source],
-              id: userId,
-              name,
-              userName
-            }
-          },
-          agentId: this.agentId
-        });
+        throw new Error(`Failed to create entity ${entityId}`);
       }
-      await this.ensureWorldExists({
-        id: worldId,
-        name: worldName || messageServerId ? `World for server ${messageServerId}` : `World for room ${roomId}`,
-        agentId: this.agentId,
-        messageServerId,
-        metadata
-      });
-      await this.ensureRoomExists({
-        id: roomId,
-        name: name || "default",
-        source: source || "default",
-        type: type || "DM" /* DM */,
-        channelId,
-        messageServerId,
-        worldId
-      });
-      try {
-        await this.ensureParticipantInRoom(entityId, roomId);
-      } catch (error) {
-        if (error.message?.includes("not found")) {
-          const added = await this.addParticipant(entityId, roomId);
-          if (!added) {
-            throw new Error(`Failed to add participant ${entityId} to room ${roomId}`);
+    } else {
+      await this.adapter.updateEntity({
+        id: entityId,
+        names: [...new Set([...entity.names || [], ...names3])].filter(Boolean),
+        metadata: {
+          ...entity.metadata,
+          [source]: {
+            ...entity.metadata?.[source] && typeof entity.metadata[source] === "object" ? entity.metadata[source] : {},
+            id: userId,
+            name,
+            userName
           }
-          this.logger.debug({ src: "agent", agentId: this.agentId, entityId, channelId: roomId }, "Participant added");
-        } else {
-          throw error;
-        }
-      }
-      await this.ensureParticipantInRoom(this.agentId, roomId);
-      this.logger.debug({ src: "agent", agentId: this.agentId, entityId, channelId: roomId }, "Entity connected");
-    } catch (error) {
-      this.logger.error({
-        src: "agent",
-        agentId: this.agentId,
-        entityId,
-        channelId: roomId,
-        error: error instanceof Error ? error.message : String(error)
-      }, "Connection setup failed");
-      throw error;
+        },
+        agentId: this.agentId
+      });
     }
+    await this.ensureWorldExists({
+      id: worldId,
+      name: worldName || messageServerId ? `World for server ${messageServerId}` : `World for room ${roomId}`,
+      agentId: this.agentId,
+      messageServerId,
+      metadata
+    });
+    await this.ensureRoomExists({
+      id: roomId,
+      name: name || "default",
+      source: source || "default",
+      type: type || "DM" /* DM */,
+      channelId,
+      messageServerId,
+      worldId
+    });
+    await this.ensureParticipantInRoom(entityId, roomId);
+    await this.ensureParticipantInRoom(this.agentId, roomId);
+    this.logger.debug({ src: "agent", agentId: this.agentId, entityId, channelId: roomId }, "Entity connected");
   }
   async ensureParticipantInRoom(entityId, roomId) {
     const entity = await this.getEntityById(entityId);
@@ -48354,29 +48599,26 @@ class AgentRuntime {
     const providersToGet = Array.from(new Set(this.providers.filter((p) => providerNames.has(p.name)))).sort((a, b) => (a.position || 0) - (b.position || 0));
     const providerData = await Promise.all(providersToGet.map(async (provider) => {
       const start = Date.now();
-      try {
-        const result = await provider.get(this, message, cachedState);
-        const duration = Date.now() - start;
-        if (duration > 100) {
-          this.logger.debug({ src: "agent", agentId: this.agentId, provider: provider.name, duration }, "Slow provider");
-        }
-        return {
-          ...result,
-          providerName: provider.name
-        };
-      } catch (error) {
-        console.error("provider error", provider.name, error);
-        return { values: {}, text: "", data: {}, providerName: provider.name };
+      const result = await provider.get(this, message, cachedState);
+      const duration = Date.now() - start;
+      if (duration > 100) {
+        this.logger.debug({ src: "agent", agentId: this.agentId, provider: provider.name, duration }, "Slow provider");
       }
+      return {
+        ...result,
+        providerName: provider.name
+      };
     }));
-    const currentProviderResults = { ...cachedState.data?.providers || {} };
+    const currentProviderResults = {
+      ...cachedState.data?.providers || {}
+    };
     for (const freshResult of providerData) {
       currentProviderResults[freshResult.providerName] = freshResult;
     }
     const orderedTexts = [];
     for (const provider of providersToGet) {
       const result = currentProviderResults[provider.name];
-      if (result && result.text && result.text.trim() !== "") {
+      if (result && result.text && typeof result.text === "string" && result.text.trim() !== "") {
         orderedTexts.push(result.text);
       }
     }
@@ -48385,14 +48627,14 @@ class AgentRuntime {
     const aggregatedStateValues = { ...cachedState.values || {} };
     for (const provider of providersToGet) {
       const providerResult = currentProviderResults[provider.name];
-      if (providerResult && providerResult.values && typeof providerResult.values === "object") {
+      if (providerResult && providerResult.values && typeof providerResult.values === "object" && providerResult.values !== null) {
         Object.assign(aggregatedStateValues, providerResult.values);
       }
     }
     for (const providerName in currentProviderResults) {
       if (!providersToGet.some((p) => p.name === providerName)) {
         const providerResult = currentProviderResults[providerName];
-        if (providerResult && providerResult.values && typeof providerResult.values === "object") {
+        if (providerResult && providerResult.values && typeof providerResult.values === "object" && providerResult.values !== null) {
           Object.assign(aggregatedStateValues, providerResult.values);
         }
       }
@@ -48471,73 +48713,40 @@ class AgentRuntime {
     }
     this.logger.debug({ src: "agent", agentId: this.agentId, serviceType }, "Registering service");
     this.serviceRegistrationStatus.set(serviceType, "registering");
-    try {
-      this.logger.debug({ src: "agent", agentId: this.agentId, serviceType }, "Service waiting for init");
-      const initTimeout = new Promise((_, reject) => {
-        setTimeout(() => {
-          reject(new Error(`Service ${serviceType} registration timed out waiting for runtime initialization (30s timeout)`));
-        }, 30000);
-      });
-      await Promise.race([this.initPromise, initTimeout]);
-      if (typeof serviceDef.start !== "function") {
-        throw new Error(`Service ${serviceType} does not have a static start method. All services must implement static async start(runtime: IAgentRuntime): Promise<Service>.`);
-      }
-      const serviceInstance = await serviceDef.start(this);
-      if (!serviceInstance) {
-        throw new Error(`Service ${serviceType}  start() method returned null or undefined. It must return a Service instance.`);
-      }
-      if (!this.services.has(serviceType)) {
-        this.services.set(serviceType, []);
-      }
-      if (!this.serviceTypes.has(serviceType)) {
-        this.serviceTypes.set(serviceType, []);
-      }
-      this.services.get(serviceType).push(serviceInstance);
-      this.serviceTypes.get(serviceType).push(serviceDef);
-      const handler = this.servicePromiseHandlers.get(serviceType);
-      if (handler) {
-        handler.resolve(serviceInstance);
-        this.servicePromiseHandlers.delete(serviceType);
-      } else {
-        this.logger.debug({ src: "agent", agentId: this.agentId, serviceType }, "Service has no promise handler");
-      }
-      if (typeof serviceDef.registerSendHandlers === "function") {
-        serviceDef.registerSendHandlers(this, serviceInstance);
-      }
-      this.serviceRegistrationStatus.set(serviceType, "registered");
-      this.logger.debug({ src: "agent", agentId: this.agentId, serviceType }, "Service registered");
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      const errorStack = error instanceof Error ? error.stack : undefined;
-      this.logger.error({ src: "agent", agentId: this.agentId, serviceType, error: errorMessage }, "Service registration failed");
-      if (errorStack) {
-        this.logger.debug({ src: "agent", agentId: this.agentId, serviceType, stack: errorStack }, "Service error stack");
-      }
-      if (error?.message?.includes("timed out waiting for runtime initialization")) {
-        this.logger.error(`Service ${serviceType} failed due to runtime initialization timeout. Check if runtime.initialize() is being called and completing successfully.`);
-      } else if (error?.message?.includes("Not implemented")) {
-        this.logger.error(`Service ${serviceType} failed because it does not implement the static start() method. ` + `All services must override the base Service.start() method. ` + `Add: static async start(runtime: IAgentRuntime): Promise<${serviceName}> { return new ${serviceName}(runtime); }`);
-        if (errorStack) {
-          this.logger.debug(`Stack trace: ${errorStack}`);
-        }
-      } else if (error?.message?.includes("Service") && error?.message?.includes("failed to start")) {
-        this.logger.error(`Service ${serviceType} (${serviceName}) failed to start. Check service implementation and dependencies.`);
-      } else if (error?.message?.includes("does not have a static start method")) {
-        this.logger.error({ src: "agent", agentId: this.agentId, serviceType, serviceName, error: error?.message }, "Service missing required static start() method implementation");
-      } else {
-        if (errorStack) {
-          this.logger.debug({ src: "agent", agentId: this.agentId, serviceType, serviceName, stack: errorStack }, "Service error stack");
-        }
-      }
-      this.serviceRegistrationStatus.set(serviceType, "failed");
-      const handler = this.servicePromiseHandlers.get(serviceType);
-      if (handler) {
-        handler.reject(error);
-        this.servicePromiseHandlers.delete(serviceType);
-        this.servicePromises.delete(serviceType);
-      }
-      throw error;
+    this.logger.debug({ src: "agent", agentId: this.agentId, serviceType }, "Service waiting for init");
+    const initTimeout = new Promise((_, reject) => {
+      setTimeout(() => {
+        reject(new Error(`Service ${serviceType} registration timed out waiting for runtime initialization (30s timeout)`));
+      }, 30000);
+    });
+    await Promise.race([this.initPromise, initTimeout]);
+    if (typeof serviceDef.start !== "function") {
+      throw new Error(`Service ${serviceType} does not have a static start method. All services must implement static async start(runtime: IAgentRuntime): Promise<Service>.`);
+    }
+    const serviceInstance = await serviceDef.start(this);
+    if (!serviceInstance) {
+      throw new Error(`Service ${serviceType}  start() method returned null or undefined. It must return a Service instance.`);
+    }
+    if (!this.services.has(serviceType)) {
+      this.services.set(serviceType, []);
+    }
+    if (!this.serviceTypes.has(serviceType)) {
+      this.serviceTypes.set(serviceType, []);
+    }
+    this.services.get(serviceType).push(serviceInstance);
+    this.serviceTypes.get(serviceType).push(serviceDef);
+    const handler = this.servicePromiseHandlers.get(serviceType);
+    if (handler) {
+      handler.resolve(serviceInstance);
+      this.servicePromiseHandlers.delete(serviceType);
+    } else {
+      this.logger.debug({ src: "agent", agentId: this.agentId, serviceType }, "Service has no promise handler");
+    }
+    if (serviceDef.registerSendHandlers) {
+      serviceDef.constructor.registerSendHandlers?.(this, serviceInstance);
     }
+    this.serviceRegistrationStatus.set(serviceType, "registered");
+    this.logger.debug({ src: "agent", agentId: this.agentId, serviceType }, "Service registered");
   }
   _createServiceResolver(serviceType) {
     let resolver;
@@ -48581,21 +48790,12 @@ class AgentRuntime {
       return (a.registrationOrder || 0) - (b.registrationOrder || 0);
     });
   }
-  getModel(modelType, provider) {
+  getModel(modelType) {
     const modelKey = typeof modelType === "string" ? modelType : ModelType[modelType];
     const models = this.models.get(modelKey);
     if (!models?.length) {
       return;
     }
-    if (provider) {
-      const modelWithProvider = models.find((m) => m.provider === provider);
-      if (modelWithProvider) {
-        this.logger.debug({ src: "agent", agentId: this.agentId, model: modelKey, provider }, "Using model");
-        return modelWithProvider.handler;
-      } else {
-        this.logger.warn({ src: "agent", agentId: this.agentId, model: modelKey, provider }, "Model provider not found");
-      }
-    }
     this.logger.debug({ src: "agent", agentId: this.agentId, model: modelKey, provider: models[0].provider }, "Using model");
     return models[0].handler;
   }
@@ -48662,9 +48862,12 @@ class AgentRuntime {
   }
   async useModel(modelType, params, provider) {
     const modelKey = typeof modelType === "string" ? modelType : ModelType[modelType];
-    const promptContent = params?.prompt || params?.input || (Array.isArray(params?.messages) ? JSON.stringify(params.messages) : null);
-    const model = this.getModel(modelKey, provider);
-    if (!model) {
+    const paramsObj = params;
+    const promptContent = (paramsObj && "prompt" in paramsObj && typeof paramsObj.prompt === "string" ? paramsObj.prompt : null) || (paramsObj && "input" in paramsObj && typeof paramsObj.input === "string" ? paramsObj.input : null) || (paramsObj && "messages" in paramsObj && Array.isArray(paramsObj.messages) ? JSON.stringify(paramsObj.messages) : null);
+    const model = this.getModel(modelKey);
+    const modelWithProvider = provider && this.models.get(modelKey)?.find((m) => m.provider === provider);
+    const handler = modelWithProvider ? modelWithProvider.handler : model;
+    if (!handler) {
       const errorMsg = `No handler found for delegate type: ${modelKey}`;
       throw new Error(errorMsg);
     }
@@ -48706,57 +48909,94 @@ class AgentRuntime {
       }
       if (isPlainObject(modelParams)) {
         if (modelParams.user === undefined && this.character?.name) {
-          modelParams.user = this.character.name;
+          if (typeof modelParams === "object" && modelParams !== null && !Array.isArray(modelParams)) {
+            modelParams.user = this.character.name;
+          }
         }
       }
     }
     const startTime = typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
-    try {
-      const response = await model(this, modelParams);
-      const elapsedTime = (typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now()) - startTime;
+    const streamingCtx = getStreamingContext();
+    const paramsChunk = isPlainObject(modelParams) ? modelParams.onStreamChunk : undefined;
+    const ctxChunk = streamingCtx?.onStreamChunk;
+    const msgId = streamingCtx?.messageId;
+    const abortSignal = streamingCtx?.abortSignal;
+    const explicitStream = isPlainObject(modelParams) ? modelParams.stream : undefined;
+    const shouldStream = explicitStream === false ? false : !!(paramsChunk || ctxChunk || explicitStream);
+    if (isPlainObject(modelParams)) {
+      modelParams.stream = shouldStream;
+      delete modelParams.onStreamChunk;
+    }
+    const response = await handler(this, modelParams);
+    if (shouldStream && (paramsChunk || ctxChunk) && response && typeof response === "object" && "textStream" in response) {
+      let fullText = "";
+      for await (const chunk of response.textStream) {
+        if (abortSignal?.aborted)
+          break;
+        fullText += chunk;
+        try {
+          if (paramsChunk)
+            await paramsChunk(chunk, msgId);
+        } catch {}
+        try {
+          if (ctxChunk)
+            await ctxChunk(chunk, msgId);
+        } catch {}
+      }
+      const ctxEnd = getStreamingContext()?.onStreamEnd;
+      if (ctxEnd)
+        ctxEnd();
+      const elapsedTime2 = (typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now()) - startTime;
       this.logger.trace({
         src: "agent",
         agentId: this.agentId,
         model: modelKey,
-        duration: Number(elapsedTime.toFixed(2))
-      }, "Model output");
-      if (modelKey !== ModelType.TEXT_EMBEDDING && promptContent) {
-        if (this.currentActionContext) {
-          this.currentActionContext.prompts.push({
-            modelType: modelKey,
-            prompt: promptContent,
-            timestamp: Date.now()
-          });
-        }
-      }
-      this.adapter.log({
-        entityId: this.agentId,
-        roomId: this.currentRoomId ?? this.agentId,
-        body: {
-          modelType,
-          modelKey,
-          params: {
-            ...typeof params === "object" && !Array.isArray(params) && params ? params : {},
-            prompt: promptContent
-          },
+        duration: Number(elapsedTime2.toFixed(2)),
+        streaming: true
+      }, "Model output (stream with callback complete)");
+      return fullText;
+    }
+    const elapsedTime = (typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now()) - startTime;
+    this.logger.trace({
+      src: "agent",
+      agentId: this.agentId,
+      model: modelKey,
+      duration: Number(elapsedTime.toFixed(2))
+    }, "Model output");
+    if (modelKey !== ModelType.TEXT_EMBEDDING && promptContent) {
+      if (this.currentActionContext) {
+        this.currentActionContext.prompts.push({
+          modelType: modelKey,
           prompt: promptContent,
-          systemPrompt: this.character?.system || null,
-          runId: this.getCurrentRunId(),
-          timestamp: Date.now(),
-          executionTime: elapsedTime,
-          provider: provider || this.models.get(modelKey)?.[0]?.provider || "unknown",
-          actionContext: this.currentActionContext ? {
-            actionName: this.currentActionContext.actionName,
-            actionId: this.currentActionContext.actionId
-          } : undefined,
-          response: Array.isArray(response) && response.every((x) => typeof x === "number") ? "[array]" : response
-        },
-        type: `useModel:${modelKey}`
-      });
-      return response;
-    } catch (error) {
-      throw error;
+          timestamp: Date.now()
+        });
+      }
     }
+    this.adapter.log({
+      entityId: this.agentId,
+      roomId: this.currentRoomId ?? this.agentId,
+      body: {
+        modelType,
+        modelKey,
+        params: {
+          ...typeof params === "object" && !Array.isArray(params) && params ? params : {},
+          prompt: promptContent
+        },
+        prompt: promptContent,
+        systemPrompt: this.character?.system || null,
+        runId: this.getCurrentRunId(),
+        timestamp: Date.now(),
+        executionTime: elapsedTime,
+        provider: provider || this.models.get(modelKey)?.[0]?.provider || "unknown",
+        actionContext: this.currentActionContext ? {
+          actionName: this.currentActionContext.actionName,
+          actionId: this.currentActionContext.actionId
+        } : undefined,
+        response: Array.isArray(response) && response.every((x) => typeof x === "number") ? "[array]" : response
+      },
+      type: `useModel:${modelKey}`
+    });
+    return response;
   }
   async generateText(input, options) {
     if (!input?.trim()) {
@@ -48827,45 +49067,32 @@ ${input}`;
       if (!eventHandlers) {
         continue;
       }
-      try {
-        let paramsWithRuntime = { runtime: this };
-        if (typeof params === "object" && params) {
-          paramsWithRuntime = { ...params, ...paramsWithRuntime };
-        }
-        await Promise.all(eventHandlers.map((handler) => handler(paramsWithRuntime)));
-      } catch (error) {
-        this.logger.error({
-          src: "agent",
-          agentId: this.agentId,
-          eventName,
-          error: error instanceof Error ? error.message : String(error)
-        }, "Event handler failed");
+      let paramsWithRuntime = { runtime: this, source: "runtime" };
+      if (typeof params === "object" && params && params !== null) {
+        const paramsObj = params;
+        paramsWithRuntime = {
+          ...paramsObj,
+          runtime: this,
+          source: paramsObj.source || "runtime"
+        };
       }
+      await Promise.all(eventHandlers.map((handler) => handler(paramsWithRuntime)));
     }
   }
   async ensureEmbeddingDimension() {
     if (!this.adapter) {
       throw new Error("Database adapter not initialized before ensureEmbeddingDimension");
     }
-    try {
-      const model = this.getModel(ModelType.TEXT_EMBEDDING);
-      if (!model) {
-        throw new Error("No TEXT_EMBEDDING model registered");
-      }
-      const embedding = await this.useModel(ModelType.TEXT_EMBEDDING, null);
-      if (!embedding || !embedding.length) {
-        throw new Error("Invalid embedding received");
-      }
-      await this.adapter.ensureEmbeddingDimension(embedding.length);
-      this.logger.debug({ src: "agent", agentId: this.agentId, dimension: embedding.length }, "Embedding dimension set");
-    } catch (error) {
-      this.logger.error({
-        src: "agent",
-        agentId: this.agentId,
-        error: error instanceof Error ? error.message : String(error)
-      }, "Embedding dimension setup failed");
-      throw error;
+    const model = this.getModel(ModelType.TEXT_EMBEDDING);
+    if (!model) {
+      throw new Error("No TEXT_EMBEDDING model registered");
+    }
+    const embedding = await this.useModel(ModelType.TEXT_EMBEDDING, { text: "" });
+    if (!embedding || !embedding.length) {
+      throw new Error("Invalid embedding received");
     }
+    await this.adapter.ensureEmbeddingDimension(embedding.length);
+    this.logger.debug({ src: "agent", agentId: this.agentId, dimension: embedding.length }, "Embedding dimension set");
   }
   registerTaskWorker(taskHandler) {
     if (this.taskWorkers.has(taskHandler.name)) {
@@ -49005,7 +49232,7 @@ ${input}`;
         agentId: this.agentId,
         error: error instanceof Error ? error.message : String(error)
       }, "Embedding generation failed");
-      memory.embedding = await this.useModel(ModelType.TEXT_EMBEDDING, null);
+      memory.embedding = await this.useModel(ModelType.TEXT_EMBEDDING, { text: "" });
     }
     return memory;
   }
@@ -49268,16 +49495,16 @@ ${input}`;
     }
   }
   async sendControlMessage(params) {
+    const { roomId, action, target } = params;
+    const controlMessage = {
+      type: "control",
+      payload: {
+        action,
+        target
+      },
+      roomId
+    };
     try {
-      const { roomId, action, target } = params;
-      const controlMessage = {
-        type: "control",
-        payload: {
-          action,
-          target
-        },
-        roomId
-      };
       await this.emitEvent("CONTROL_MESSAGE", {
         runtime: this,
         message: controlMessage,
@@ -49322,7 +49549,7 @@ ${input}`;
     return await this.adapter.getMemoriesByWorldId(params);
   }
   async runMigrations(migrationsPaths) {
-    if (this.adapter && "runMigrations" in this.adapter) {
+    if (this.adapter?.runMigrations) {
       await this.adapter.runMigrations(migrationsPaths);
     } else {
       this.logger.warn({ src: "agent", agentId: this.agentId }, "Database adapter does not support migrations");
@@ -49373,11 +49600,7 @@ async function setDefaultSecretsFromEnv(character, options) {
 
 // src/utils/crypto-compat.ts
 function hasNodeCrypto() {
-  try {
-    return typeof process !== "undefined" && (process.versions?.node !== undefined || process.versions?.bun !== undefined);
-  } catch {
-    return false;
-  }
+  return typeof process !== "undefined" && (process.versions?.node !== undefined || process.versions?.bun !== undefined);
 }
 function getCryptoModule() {
   if (hasNodeCrypto()) {
@@ -49403,14 +49626,34 @@ function createCipheriv(algorithm, key, iv) {
     throw new Error(`Unsupported algorithm: ${algorithm}. Only 'aes-256-cbc' is currently supported.`);
   }
   const crypto2 = getCryptoModule();
-  return crypto2.createCipheriv(algorithm, key, iv);
+  const cipher = crypto2.createCipheriv(algorithm, key, iv);
+  return {
+    update(data2, inputEncoding, outputEncoding) {
+      const result = cipher.update(Buffer.from(data2, inputEncoding), undefined, outputEncoding);
+      return typeof result === "string" ? result : result.toString(outputEncoding);
+    },
+    final(encoding) {
+      const result = cipher.final(encoding);
+      return typeof result === "string" ? result : result.toString(encoding);
+    }
+  };
 }
 function createDecipheriv(algorithm, key, iv) {
   if (algorithm !== "aes-256-cbc") {
     throw new Error(`Unsupported algorithm: ${algorithm}. Only 'aes-256-cbc' is currently supported.`);
   }
   const crypto2 = getCryptoModule();
-  return crypto2.createDecipheriv(algorithm, key, iv);
+  const decipher = crypto2.createDecipheriv(algorithm, key, iv);
+  return {
+    update(data2, inputEncoding, outputEncoding) {
+      const result = decipher.update(Buffer.from(data2, inputEncoding), undefined, outputEncoding);
+      return typeof result === "string" ? result : result.toString(outputEncoding);
+    },
+    final(encoding) {
+      const result = decipher.final(encoding);
+      return typeof result === "string" ? result : result.toString(encoding);
+    }
+  };
 }
 
 // src/settings.ts
@@ -49472,7 +49715,7 @@ function encryptStringValue(value, salt) {
       if (possibleIv.length === 16) {
         return value;
       }
-    } catch (e) {}
+    } catch {}
   }
   const key = createHash("sha256").update(salt).digest().slice(0, 32);
   const iv = BufferUtils.randomBytes(16);
@@ -49483,15 +49726,6 @@ function encryptStringValue(value, salt) {
 }
 function decryptStringValue(value, salt) {
   try {
-    if (value === undefined || value === null) {
-      return value;
-    }
-    if (typeof value === "boolean" || typeof value === "number") {
-      return value;
-    }
-    if (typeof value !== "string") {
-      return value;
-    }
     const parts = value.split(":");
     if (parts.length !== 2) {
       return value;
@@ -49658,7 +49892,8 @@ class ServiceBuilder {
     const description = this.description;
     const startFn = this.startFn;
     const stopFn = this.stopFn;
-    return class extends Service {
+
+    class ServiceClass extends Service {
       static serviceType = serviceType;
       capabilityDescription = description;
       static async start(runtime) {
@@ -49672,14 +49907,16 @@ class ServiceBuilder {
           await stopFn();
         }
       }
-    };
+    }
+    return ServiceClass;
   }
 }
 function createService(serviceType) {
   return new ServiceBuilder(serviceType);
 }
 function defineService(definition) {
-  return createService(definition.serviceType).withDescription(definition.description).withStart(definition.start).withStop(definition.stop || (() => Promise.resolve())).build();
+  const builtService = createService(definition.serviceType).withDescription(definition.description).withStart(definition.start).withStop(definition.stop || (() => Promise.resolve())).build();
+  return builtService;
 }
 
 // src/plugin.ts
@@ -49795,55 +50032,46 @@ function validatePlugin(plugin) {
   };
 }
 async function loadAndPreparePlugin(pluginName) {
+  let pluginModule;
   try {
-    let pluginModule;
+    pluginModule = await import(pluginName);
+  } catch (error) {
+    logger.warn({ src: "core:plugin", pluginName, error }, "Failed to load plugin");
+    const attempted = await tryInstallPlugin(pluginName);
+    if (!attempted) {
+      return null;
+    }
     try {
       pluginModule = await import(pluginName);
-    } catch (error) {
-      logger.warn({ src: "core:plugin", pluginName, error }, "Failed to load plugin");
-      const attempted = await tryInstallPlugin(pluginName);
-      if (!attempted) {
-        return null;
-      }
-      try {
-        pluginModule = await import(pluginName);
-      } catch (secondError) {
-        logger.error({ src: "core:plugin", pluginName, error: secondError }, "Import failed after auto-install");
-        return null;
-      }
-    }
-    if (!pluginModule) {
-      logger.error({ src: "core:plugin", pluginName }, "Failed to load plugin module");
+    } catch (secondError) {
+      logger.error({ src: "core:plugin", pluginName, error: secondError }, "Import failed after auto-install");
       return null;
     }
-    const expectedFunctionName = `${pluginName.replace(/^@elizaos\/plugin-/, "").replace(/^@elizaos\//, "").replace(/-./g, (match) => match[1].toUpperCase())}Plugin`;
-    const moduleObj = pluginModule;
-    const exportsToCheck = [
-      moduleObj[expectedFunctionName],
-      moduleObj.default,
-      ...Object.values(moduleObj)
-    ];
-    for (const potentialPlugin of exportsToCheck) {
-      if (isValidPluginShape(potentialPlugin)) {
-        return potentialPlugin;
-      }
-      if (typeof potentialPlugin === "function" && potentialPlugin.length === 0) {
-        try {
-          const produced = potentialPlugin();
-          if (isValidPluginShape(produced)) {
-            return produced;
-          }
-        } catch (err) {
-          logger.debug({ src: "core:plugin", pluginName, error: err }, "Factory export threw");
-        }
+  }
+  if (!pluginModule) {
+    logger.error({ src: "core:plugin", pluginName }, "Failed to load plugin module");
+    return null;
+  }
+  const expectedFunctionName = `${pluginName.replace(/^@elizaos\/plugin-/, "").replace(/^@elizaos\//, "").replace(/-./g, (match) => match[1].toUpperCase())}Plugin`;
+  const moduleObj = pluginModule;
+  const exportsToCheck = [
+    moduleObj[expectedFunctionName],
+    moduleObj.default,
+    ...Object.values(moduleObj)
+  ];
+  for (const potentialPlugin of exportsToCheck) {
+    if (isValidPluginShape(potentialPlugin)) {
+      return potentialPlugin;
+    }
+    if (typeof potentialPlugin === "function" && potentialPlugin.length === 0) {
+      const produced = potentialPlugin();
+      if (isValidPluginShape(produced)) {
+        return produced;
       }
     }
-    logger.warn({ src: "core:plugin", pluginName }, "No valid plugin export found");
-    return null;
-  } catch (error) {
-    logger.error({ src: "core:plugin", pluginName, error }, "Error loading plugin");
-    return null;
   }
+  logger.warn({ src: "core:plugin", pluginName }, "No valid plugin export found");
+  return null;
 }
 function normalizePluginName(pluginName) {
   const scopedMatch = pluginName.match(/^@[^/]+\/plugin-(.+)$/);
@@ -49985,8 +50213,15 @@ class ElizaOS extends EventTarget {
   async addAgents(agents, options) {
     const createdRuntimes = [];
     const promises = agents.map(async (agent) => {
-      const character = agent.character;
+      const character = JSON.parse(JSON.stringify(agent.character));
       await setDefaultSecretsFromEnv(character, { skipEnvMerge: options?.isTestMode });
+      const salt = getSalt();
+      if (character.settings?.secrets && typeof character.settings.secrets === "object") {
+        character.settings.secrets = encryptObjectValues(character.settings.secrets, salt);
+      }
+      if (character.secrets && typeof character.secrets === "object") {
+        character.secrets = encryptObjectValues(character.secrets, salt);
+      }
       let resolvedPlugins = agent.plugins ? await resolvePlugins(agent.plugins, options?.isTestMode || false) : [];
       if (agent.databaseAdapter) {
         resolvedPlugins = resolvedPlugins.filter((p) => p.name !== "@elizaos/plugin-sql");
@@ -50140,7 +50375,7 @@ class ElizaOS extends EventTarget {
   getAgentByCharacterId(characterId) {
     return this.getAgents().find((runtime) => runtime.character.id === characterId);
   }
-  async sendMessage(target, message, options) {
+  async handleMessage(target, message, options) {
     let runtime;
     let agentId;
     if (typeof target === "string") {
@@ -50177,7 +50412,8 @@ class ElizaOS extends EventTarget {
       maxRetries: options?.maxRetries,
       timeoutDuration: options?.timeoutDuration,
       useMultiStep: options?.useMultiStep,
-      maxMultiStepIterations: options?.maxMultiStepIterations
+      maxMultiStepIterations: options?.maxMultiStepIterations,
+      onStreamChunk: options?.onStreamChunk
     };
     const handleMessageWithEntityContext = async (handler) => {
       if (runtime.withEntityContext) {
@@ -50221,10 +50457,10 @@ class ElizaOS extends EventTarget {
       return { messageId, userMessage, processing };
     }
   }
-  async sendMessages(messages) {
+  async handleMessages(messages) {
     const results = await Promise.all(messages.map(async ({ agentId, message, options }) => {
       try {
-        const result = await this.sendMessage(agentId, message, options);
+        const result = await this.handleMessage(agentId, message, options);
         return { agentId, result };
       } catch (error) {
         return {
@@ -50279,9 +50515,8 @@ class ElizaOS extends EventTarget {
         const agent = this.getAgent(agentId);
         if (!agent)
           return;
-        const agentRuntime = agent;
-        if (agentRuntime.stateCache && agentRuntime.stateCache.size > 0) {
-          const states = Array.from(agentRuntime.stateCache.values());
+        if (agent.stateCache && agent.stateCache.size > 0) {
+          const states = Array.from(agent.stateCache.values());
           return states[states.length - 1];
         }
         return;
@@ -50437,8 +50672,10 @@ async function findEntityByName(runtime, message, state) {
     }
   }
   let matchesArray = [];
-  if (resolution.matches?.match) {
-    matchesArray = Array.isArray(resolution.matches.match) ? resolution.matches.match : [resolution.matches.match];
+  const parsedResolution = resolution;
+  if (parsedResolution.matches?.match) {
+    const matchValue = parsedResolution.matches.match;
+    matchesArray = Array.isArray(matchValue) ? matchValue : [matchValue];
   }
   if (matchesArray.length > 0 && matchesArray[0]?.name) {
     const matchName = matchesArray[0].name.toLowerCase();
@@ -50495,9 +50732,19 @@ async function getEntityDetails({
         mergedData[key] = { ...mergedData[key], ...value };
       }
     }
+    const getEntityNameFromMetadata = (source) => {
+      const sourceMetadata = entity.metadata[source];
+      if (sourceMetadata && typeof sourceMetadata === "object" && sourceMetadata !== null) {
+        const metadataObj = sourceMetadata;
+        if ("name" in metadataObj && typeof metadataObj.name === "string") {
+          return metadataObj.name;
+        }
+      }
+      return;
+    };
     uniqueEntities.set(entity.id, {
       id: entity.id,
-      name: room?.source ? entity.metadata[room.source]?.name || entity.names[0] : entity.names[0],
+      name: room?.source ? getEntityNameFromMetadata(room.source) || entity.names[0] : entity.names[0],
       names: entity.names,
       data: JSON.stringify({ ...mergedData, ...entity.metadata })
     });
@@ -50518,6 +50765,7 @@ Data: ${JSON.stringify(entity.metadata)}
 }
 
 // src/index.node.ts
+setStreamingContextManager(createNodeStreamingContextManager());
 var isBrowser4 = false;
 var isNode3 = true;
 export {
@@ -50542,15 +50790,18 @@ export {
   slice,
   shouldRespondTemplate,
   settingsSchema,
+  setStreamingContextManager,
   setEnv,
   setDefaultSecretsFromEnv,
   secretsSchema,
   saltWorldSettings,
   saltSettingValue,
   safeReplacer,
+  runWithStreamingContext,
   resolvePlugins,
   resolvePluginDependencies,
   resetPaths,
+  removeLogListener,
   recentLogs,
   randomBytes,
   prewarmUuidCache,
@@ -50576,6 +50827,7 @@ export {
   knowledgeItemSchema,
   isValidPluginShape,
   isValidCharacter,
+  isStreamableModelType,
   isNode3 as isNode,
   isMessageMetadata,
   isFragmentMetadata,
@@ -50596,6 +50848,8 @@ export {
   getUploadsChannelsDir,
   getUploadsAgentsDir,
   getTypedService,
+  getStreamingContextManager,
+  getStreamingContext,
   getSalt,
   getNumberEnv,
   getMemoryText,
@@ -50655,21 +50909,27 @@ export {
   booleanFooter,
   asUUID,
   alloc,
+  addLogListener,
   addHeader,
   __loggerTestHooks,
+  XmlTagExtractor,
   VECTOR_DIMS,
   TeeType,
   TEEMode,
+  StreamError,
   ServiceType,
   ServiceBuilder,
   Service,
   Semaphore,
   SOCKET_MESSAGE_TYPE,
   Role,
+  ResponseStreamExtractor,
   PlatformPrefix,
+  PassthroughExtractor,
   ModelType,
   MemoryType,
   MODEL_SETTINGS,
+  MESSAGE_STREAM_EVENT,
   EventType,
   Environment,
   ElizaOS,
@@ -50680,8 +50940,9 @@ export {
   BufferUtils,
   BM25,
   AgentStatus,
-  AgentRuntime
+  AgentRuntime,
+  ActionStreamFilter
 };
 
-//# debugId=C468BC8B5AE0993F64756E2164756E21
+//# debugId=7435777E3B16550264756E2164756E21
 //# sourceMappingURL=index.node.js.map