@elizaos/core 1.0.8 → 1.0.10

package/dist/{chunk-6EXKM3O4.js → chunk-27AU6HW7.js}

@@ -106,7 +106,7 @@ __export(v2_exports, {
   isMessageMetadata: () => isMessageMetadata,
   logger: () => logger2,
   messageHandlerTemplate: () => messageHandlerTemplate2,
-  parseBooleanFromText: () => parseBooleanFromText2,
+  parseBooleanFromText: () => parseBooleanFromText3,
   parseJSONObjectFromText: () => parseJSONObjectFromText2,
   parseKeyValueXml: () => parseKeyValueXml2,
   postCreationTemplate: () => postCreationTemplate2,
@@ -513,7 +513,10 @@ var ServiceType3 = {
   WALLET: "wallet",
   LP_POOL: "lp_pool",
   TOKEN_DATA: "token_data",
-  DATABASE_MIGRATION: "database_migration"
+  DATABASE_MIGRATION: "database_migration",
+  PLUGIN_MANAGER: "PLUGIN_MANAGER",
+  PLUGIN_CONFIGURATION: "PLUGIN_CONFIGURATION",
+  PLUGIN_USER_INTERACTION: "PLUGIN_USER_INTERACTION"
 };
 var Service3 = class {
   constructor(runtime) {
@@ -679,71 +682,12 @@ var ILpService = class extends Service3 {
   }
 };
 
-// src/actions.ts
+// src/utils.ts
+import handlebars from "handlebars";
+import { sha1 } from "js-sha1";
+import { RecursiveCharacterTextSplitter } from "langchain/text_splitter";
 import { names, uniqueNamesGenerator } from "unique-names-generator";
-var composeActionExamples2 = (actionsData, count) => {
-  if (!actionsData.length || count <= 0) {
-    return "";
-  }
-  const actionsWithExamples = actionsData.filter(
-    (action) => action.examples && Array.isArray(action.examples) && action.examples.length > 0
-  );
-  if (!actionsWithExamples.length) {
-    return "";
-  }
-  const examplesCopy = actionsWithExamples.map((action) => [
-    ...action.examples
-  ]);
-  const selectedExamples = [];
-  let availableActionIndices = examplesCopy.map((examples, index) => examples.length > 0 ? index : -1).filter((index) => index !== -1);
-  while (selectedExamples.length < count && availableActionIndices.length > 0) {
-    const randomIndex = Math.floor(Math.random() * availableActionIndices.length);
-    const actionIndex = availableActionIndices[randomIndex];
-    const examples = examplesCopy[actionIndex];
-    const exampleIndex = Math.floor(Math.random() * examples.length);
-    selectedExamples.push(examples.splice(exampleIndex, 1)[0]);
-    if (examples.length === 0) {
-      availableActionIndices.splice(randomIndex, 1);
-    }
-  }
-  return formatSelectedExamples(selectedExamples);
-};
-var formatSelectedExamples = (examples) => {
-  const MAX_NAME_PLACEHOLDERS = 5;
-  return examples.map((example) => {
-    const randomNames = Array.from(
-      { length: MAX_NAME_PLACEHOLDERS },
-      () => uniqueNamesGenerator({ dictionaries: [names] })
-    );
-    const conversation = example.map((message) => {
-      let messageText = `${message.name}: ${message.content.text}`;
-      if (message.content.action) {
-        messageText += ` (action: ${message.content.action})`;
-      }
-      if (message.content.actions?.length) {
-        messageText += ` (actions: ${message.content.actions.join(", ")})`;
-      }
-      for (let i = 0; i < randomNames.length; i++) {
-        messageText = messageText.replaceAll(`{{name${i + 1}}}`, randomNames[i]);
-      }
-      return messageText;
-    }).join("\n");
-    return `
-${conversation}`;
-  }).join("\n");
-};
-function formatActionNames2(actions) {
-  if (!actions?.length) return "";
-  return [...actions].sort(() => Math.random() - 0.5).map((action) => action.name).join(", ");
-}
-function formatActions2(actions) {
-  if (!actions?.length) return "";
-  return [...actions].sort(() => Math.random() - 0.5).map((action) => `${action.name}: ${action.description}`).join(",\n");
-}
-
-// src/database.ts
-var DatabaseAdapter2 = class {
-};
+import { z } from "zod";
 
 // src/logger.ts
 import pino from "pino";
@@ -762,391 +706,71 @@ if (process.env.SENTRY_LOGGING !== "false") {
   });
 }
 
-// src/utils.ts
-import handlebars from "handlebars";
-import { sha1 } from "js-sha1";
-import { RecursiveCharacterTextSplitter } from "langchain/text_splitter";
-import { names as names2, uniqueNamesGenerator as uniqueNamesGenerator2 } from "unique-names-generator";
-import { z } from "zod";
-function upgradeDoubleToTriple(tpl) {
-  return tpl.replace(
-    // ────────╮ negative-LB: not already "{{{"
-    //          │   {{     ─ opening braces
-    //          │    ╰──── negative-LA: not {, #, /, !, >
-    //          ▼
-    /(?<!{){{(?![{#\/!>])([\s\S]*?)}}/g,
-    (_match, inner) => {
-      if (inner.trim() === "else") return `{{${inner}}}`;
-      return `{{{${inner}}}}`;
-    }
-  );
+// src/logger.ts
+function parseBooleanFromText(value) {
+  if (!value) return false;
+  const normalized = value.toLowerCase().trim();
+  return normalized === "true" || normalized === "1" || normalized === "yes" || normalized === "on";
 }
-var composePrompt = ({
-  state,
-  template
-}) => {
-  const templateStr = typeof template === "function" ? template({ state }) : template;
-  const templateFunction = handlebars.compile(upgradeDoubleToTriple(templateStr));
-  const output = composeRandomUser(templateFunction(state), 10);
-  return output;
-};
-var composePromptFromState = ({
-  state,
-  template
-}) => {
-  const templateStr = typeof template === "function" ? template({ state }) : template;
-  const templateFunction = handlebars.compile(upgradeDoubleToTriple(templateStr));
-  const stateKeys = Object.keys(state);
-  const filteredKeys = stateKeys.filter((key) => !["text", "values", "data"].includes(key));
-  const filteredState = filteredKeys.reduce((acc, key) => {
-    acc[key] = state[key];
-    return acc;
-  }, {});
-  const output = composeRandomUser(templateFunction({ ...filteredState, ...state.values }), 10);
-  return output;
-};
-var addHeader = (header, body) => {
-  return body.length > 0 ? `${header ? `${header}
-` : header}${body}
-` : "";
-};
-var composeRandomUser = (template, length) => {
-  const exampleNames = Array.from(
-    { length },
-    () => uniqueNamesGenerator2({ dictionaries: [names2] })
-  );
-  let result = template;
-  for (let i = 0; i < exampleNames.length; i++) {
-    result = result.replaceAll(`{{name${i + 1}}}`, exampleNames[i]);
+var InMemoryDestination = class {
+  /**
+   * Constructor for creating a new instance of the class.
+   * @param {DestinationStream|null} stream - The stream to assign to the instance. Can be null.
+   */
+  constructor(stream) {
+    this.logs = [];
+    this.maxLogs = 1e3;
+    this.stream = stream;
   }
-  return result;
-};
-var formatPosts = ({
-  messages,
-  entities,
-  conversationHeader = true
-}) => {
-  const groupedMessages = {};
-  messages.forEach((message) => {
-    if (message.roomId) {
-      if (!groupedMessages[message.roomId]) {
-        groupedMessages[message.roomId] = [];
+  /**
+   * Writes a log entry to the memory buffer and forwards it to the pretty print stream if available.
+   *
+   * @param {string | LogEntry} data - The data to be written, which can be either a string or a LogEntry object.
+   * @returns {void}
+   */
+  write(data) {
+    let logEntry;
+    let stringData;
+    if (typeof data === "string") {
+      stringData = data;
+      try {
+        logEntry = JSON.parse(data);
+      } catch (e) {
+        if (this.stream) {
+          this.stream.write(data);
+        }
+        return;
       }
-      groupedMessages[message.roomId].push(message);
+    } else {
+      logEntry = data;
+      stringData = JSON.stringify(data);
     }
-  });
-  Object.values(groupedMessages).forEach((roomMessages) => {
-    roomMessages.sort((a, b) => a.createdAt - b.createdAt);
-  });
-  const sortedRooms = Object.entries(groupedMessages).sort(
-    ([, messagesA], [, messagesB]) => messagesB[messagesB.length - 1].createdAt - messagesA[messagesA.length - 1].createdAt
-  );
-  const formattedPosts = sortedRooms.map(([roomId, roomMessages]) => {
-    const messageStrings = roomMessages.filter((message) => message.entityId).map((message) => {
-      const entity = entities.find((entity2) => entity2.id === message.entityId);
-      if (!entity) {
-        logger_default.warn("core::prompts:formatPosts - no entity for", message.entityId);
+    if (!logEntry.time) {
+      logEntry.time = Date.now();
+    }
+    const isDebugMode2 = (process?.env?.LOG_LEVEL || "").toLowerCase() === "debug";
+    const isLoggingDiagnostic = Boolean(process?.env?.LOG_DIAGNOSTIC);
+    if (isLoggingDiagnostic) {
+      logEntry.diagnostic = true;
+    }
+    if (!isDebugMode2) {
+      if (logEntry.agentName && logEntry.agentId) {
+        const msg = logEntry.msg || "";
+        if (typeof msg === "string" && (msg.includes("registered successfully") || msg.includes("Registering") || msg.includes("Success:") || msg.includes("linked to") || msg.includes("Started"))) {
+          if (isLoggingDiagnostic) {
+            console.error("Filtered log:", stringData);
+          }
+          return;
+        }
       }
-      const userName = entity?.names[0] || "Unknown User";
-      const displayName = entity?.names[0] || "unknown";
-      return `Name: ${userName} (@${displayName} EntityID:${message.entityId})
-MessageID: ${message.id}${message.content.inReplyTo ? `
-In reply to: ${message.content.inReplyTo}` : ""}
-Source: ${message.content.source}
-Date: ${formatTimestamp(message.createdAt)}
-Text:
-${message.content.text}`;
-    });
-    const header = conversationHeader ? `Conversation: ${roomId.slice(-5)}
-` : "";
-    return `${header}${messageStrings.join("\n\n")}`;
-  });
-  return formattedPosts.join("\n\n");
-};
-var formatMessages = ({
-  messages,
-  entities
-}) => {
-  const messageStrings = messages.reverse().filter((message) => message.entityId).map((message) => {
-    const messageText = message.content.text;
-    const messageActions = message.content.actions;
-    const messageThought = message.content.thought;
-    const formattedName = entities.find((entity) => entity.id === message.entityId)?.names[0] || "Unknown User";
-    const attachments = message.content.attachments;
-    const attachmentString = attachments && attachments.length > 0 ? ` (Attachments: ${attachments.map((media) => `[${media.id} - ${media.title} (${media.url})]`).join(", ")})` : null;
-    const messageTime = new Date(message.createdAt);
-    const hours = messageTime.getHours().toString().padStart(2, "0");
-    const minutes = messageTime.getMinutes().toString().padStart(2, "0");
-    const timeString = `${hours}:${minutes}`;
-    const timestamp = formatTimestamp(message.createdAt);
-    const thoughtString = messageThought ? `(${formattedName}'s internal thought: ${messageThought})` : null;
-    const timestampString = `${timeString} (${timestamp}) [${message.entityId}]`;
-    const textString = messageText ? `${timestampString} ${formattedName}: ${messageText}` : null;
-    const actionString = messageActions && messageActions.length > 0 ? `${textString ? "" : timestampString} (${formattedName}'s actions: ${messageActions.join(", ")})` : null;
-    const messageString = [textString, thoughtString, actionString, attachmentString].filter(Boolean).join("\n");
-    return messageString;
-  }).join("\n");
-  return messageStrings;
-};
-var formatTimestamp = (messageDate) => {
-  const now = /* @__PURE__ */ new Date();
-  const diff = now.getTime() - messageDate;
-  const absDiff = Math.abs(diff);
-  const seconds = Math.floor(absDiff / 1e3);
-  const minutes = Math.floor(seconds / 60);
-  const hours = Math.floor(minutes / 60);
-  const days = Math.floor(hours / 24);
-  if (absDiff < 6e4) {
-    return "just now";
-  }
-  if (minutes < 60) {
-    return `${minutes} minute${minutes !== 1 ? "s" : ""} ago`;
-  }
-  if (hours < 24) {
-    return `${hours} hour${hours !== 1 ? "s" : ""} ago`;
-  }
-  return `${days} day${days !== 1 ? "s" : ""} ago`;
-};
-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];
-    logger_default.debug("Found response XML block");
-  } else {
-    const fallbackMatch = text.match(/<(\w+)>([\s\S]*?)<\/\1>/);
-    if (!fallbackMatch) {
-      logger_default.warn("Could not find XML block in text");
-      logger_default.debug("Text content:", text.substring(0, 200) + "...");
-      return null;
-    }
-    xmlContent = fallbackMatch[2];
-    logger_default.debug(`Found XML block with tag: ${fallbackMatch[1]}`);
-  }
-  const result = {};
-  const tagPattern = /<([\w-]+)>([\s\S]*?)<\/([\w-]+)>/g;
-  let match;
-  while ((match = tagPattern.exec(xmlContent)) !== null) {
-    if (match[1] === match[3]) {
-      const key = match[1];
-      const value = match[2].replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&").replace(/&quot;/g, '"').replace(/&apos;/g, "'").trim();
-      if (key === "actions" || key === "providers" || key === "evaluators") {
-        result[key] = value ? value.split(",").map((s) => s.trim()) : [];
-      } else if (key === "simple") {
-        result[key] = value.toLowerCase() === "true";
-      } else {
-        result[key] = value;
-      }
-    } else {
-      logger_default.warn(`Mismatched XML tags found: <${match[1]}> and </${match[3]}>`);
-    }
-  }
-  if (Object.keys(result).length === 0) {
-    logger_default.warn("No key-value pairs extracted from XML content");
-    logger_default.debug("XML content was:", xmlContent.substring(0, 200) + "...");
-    return null;
-  }
-  return result;
-}
-function parseJSONObjectFromText(text) {
-  let jsonData = null;
-  const jsonBlockMatch = text.match(jsonBlockPattern);
-  try {
-    if (jsonBlockMatch) {
-      jsonData = JSON.parse(normalizeJsonString(jsonBlockMatch[1].trim()));
-    } else {
-      jsonData = JSON.parse(normalizeJsonString(text.trim()));
-    }
-  } catch (_e) {
-    return null;
-  }
-  if (jsonData && typeof jsonData === "object" && !Array.isArray(jsonData)) {
-    return jsonData;
-  }
-  return null;
-}
-var normalizeJsonString = (str) => {
-  str = str.replace(/\{\s+/, "{").replace(/\s+\}/, "}").trim();
-  str = str.replace(/("[\w\d_-]+")\s*: \s*(?!"|\[)([\s\S]+?)(?=(,\s*"|\}$))/g, '$1: "$2"');
-  str = str.replace(/"([^"]+)"\s*:\s*'([^']*)'/g, (_, key, value) => `"${key}": "${value}"`);
-  str = str.replace(/("[\w\d_-]+")\s*:\s*([A-Za-z_]+)(?!["\w])/g, '$1: "$2"');
-  return str;
-};
-function truncateToCompleteSentence(text, maxLength) {
-  if (text.length <= maxLength) {
-    return text;
-  }
-  const lastPeriodIndex = text.lastIndexOf(".", maxLength - 1);
-  if (lastPeriodIndex !== -1) {
-    const truncatedAtPeriod = text.slice(0, lastPeriodIndex + 1).trim();
-    if (truncatedAtPeriod.length > 0) {
-      return truncatedAtPeriod;
-    }
-  }
-  const lastSpaceIndex = text.lastIndexOf(" ", maxLength - 1);
-  if (lastSpaceIndex !== -1) {
-    const truncatedAtSpace = text.slice(0, lastSpaceIndex).trim();
-    if (truncatedAtSpace.length > 0) {
-      return `${truncatedAtSpace}...`;
-    }
-  }
-  const hardTruncated = text.slice(0, maxLength - 3).trim();
-  return `${hardTruncated}...`;
-}
-async function splitChunks(content, chunkSize = 512, bleed = 20) {
-  logger_default.debug("[splitChunks] Starting text split");
-  const characterstoTokens = 3.5;
-  const textSplitter = new RecursiveCharacterTextSplitter({
-    chunkSize: Number(Math.floor(chunkSize * characterstoTokens)),
-    chunkOverlap: Number(Math.floor(bleed * characterstoTokens))
-  });
-  const chunks = await textSplitter.splitText(content);
-  logger_default.debug("[splitChunks] Split complete:", {
-    numberOfChunks: chunks.length,
-    averageChunkSize: chunks.reduce((acc, chunk) => acc + chunk.length, 0) / chunks.length
-  });
-  return chunks;
-}
-async function trimTokens(prompt, maxTokens, runtime) {
-  if (!prompt) throw new Error("Trim tokens received a null prompt");
-  if (prompt.length < maxTokens / 5) return prompt;
-  if (maxTokens <= 0) throw new Error("maxTokens must be positive");
-  const tokens = await runtime.useModel(ModelType2.TEXT_TOKENIZER_ENCODE, {
-    prompt
-  });
-  if (tokens.length <= maxTokens) {
-    return prompt;
-  }
-  const truncatedTokens = tokens.slice(-maxTokens);
-  return await runtime.useModel(ModelType2.TEXT_TOKENIZER_DECODE, {
-    tokens: truncatedTokens
-  });
-}
-function safeReplacer() {
-  const seen = /* @__PURE__ */ new WeakSet();
-  return function(key, value) {
-    if (typeof value === "object" && value !== null) {
-      if (seen.has(value)) {
-        return "[Circular]";
-      }
-      seen.add(value);
-    }
-    return value;
-  };
-}
-function parseBooleanFromText(value) {
-  if (!value) return false;
-  const affirmative = ["YES", "Y", "TRUE", "T", "1", "ON", "ENABLE"];
-  const negative = ["NO", "N", "FALSE", "F", "0", "OFF", "DISABLE"];
-  const normalizedText = value.trim().toUpperCase();
-  if (affirmative.includes(normalizedText)) {
-    return true;
-  }
-  if (negative.includes(normalizedText)) {
-    return false;
-  }
-  return false;
-}
-var uuidSchema = z.string().uuid();
-function validateUuid(value) {
-  const result = uuidSchema.safeParse(value);
-  return result.success ? result.data : null;
-}
-function stringToUuid(target) {
-  if (typeof target === "number") {
-    target = target.toString();
-  }
-  if (typeof target !== "string") {
-    throw TypeError("Value must be string");
-  }
-  const _uint8ToHex = (ubyte) => {
-    const first = ubyte >> 4;
-    const second = ubyte - (first << 4);
-    const HEX_DIGITS = "0123456789abcdef".split("");
-    return HEX_DIGITS[first] + HEX_DIGITS[second];
-  };
-  const _uint8ArrayToHex = (buf) => {
-    let out = "";
-    for (let i = 0; i < buf.length; i++) {
-      out += _uint8ToHex(buf[i]);
-    }
-    return out;
-  };
-  const escapedStr = encodeURIComponent(target);
-  const buffer = new Uint8Array(escapedStr.length);
-  for (let i = 0; i < escapedStr.length; i++) {
-    buffer[i] = escapedStr[i].charCodeAt(0);
-  }
-  const hash = sha1(buffer);
-  const hashBuffer = new Uint8Array(hash.length / 2);
-  for (let i = 0; i < hash.length; i += 2) {
-    hashBuffer[i / 2] = Number.parseInt(hash.slice(i, i + 2), 16);
-  }
-  return `${_uint8ArrayToHex(hashBuffer.slice(0, 4))}-${_uint8ArrayToHex(hashBuffer.slice(4, 6))}-${_uint8ToHex(hashBuffer[6] & 15)}${_uint8ToHex(hashBuffer[7])}-${_uint8ToHex(hashBuffer[8] & 63 | 128)}${_uint8ToHex(hashBuffer[9])}-${_uint8ArrayToHex(hashBuffer.slice(10, 16))}`;
-}
-
-// src/logger.ts
-var InMemoryDestination = class {
-  /**
-   * Constructor for creating a new instance of the class.
-   * @param {DestinationStream|null} stream - The stream to assign to the instance. Can be null.
-   */
-  constructor(stream) {
-    this.logs = [];
-    this.maxLogs = 1e3;
-    this.stream = stream;
-  }
-  /**
-   * Writes a log entry to the memory buffer and forwards it to the pretty print stream if available.
-   *
-   * @param {string | LogEntry} data - The data to be written, which can be either a string or a LogEntry object.
-   * @returns {void}
-   */
-  write(data) {
-    let logEntry;
-    let stringData;
-    if (typeof data === "string") {
-      stringData = data;
-      try {
-        logEntry = JSON.parse(data);
-      } catch (e) {
-        if (this.stream) {
-          this.stream.write(data);
-        }
-        return;
-      }
-    } else {
-      logEntry = data;
-      stringData = JSON.stringify(data);
-    }
-    if (!logEntry.time) {
-      logEntry.time = Date.now();
-    }
-    const isDebugMode2 = (process?.env?.LOG_LEVEL || "").toLowerCase() === "debug";
-    const isLoggingDiagnostic = Boolean(process?.env?.LOG_DIAGNOSTIC);
-    if (isLoggingDiagnostic) {
-      logEntry.diagnostic = true;
-    }
-    if (!isDebugMode2) {
-      if (logEntry.agentName && logEntry.agentId) {
-        const msg = logEntry.msg || "";
-        if (typeof msg === "string" && (msg.includes("registered successfully") || msg.includes("Registering") || msg.includes("Success:") || msg.includes("linked to") || msg.includes("Started"))) {
-          if (isLoggingDiagnostic) {
-            console.error("Filtered log:", stringData);
-          }
-          return;
-        }
-      }
-    }
-    this.logs.push(logEntry);
-    if (this.logs.length > this.maxLogs) {
-      this.logs.shift();
-    }
-    if (this.stream) {
-      this.stream.write(stringData);
-    }
+    }
+    this.logs.push(logEntry);
+    if (this.logs.length > this.maxLogs) {
+      this.logs.shift();
+    }
+    if (this.stream) {
+      this.stream.write(stringData);
+    }
   }
   /**
    * Retrieves the recent logs from the system.
@@ -1298,58 +922,540 @@ var options = {
     }
   }
 };
-var createLogger = (bindings = false) => {
-  const opts = { ...options };
-  if (bindings) {
-    opts.base = bindings;
-    opts.transport = {
-      target: "pino-pretty",
-      // this is just a string, not a dynamic import
-      options: {
-        colorize: true,
-        translateTime: "SYS:standard",
-        ignore: "pid,hostname"
-      }
+var createLogger = (bindings = false) => {
+  const opts = { ...options };
+  if (bindings) {
+    opts.base = bindings;
+    opts.transport = {
+      target: "pino-pretty",
+      // this is just a string, not a dynamic import
+      options: {
+        colorize: true,
+        translateTime: "SYS:standard",
+        ignore: "pid,hostname"
+      }
+    };
+  }
+  const logger3 = pino(opts);
+  return logger3;
+};
+var logger = pino(options);
+if (typeof process !== "undefined") {
+  let stream = null;
+  if (!raw) {
+    try {
+      const pretty = __require("pino-pretty");
+      stream = pretty.default ? pretty.default(createPrettyConfig()) : null;
+    } catch (e) {
+      createStream().then((prettyStream) => {
+        const destination = new InMemoryDestination(prettyStream);
+        logger = pino(options, destination);
+        logger[Symbol.for("pino-destination")] = destination;
+        logger.clear = () => {
+          const destination2 = logger[Symbol.for("pino-destination")];
+          if (destination2 instanceof InMemoryDestination) {
+            destination2.clear();
+          }
+        };
+      });
+    }
+  }
+  if (stream !== null || raw) {
+    const destination = new InMemoryDestination(stream);
+    logger = pino(options, destination);
+    logger[Symbol.for("pino-destination")] = destination;
+    logger.clear = () => {
+      const destination2 = logger[Symbol.for("pino-destination")];
+      if (destination2 instanceof InMemoryDestination) {
+        destination2.clear();
+      }
+    };
+  }
+}
+var elizaLogger = logger;
+var logger_default = logger;
+
+// src/utils.ts
+function upgradeDoubleToTriple(tpl) {
+  return tpl.replace(
+    // ────────╮ negative-LB: not already "{{{"
+    //          │   {{     ─ opening braces
+    //          │    ╰──── negative-LA: not {, #, /, !, >
+    //          ▼
+    /(?<!{){{(?![{#\/!>])([\s\S]*?)}}/g,
+    (_match, inner) => {
+      if (inner.trim() === "else") return `{{${inner}}}`;
+      return `{{{${inner}}}}`;
+    }
+  );
+}
+var composePrompt = ({
+  state,
+  template
+}) => {
+  const templateStr = typeof template === "function" ? template({ state }) : template;
+  const templateFunction = handlebars.compile(upgradeDoubleToTriple(templateStr));
+  const output = composeRandomUser(templateFunction(state), 10);
+  return output;
+};
+var composePromptFromState = ({
+  state,
+  template
+}) => {
+  const templateStr = typeof template === "function" ? template({ state }) : template;
+  const templateFunction = handlebars.compile(upgradeDoubleToTriple(templateStr));
+  const stateKeys = Object.keys(state);
+  const filteredKeys = stateKeys.filter((key) => !["text", "values", "data"].includes(key));
+  const filteredState = filteredKeys.reduce((acc, key) => {
+    acc[key] = state[key];
+    return acc;
+  }, {});
+  const output = composeRandomUser(templateFunction({ ...filteredState, ...state.values }), 10);
+  return output;
+};
+var addHeader = (header, body) => {
+  return body.length > 0 ? `${header ? `${header}
+` : header}${body}
+` : "";
+};
+var composeRandomUser = (template, length) => {
+  const exampleNames = Array.from(
+    { length },
+    () => uniqueNamesGenerator({ dictionaries: [names] })
+  );
+  let result = template;
+  for (let i = 0; i < exampleNames.length; i++) {
+    result = result.replaceAll(`{{name${i + 1}}}`, exampleNames[i]);
+  }
+  return result;
+};
+var formatPosts = ({
+  messages,
+  entities,
+  conversationHeader = true
+}) => {
+  const groupedMessages = {};
+  messages.forEach((message) => {
+    if (message.roomId) {
+      if (!groupedMessages[message.roomId]) {
+        groupedMessages[message.roomId] = [];
+      }
+      groupedMessages[message.roomId].push(message);
+    }
+  });
+  Object.values(groupedMessages).forEach((roomMessages) => {
+    roomMessages.sort((a, b) => a.createdAt - b.createdAt);
+  });
+  const sortedRooms = Object.entries(groupedMessages).sort(
+    ([, messagesA], [, messagesB]) => messagesB[messagesB.length - 1].createdAt - messagesA[messagesA.length - 1].createdAt
+  );
+  const formattedPosts = sortedRooms.map(([roomId, roomMessages]) => {
+    const messageStrings = roomMessages.filter((message) => message.entityId).map((message) => {
+      const entity = entities.find((entity2) => entity2.id === message.entityId);
+      if (!entity) {
+        logger_default.warn("core::prompts:formatPosts - no entity for", message.entityId);
+      }
+      const userName = entity?.names[0] || "Unknown User";
+      const displayName = entity?.names[0] || "unknown";
+      return `Name: ${userName} (@${displayName} EntityID:${message.entityId})
+MessageID: ${message.id}${message.content.inReplyTo ? `
+In reply to: ${message.content.inReplyTo}` : ""}
+Source: ${message.content.source}
+Date: ${formatTimestamp(message.createdAt)}
+Text:
+${message.content.text}`;
+    });
+    const header = conversationHeader ? `Conversation: ${roomId.slice(-5)}
+` : "";
+    return `${header}${messageStrings.join("\n\n")}`;
+  });
+  return formattedPosts.join("\n\n");
+};
+var formatMessages = ({
+  messages,
+  entities
+}) => {
+  const messageStrings = messages.reverse().filter((message) => message.entityId).map((message) => {
+    const messageText = message.content.text;
+    const messageActions = message.content.actions;
+    const messageThought = message.content.thought;
+    const formattedName = entities.find((entity) => entity.id === message.entityId)?.names[0] || "Unknown User";
+    const attachments = message.content.attachments;
+    const attachmentString = attachments && attachments.length > 0 ? ` (Attachments: ${attachments.map((media) => `[${media.id} - ${media.title} (${media.url})]`).join(", ")})` : null;
+    const messageTime = new Date(message.createdAt);
+    const hours = messageTime.getHours().toString().padStart(2, "0");
+    const minutes = messageTime.getMinutes().toString().padStart(2, "0");
+    const timeString = `${hours}:${minutes}`;
+    const timestamp = formatTimestamp(message.createdAt);
+    const thoughtString = messageThought ? `(${formattedName}'s internal thought: ${messageThought})` : null;
+    const timestampString = `${timeString} (${timestamp}) [${message.entityId}]`;
+    const textString = messageText ? `${timestampString} ${formattedName}: ${messageText}` : null;
+    const actionString = messageActions && messageActions.length > 0 ? `${textString ? "" : timestampString} (${formattedName}'s actions: ${messageActions.join(", ")})` : null;
+    const messageString = [textString, thoughtString, actionString, attachmentString].filter(Boolean).join("\n");
+    return messageString;
+  }).join("\n");
+  return messageStrings;
+};
+var formatTimestamp = (messageDate) => {
+  const now = /* @__PURE__ */ new Date();
+  const diff = now.getTime() - messageDate;
+  const absDiff = Math.abs(diff);
+  const seconds = Math.floor(absDiff / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  if (absDiff < 6e4) {
+    return "just now";
+  }
+  if (minutes < 60) {
+    return `${minutes} minute${minutes !== 1 ? "s" : ""} ago`;
+  }
+  if (hours < 24) {
+    return `${hours} hour${hours !== 1 ? "s" : ""} ago`;
+  }
+  return `${days} day${days !== 1 ? "s" : ""} ago`;
+};
+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];
+    logger_default.debug("Found response XML block");
+  } else {
+    const fallbackMatch = text.match(/<(\w+)>([\s\S]*?)<\/\1>/);
+    if (!fallbackMatch) {
+      logger_default.warn("Could not find XML block in text");
+      logger_default.debug("Text content:", text.substring(0, 200) + "...");
+      return null;
+    }
+    xmlContent = fallbackMatch[2];
+    logger_default.debug(`Found XML block with tag: ${fallbackMatch[1]}`);
+  }
+  const result = {};
+  const tagPattern = /<([\w-]+)>([\s\S]*?)<\/([\w-]+)>/g;
+  let match;
+  while ((match = tagPattern.exec(xmlContent)) !== null) {
+    if (match[1] === match[3]) {
+      const key = match[1];
+      const value = match[2].replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&").replace(/&quot;/g, '"').replace(/&apos;/g, "'").trim();
+      if (key === "actions" || key === "providers" || key === "evaluators") {
+        result[key] = value ? value.split(",").map((s) => s.trim()) : [];
+      } else if (key === "simple") {
+        result[key] = value.toLowerCase() === "true";
+      } else {
+        result[key] = value;
+      }
+    } else {
+      logger_default.warn(`Mismatched XML tags found: <${match[1]}> and </${match[3]}>`);
+    }
+  }
+  if (Object.keys(result).length === 0) {
+    logger_default.warn("No key-value pairs extracted from XML content");
+    logger_default.debug("XML content was:", xmlContent.substring(0, 200) + "...");
+    return null;
+  }
+  return result;
+}
+function parseJSONObjectFromText(text) {
+  let jsonData = null;
+  const jsonBlockMatch = text.match(jsonBlockPattern);
+  try {
+    if (jsonBlockMatch) {
+      jsonData = JSON.parse(normalizeJsonString(jsonBlockMatch[1].trim()));
+    } else {
+      jsonData = JSON.parse(normalizeJsonString(text.trim()));
+    }
+  } catch (_e) {
+    return null;
+  }
+  if (jsonData && typeof jsonData === "object" && !Array.isArray(jsonData)) {
+    return jsonData;
+  }
+  return null;
+}
+var normalizeJsonString = (str) => {
+  str = str.replace(/\{\s+/, "{").replace(/\s+\}/, "}").trim();
+  str = str.replace(/("[\w\d_-]+")\s*: \s*(?!"|\[)([\s\S]+?)(?=(,\s*"|\}$))/g, '$1: "$2"');
+  str = str.replace(/"([^"]+)"\s*:\s*'([^']*)'/g, (_, key, value) => `"${key}": "${value}"`);
+  str = str.replace(/("[\w\d_-]+")\s*:\s*([A-Za-z_]+)(?!["\w])/g, '$1: "$2"');
+  return str;
+};
+function truncateToCompleteSentence(text, maxLength) {
+  if (text.length <= maxLength) {
+    return text;
+  }
+  const lastPeriodIndex = text.lastIndexOf(".", maxLength - 1);
+  if (lastPeriodIndex !== -1) {
+    const truncatedAtPeriod = text.slice(0, lastPeriodIndex + 1).trim();
+    if (truncatedAtPeriod.length > 0) {
+      return truncatedAtPeriod;
+    }
+  }
+  const lastSpaceIndex = text.lastIndexOf(" ", maxLength - 1);
+  if (lastSpaceIndex !== -1) {
+    const truncatedAtSpace = text.slice(0, lastSpaceIndex).trim();
+    if (truncatedAtSpace.length > 0) {
+      return `${truncatedAtSpace}...`;
+    }
+  }
+  const hardTruncated = text.slice(0, maxLength - 3).trim();
+  return `${hardTruncated}...`;
+}
+async function splitChunks(content, chunkSize = 512, bleed = 20) {
+  logger_default.debug("[splitChunks] Starting text split");
+  const characterstoTokens = 3.5;
+  const textSplitter = new RecursiveCharacterTextSplitter({
+    chunkSize: Number(Math.floor(chunkSize * characterstoTokens)),
+    chunkOverlap: Number(Math.floor(bleed * characterstoTokens))
+  });
+  const chunks = await textSplitter.splitText(content);
+  logger_default.debug("[splitChunks] Split complete:", {
+    numberOfChunks: chunks.length,
+    averageChunkSize: chunks.reduce((acc, chunk) => acc + chunk.length, 0) / chunks.length
+  });
+  return chunks;
+}
+async function trimTokens(prompt, maxTokens, runtime) {
+  if (!prompt) throw new Error("Trim tokens received a null prompt");
+  if (prompt.length < maxTokens / 5) return prompt;
+  if (maxTokens <= 0) throw new Error("maxTokens must be positive");
+  const tokens = await runtime.useModel(ModelType2.TEXT_TOKENIZER_ENCODE, {
+    prompt
+  });
+  if (tokens.length <= maxTokens) {
+    return prompt;
+  }
+  const truncatedTokens = tokens.slice(-maxTokens);
+  return await runtime.useModel(ModelType2.TEXT_TOKENIZER_DECODE, {
+    tokens: truncatedTokens
+  });
+}
+function safeReplacer() {
+  const seen = /* @__PURE__ */ new WeakSet();
+  return function(key, value) {
+    if (typeof value === "object" && value !== null) {
+      if (seen.has(value)) {
+        return "[Circular]";
+      }
+      seen.add(value);
+    }
+    return value;
+  };
+}
+function parseBooleanFromText2(value) {
+  if (!value) return false;
+  const affirmative = ["YES", "Y", "TRUE", "T", "1", "ON", "ENABLE"];
+  const negative = ["NO", "N", "FALSE", "F", "0", "OFF", "DISABLE"];
+  const normalizedText = value.trim().toUpperCase();
+  if (affirmative.includes(normalizedText)) {
+    return true;
+  }
+  if (negative.includes(normalizedText)) {
+    return false;
+  }
+  return false;
+}
+var uuidSchema = z.string().uuid();
+function validateUuid(value) {
+  const result = uuidSchema.safeParse(value);
+  return result.success ? result.data : null;
+}
+function stringToUuid(target) {
+  if (typeof target === "number") {
+    target = target.toString();
+  }
+  if (typeof target !== "string") {
+    throw TypeError("Value must be string");
+  }
+  const _uint8ToHex = (ubyte) => {
+    const first = ubyte >> 4;
+    const second = ubyte - (first << 4);
+    const HEX_DIGITS = "0123456789abcdef".split("");
+    return HEX_DIGITS[first] + HEX_DIGITS[second];
+  };
+  const _uint8ArrayToHex = (buf) => {
+    let out = "";
+    for (let i = 0; i < buf.length; i++) {
+      out += _uint8ToHex(buf[i]);
+    }
+    return out;
+  };
+  const escapedStr = encodeURIComponent(target);
+  const buffer = new Uint8Array(escapedStr.length);
+  for (let i = 0; i < escapedStr.length; i++) {
+    buffer[i] = escapedStr[i].charCodeAt(0);
+  }
+  const hash = sha1(buffer);
+  const hashBuffer = new Uint8Array(hash.length / 2);
+  for (let i = 0; i < hash.length; i += 2) {
+    hashBuffer[i / 2] = Number.parseInt(hash.slice(i, i + 2), 16);
+  }
+  return `${_uint8ArrayToHex(hashBuffer.slice(0, 4))}-${_uint8ArrayToHex(hashBuffer.slice(4, 6))}-${_uint8ToHex(hashBuffer[6] & 15)}${_uint8ToHex(hashBuffer[7])}-${_uint8ToHex(hashBuffer[8] & 63 | 128)}${_uint8ToHex(hashBuffer[9])}-${_uint8ArrayToHex(hashBuffer.slice(10, 16))}`;
+}
+var getContentTypeFromMimeType = (mimeType) => {
+  if (mimeType.startsWith("image/")) return "image" /* IMAGE */;
+  if (mimeType.startsWith("video/")) return "video" /* VIDEO */;
+  if (mimeType.startsWith("audio/")) return "audio" /* AUDIO */;
+  if (mimeType.includes("pdf") || mimeType.includes("document") || mimeType.startsWith("text/")) {
+    return "document" /* DOCUMENT */;
+  }
+  return void 0;
+};
+
+// src/schemas/character.ts
+import { z as z2 } from "zod";
+var uuidSchema2 = z2.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i, "Invalid UUID format");
+var contentSchema = z2.object({
+  text: z2.string().optional(),
+  thought: z2.string().optional(),
+  actions: z2.array(z2.string()).optional(),
+  providers: z2.array(z2.string()).optional(),
+  source: z2.string().optional(),
+  target: z2.string().optional(),
+  url: z2.string().optional(),
+  inReplyTo: uuidSchema2.optional(),
+  attachments: z2.array(z2.any()).optional(),
+  channelType: z2.string().optional()
+}).passthrough();
+var messageExampleSchema = z2.object({
+  name: z2.string(),
+  content: contentSchema
+});
+var directoryItemSchema = z2.object({
+  directory: z2.string(),
+  shared: z2.boolean().optional()
+});
+var knowledgeItemSchema = z2.union([
+  z2.string(),
+  z2.object({
+    path: z2.string(),
+    shared: z2.boolean().optional()
+  }),
+  directoryItemSchema
+]);
+var templateTypeSchema = z2.union([
+  z2.string(),
+  z2.function().optional()
+  // Functions won't be in JSON but allowed in runtime
+]);
+var styleSchema = z2.object({
+  all: z2.array(z2.string()).optional(),
+  chat: z2.array(z2.string()).optional(),
+  post: z2.array(z2.string()).optional()
+}).optional();
+var settingsSchema = z2.record(z2.union([z2.string(), z2.boolean(), z2.number(), z2.any()])).optional();
+var secretsSchema = z2.record(z2.union([z2.string(), z2.boolean(), z2.number()])).optional();
+var characterSchema = z2.object({
+  id: uuidSchema2.optional(),
+  name: z2.string().min(1, "Character name is required"),
+  username: z2.string().optional(),
+  system: z2.string().optional(),
+  templates: z2.record(templateTypeSchema).optional(),
+  bio: z2.union([z2.string(), z2.array(z2.string())]),
+  messageExamples: z2.array(z2.array(messageExampleSchema)).optional(),
+  postExamples: z2.array(z2.string()).optional(),
+  topics: z2.array(z2.string()).optional(),
+  adjectives: z2.array(z2.string()).optional(),
+  knowledge: z2.array(knowledgeItemSchema).optional(),
+  plugins: z2.array(z2.string()).optional(),
+  settings: settingsSchema,
+  secrets: secretsSchema,
+  style: styleSchema
+}).strict();
+function validateCharacter(data) {
+  const result = characterSchema.safeParse(data);
+  if (result.success) {
+    return {
+      success: true,
+      data: result.data
     };
   }
-  const logger3 = pino(opts);
-  return logger3;
-};
-var logger = pino(options);
-if (typeof process !== "undefined") {
-  let stream = null;
-  if (!raw) {
-    try {
-      const pretty = __require("pino-pretty");
-      stream = pretty.default ? pretty.default(createPrettyConfig()) : null;
-    } catch (e) {
-      createStream().then((prettyStream) => {
-        const destination = new InMemoryDestination(prettyStream);
-        logger = pino(options, destination);
-        logger[Symbol.for("pino-destination")] = destination;
-        logger.clear = () => {
-          const destination2 = logger[Symbol.for("pino-destination")];
-          if (destination2 instanceof InMemoryDestination) {
-            destination2.clear();
-          }
-        };
-      });
+  return {
+    success: false,
+    error: {
+      message: `Character validation failed: ${result.error.message}`,
+      issues: result.error.issues
     }
-  }
-  if (stream !== null || raw) {
-    const destination = new InMemoryDestination(stream);
-    logger = pino(options, destination);
-    logger[Symbol.for("pino-destination")] = destination;
-    logger.clear = () => {
-      const destination2 = logger[Symbol.for("pino-destination")];
-      if (destination2 instanceof InMemoryDestination) {
-        destination2.clear();
+  };
+}
+function parseAndValidateCharacter(jsonString) {
+  try {
+    const parsed = JSON.parse(jsonString);
+    return validateCharacter(parsed);
+  } catch (error) {
+    return {
+      success: false,
+      error: {
+        message: `Invalid JSON: ${error instanceof Error ? error.message : "Unknown JSON parsing error"}`
       }
     };
   }
 }
-var elizaLogger = logger;
-var logger_default = logger;
+function isValidCharacter(data) {
+  return validateCharacter(data).success;
+}
+
+// src/actions.ts
+import { names as names2, uniqueNamesGenerator as uniqueNamesGenerator2 } from "unique-names-generator";
+var composeActionExamples2 = (actionsData, count) => {
+  if (!actionsData.length || count <= 0) {
+    return "";
+  }
+  const actionsWithExamples = actionsData.filter(
+    (action) => action.examples && Array.isArray(action.examples) && action.examples.length > 0
+  );
+  if (!actionsWithExamples.length) {
+    return "";
+  }
+  const examplesCopy = actionsWithExamples.map((action) => [
+    ...action.examples
+  ]);
+  const selectedExamples = [];
+  let availableActionIndices = examplesCopy.map((examples, index) => examples.length > 0 ? index : -1).filter((index) => index !== -1);
+  while (selectedExamples.length < count && availableActionIndices.length > 0) {
+    const randomIndex = Math.floor(Math.random() * availableActionIndices.length);
+    const actionIndex = availableActionIndices[randomIndex];
+    const examples = examplesCopy[actionIndex];
+    const exampleIndex = Math.floor(Math.random() * examples.length);
+    selectedExamples.push(examples.splice(exampleIndex, 1)[0]);
+    if (examples.length === 0) {
+      availableActionIndices.splice(randomIndex, 1);
+    }
+  }
+  return formatSelectedExamples(selectedExamples);
+};
+var formatSelectedExamples = (examples) => {
+  const MAX_NAME_PLACEHOLDERS = 5;
+  return examples.map((example) => {
+    const randomNames = Array.from(
+      { length: MAX_NAME_PLACEHOLDERS },
+      () => uniqueNamesGenerator2({ dictionaries: [names2] })
+    );
+    const conversation = example.map((message) => {
+      let messageText = `${message.name}: ${message.content.text}`;
+      for (let i = 0; i < randomNames.length; i++) {
+        messageText = messageText.replaceAll(`{{name${i + 1}}}`, randomNames[i]);
+      }
+      return messageText;
+    }).join("\n");
+    return `
+${conversation}`;
+  }).join("\n");
+};
+function formatActionNames2(actions) {
+  if (!actions?.length) return "";
+  return [...actions].sort(() => Math.random() - 0.5).map((action) => action.name).join(", ");
+}
+function formatActions2(actions) {
+  if (!actions?.length) return "";
+  return [...actions].sort(() => Math.random() - 0.5).map((action) => `${action.name}: ${action.description}`).join(",\n");
+}
+
+// src/database.ts
+var DatabaseAdapter2 = class {
+};
 
 // src/prompts.ts
 var shouldRespondTemplate = `<task>Decide on behalf of {{agentName}} whether they should respond to the message, ignore it or stop the conversation.</task>
@@ -1388,78 +1494,35 @@ These are the available valid actions:
 </actionNames>
 
 <instructions>
-Analyze the message and create a response plan for {{agentName}}.
+Write a thought and plan for {{agentName}} and decide what actions to take. Also include the providers that {{agentName}} will use to have the right context for responding and acting, if any.
 
-STEP 1 - DETERMINE RESPONSE TYPE:
-- SIMPLE RESPONSE: If you only need to send a text reply without any tools, data lookups, or complex operations
-  \u2192 Use only REPLY action with no providers
-  \u2192 This is the preferred path for basic conversations
-  \u2192 Do NOT use this for questions that require checking stored knowledge!
-  
-- COMPLEX RESPONSE: If you need to:
-  \u2192 Use external tools or services (CALL_TOOL, etc.)
-  \u2192 Look up specific information (needs providers like KNOWLEDGE, ATTACHMENTS, etc.)
-  \u2192 Answer questions about what you know or might know (ALWAYS check KNOWLEDGE first!)
-  \u2192 Perform multiple operations
-  \u2192 Update data or settings
+IMPORTANT ACTION ORDERING RULES:
+- Actions are executed in the ORDER you list them - the order MATTERS!
+- REPLY should come FIRST to acknowledge the user's request before executing other actions
+- Common patterns:
+  - For requests requiring tool use: REPLY,CALL_MCP_TOOL (acknowledge first, then gather info)
+  - For task execution: REPLY,SEND_MESSAGE or REPLY,EVM_SWAP_TOKENS (acknowledge first, then do the task)
+  - For multi-step operations: REPLY,ACTION1,ACTION2 (acknowledge first, then complete all steps)
+- REPLY is used to acknowledge and inform the user about what you're going to do
+- Follow-up actions execute the actual tasks after acknowledgment
+- Use IGNORE only when you should not respond at all
 
-STEP 2 - PROVIDER SELECTION (for complex responses):
 IMPORTANT PROVIDER SELECTION RULES:
 - If the message mentions images, photos, pictures, attachments, or visual content, OR if you see "(Attachments:" in the conversation, you MUST include "ATTACHMENTS" in your providers list
 - If the message asks about or references specific people, include "ENTITIES" in your providers list  
 - If the message asks about relationships or connections between people, include "RELATIONSHIPS" in your providers list
 - If the message asks about facts or specific information, include "FACTS" in your providers list
 - If the message asks about the environment or world context, include "WORLD" in your providers list
-- **CRITICAL: If the message asks "do you know", "who created", "what is", "tell me about", or ANY question that might be answered by stored knowledge, you MUST include "KNOWLEDGE" in your providers list. Always check KNOWLEDGE before saying you don't know something!**
-- Some actions may require specific providers (this will be clear from the action's purpose)
-
-REMEMBER: It's better to check providers and find nothing than to assume you don't have information without checking!
+- If you need external knowledge, information, or context beyond the current conversation to provide a helpful response, include "KNOWLEDGE" in your providers list
 
-STEP 3 - ACTION PLANNING:
-For complex responses, consider the order of actions:
-- If using tools (CALL_TOOL, etc.): First REPLY to acknowledge the request (e.g., "Let me check that for you"), then execute the tool action
-- Tool actions often handle their own responses, so you may not need a final REPLY after them
-- Actions should flow logically: acknowledge \u2192 gather data \u2192 process \u2192 respond
-
-Think about your response as a plan:
-1. What is the user asking for?
-2. Do I need any additional context or data? (providers)
-3. What actions do I need to take and in what order?
-4. How will I communicate the results?
+First, think about what you want to do next and plan your actions. Then, write the next message and include the actions you plan to take.
 </instructions>
 
-<output_format>
-First, think about what you want to do and create your plan.
-
-For SIMPLE responses (text-only reply):
-- Set thought to explain your reasoning
-- Set actions to ["REPLY"]
-- Leave providers empty or set to []
-- Set text to your response message
-
-For COMPLEX responses (using tools/providers):
-- Set thought to explain your plan and reasoning
-- Set actions in the order they should execute (e.g., ["REPLY", "CALL_TOOL"])
-- Set providers to gather needed context
-- Set text for your initial response (if using REPLY first)
-
-Remember: Some actions like CALL_TOOL will send their own responses, so plan accordingly.
-</output_format>
-
-<response>
-    <thought>User asking if I know something - must check KNOWLEDGE provider first before saying I don't know</thought>
-    <actions>REPLY</actions>
-    <providers>KNOWLEDGE</providers>
-    <text>Let me check if I have any information about Roxane's creator...</text>
-</response>
-</examples>
-
 <keys>
-"thought" should be a short description of what the agent is thinking about and their plan
-"actions" should be a comma-separated list of the actions {{agentName}} plans to take in order (if none, use IGNORE, if simply responding with text, use REPLY)
-"providers" should be a comma-separated list of the providers that {{agentName}} will use to have the right context for responding and acting (leave empty for simple responses)
-"evaluators" should be an optional comma-separated list of the evaluators that {{agentName}} will use to evaluate the conversation after responding
-"text" should be the text of the next message for {{agentName}} (used with REPLY action)
+"thought" should be a short description of what the agent is thinking about and planning.
+"actions" should be a comma-separated list of the actions {{agentName}} plans to take based on the thought, IN THE ORDER THEY SHOULD BE EXECUTED (if none, use IGNORE, if simply responding with text, use REPLY)
+"providers" should be a comma-separated list of the providers that {{agentName}} will use to have the right context for responding and acting (NEVER use "IGNORE" as a provider - use specific provider names like ATTACHMENTS, ENTITIES, FACTS, KNOWLEDGE, etc.)
+"text" should be the text of the next message for {{agentName}} which they will send to the conversation.
 </keys>
 
 <output>
@@ -2639,9 +2702,9 @@ var AgentRuntime = class {
     this.character = opts.character;
     const logLevel = process.env.LOG_LEVEL || "info";
     this.logger = createLogger({
-      agentName: this.character?.name
+      agentName: this.character?.name,
+      logLevel
     });
-    this.logger.debug(`[AgentRuntime] Process working directory: ${process.cwd()}`);
     this.#conversationLength = opts.conversationLength ?? this.#conversationLength;
     if (opts.adapter) {
       this.registerDatabaseAdapter(opts.adapter);
@@ -2658,8 +2721,37 @@ var AgentRuntime = class {
       }
     }
     this.logger.debug(`Success: Agent ID: ${this.agentId}`);
+    this.currentRunId = void 0;
   }
   #conversationLength;
+  /**
+   * Create a new run ID for tracking a sequence of model calls
+   */
+  createRunId() {
+    return uuidv4();
+  }
+  /**
+   * Start a new run for tracking prompts
+   */
+  startRun() {
+    this.currentRunId = this.createRunId();
+    return this.currentRunId;
+  }
+  /**
+   * End the current run
+   */
+  endRun() {
+    this.currentRunId = void 0;
+  }
+  /**
+   * Get the current run ID (creates one if it doesn't exist)
+   */
+  getCurrentRunId() {
+    if (!this.currentRunId) {
+      this.currentRunId = this.createRunId();
+    }
+    return this.currentRunId;
+  }
   async registerPlugin(plugin) {
     if (!plugin?.name) {
       const errorMsg = "Plugin or plugin name is undefined";
@@ -3045,6 +3137,12 @@ var AgentRuntime = class {
         }
         try {
           this.logger.debug(`Executing handler for action: ${action.name}`);
+          const actionId = uuidv4();
+          this.currentActionContext = {
+            actionName: action.name,
+            actionId,
+            prompts: []
+          };
           const result = await action.handler(this, message, state, {}, callback, responses);
           this.logger.debug(`Success: Action ${action.name} executed successfully.`);
           this.adapter.log({
@@ -3053,15 +3151,20 @@ var AgentRuntime = class {
             type: "action",
             body: {
               action: action.name,
+              actionId,
               message: message.content.text,
               messageId: message.id,
               state,
-              responses
+              responses,
+              prompts: this.currentActionContext?.prompts || [],
+              promptCount: this.currentActionContext?.prompts.length || 0
             }
           });
+          this.currentActionContext = void 0;
         } catch (error) {
           const errorMessage = error instanceof Error ? error.message : String(error);
           this.logger.error(error);
+          this.currentActionContext = void 0;
           const actionMemory = {
             id: uuidv4(),
             content: {
@@ -3609,13 +3712,43 @@ var AgentRuntime = class {
         `[useModel] ${modelKey} output (took ${Number(elapsedTime.toFixed(2)).toLocaleString()}ms):`,
         Array.isArray(response) ? `${JSON.stringify(response.slice(0, 5))}...${JSON.stringify(response.slice(-5))} (${response.length} items)` : JSON.stringify(response, safeReplacer(), 2).replace(/\\n/g, "\n")
       );
+      if (modelKey !== ModelType2.TEXT_EMBEDDING && promptContent) {
+        if (this.currentActionContext) {
+          this.currentActionContext.prompts.push({
+            modelType: modelKey,
+            prompt: promptContent,
+            timestamp: Date.now()
+          });
+        }
+        await this.adapter.log({
+          entityId: this.agentId,
+          roomId: this.agentId,
+          body: {
+            modelType,
+            modelKey,
+            prompt: promptContent,
+            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
+            } : void 0
+          },
+          type: `prompt:${modelKey}`
+        });
+      }
       this.adapter.log({
         entityId: this.agentId,
         roomId: this.agentId,
         body: {
           modelType,
           modelKey,
-          params: params ? typeof params === "object" ? Object.keys(params) : typeof params : null,
+          params: {
+            ...typeof params === "object" && !Array.isArray(params) && params ? params : {},
+            prompt: promptContent
+          },
           response: Array.isArray(response) && response.every((x) => typeof x === "number") ? "[array]" : response
         },
         type: `useModel:${modelKey}`
@@ -3812,6 +3945,24 @@ var AgentRuntime = class {
   async getMemories(params) {
     return await this.adapter.getMemories(params);
   }
+  async getAllMemories() {
+    const tables = ["memories", "messages", "facts", "documents"];
+    const allMemories = [];
+    for (const tableName of tables) {
+      try {
+        const memories = await this.adapter.getMemories({
+          agentId: this.agentId,
+          tableName,
+          count: 1e4
+          // Get a large number to fetch all
+        });
+        allMemories.push(...memories);
+      } catch (error) {
+        this.logger.debug(`Failed to get memories from table ${tableName}:`, error);
+      }
+    }
+    return allMemories;
+  }
   async getMemoryById(id) {
     return await this.adapter.getMemoryById(id);
   }
@@ -3856,6 +4007,18 @@ var AgentRuntime = class {
   async deleteManyMemories(memoryIds) {
     await this.adapter.deleteManyMemories(memoryIds);
   }
+  async clearAllAgentMemories() {
+    this.logger.info(`Clearing all memories for agent ${this.character.name} (${this.agentId})`);
+    const allMemories = await this.getAllMemories();
+    const memoryIds = allMemories.map((memory) => memory.id);
+    if (memoryIds.length === 0) {
+      this.logger.info("No memories found to delete");
+      return;
+    }
+    this.logger.info(`Found ${memoryIds.length} memories to delete`);
+    await this.adapter.deleteManyMemories(memoryIds);
+    this.logger.info(`Successfully cleared all ${memoryIds.length} memories for agent`);
+  }
   async deleteAllMemories(roomId, tableName) {
     await this.adapter.deleteAllMemories(roomId, tableName);
   }
@@ -5351,6 +5514,12 @@ var AgentRuntime2 = class {
   async addEmbeddingToMemory(memory) {
     return this._runtime.addEmbeddingToMemory(memory);
   }
+  async getAllMemories() {
+    return this._runtime.getAllMemories();
+  }
+  async clearAllAgentMemories() {
+    return this._runtime.clearAllAgentMemories();
+  }
   async getMemories(params) {
     return this._runtime.getMemories(params);
   }
@@ -5510,15 +5679,38 @@ var AgentRuntime2 = class {
   async sendControlMessage(params) {
     return this._runtime.sendControlMessage(params);
   }
+  /**
+   * Register a message send handler for a specific source
+   * @param source - The source identifier (e.g., 'discord', 'telegram')
+   * @param handler - The handler function to send messages
+   */
   registerSendHandler(source, handler) {
-    return this._runtime.registerSendHandler(source, handler);
+    this._runtime.registerSendHandler(source, handler);
   }
+  /**
+   * Send a message to a specific target
+   * @param target - The target information including source and channel/user ID
+   * @param content - The message content to send
+   */
   async sendMessageToTarget(target, content) {
     return this._runtime.sendMessageToTarget(target, content);
   }
   async getMemoriesByWorldId(params) {
     return this._runtime.getMemoriesByWorldId(params);
   }
+  // Run tracking methods
+  createRunId() {
+    return this._runtime.createRunId();
+  }
+  startRun() {
+    return this._runtime.startRun();
+  }
+  endRun() {
+    return this._runtime.endRun();
+  }
+  getCurrentRunId() {
+    return this._runtime.getCurrentRunId();
+  }
 };
 
 // src/specs/v2/settings.ts
@@ -5615,8 +5807,8 @@ function parseKeyValueXml2(text) {
 function parseJSONObjectFromText2(text) {
   return parseJSONObjectFromText(text);
 }
-function parseBooleanFromText2(text) {
-  return parseBooleanFromText(text);
+function parseBooleanFromText3(text) {
+  return parseBooleanFromText2(text);
 }
 function safeReplacer2() {
   return safeReplacer();
@@ -5671,10 +5863,6 @@ export {
   SOCKET_MESSAGE_TYPE2 as SOCKET_MESSAGE_TYPE,
   IWalletService,
   ILpService,
-  composeActionExamples2 as composeActionExamples,
-  formatActionNames2 as formatActionNames,
-  formatActions2 as formatActions,
-  DatabaseAdapter2 as DatabaseAdapter,
   Sentry,
   createLogger,
   logger,
@@ -5692,9 +5880,18 @@ export {
   splitChunks,
   trimTokens,
   safeReplacer,
-  parseBooleanFromText,
+  parseBooleanFromText2 as parseBooleanFromText,
   validateUuid,
   stringToUuid,
+  getContentTypeFromMimeType,
+  characterSchema,
+  validateCharacter,
+  parseAndValidateCharacter,
+  isValidCharacter,
+  composeActionExamples2 as composeActionExamples,
+  formatActionNames2 as formatActionNames,
+  formatActions2 as formatActions,
+  DatabaseAdapter2 as DatabaseAdapter,
   findEntityByName,
   createUniqueUuid,
   getEntityDetails,
@@ -5799,7 +5996,7 @@ export {
   truncateToCompleteSentence2,
   parseKeyValueXml2,
   parseJSONObjectFromText2,
-  parseBooleanFromText2,
+  parseBooleanFromText3 as parseBooleanFromText2,
   safeReplacer2,
   trimTokens2,
   ServiceBuilder2,