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

package/dist/index.js

@@ -1,30 +1,98 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/dedent/dist/dedent.js
+var require_dedent = __commonJS({
+  "../../node_modules/dedent/dist/dedent.js"(exports, module) {
+    "use strict";
+    function dedent3(strings) {
+      var raw2 = void 0;
+      if (typeof strings === "string") {
+        raw2 = [strings];
+      } else {
+        raw2 = strings.raw;
+      }
+      var result = "";
+      for (var i = 0; i < raw2.length; i++) {
+        result += raw2[i].replace(/\\\n[ \t]*/g, "").replace(/\\`/g, "`");
+        if (i < (arguments.length <= 1 ? 0 : arguments.length - 1)) {
+          result += arguments.length <= i + 1 ? void 0 : arguments[i + 1];
+        }
+      }
+      var lines = result.split("\n");
+      var mindent = null;
+      lines.forEach(function(l) {
+        var m = l.match(/^(\s+)\S+/);
+        if (m) {
+          var indent = m[1].length;
+          if (!mindent) {
+            mindent = indent;
+          } else {
+            mindent = Math.min(mindent, indent);
+          }
+        }
+      });
+      if (mindent !== null) {
+        result = lines.map(function(l) {
+          return l[0] === " " ? l.slice(mindent) : l;
+        }).join("\n");
+      }
+      result = result.trim();
+      return result.replace(/\\n/g, "\n");
+    }
+    if (typeof module !== "undefined") {
+      module.exports = dedent3;
+    }
+  }
+});
+
 // src/types.ts
-var GoalStatus = /* @__PURE__ */ ((GoalStatus2) => {
-  GoalStatus2["DONE"] = "DONE";
-  GoalStatus2["FAILED"] = "FAILED";
-  GoalStatus2["IN_PROGRESS"] = "IN_PROGRESS";
-  return GoalStatus2;
-})(GoalStatus || {});
 var ModelTypes = {
-  SMALL: "text_small",
+  SMALL: "TEXT_SMALL",
   // kept for backwards compatibility
-  MEDIUM: "text_large",
+  MEDIUM: "TEXT_LARGE",
   // kept for backwards compatibility
-  LARGE: "text_large",
+  LARGE: "TEXT_LARGE",
   // kept for backwards compatibility
-  TEXT_SMALL: "text_small",
-  TEXT_LARGE: "text_large",
-  TEXT_EMBEDDING: "text_embedding",
+  TEXT_SMALL: "TEXT_SMALL",
+  TEXT_LARGE: "TEXT_LARGE",
+  TEXT_EMBEDDING: "TEXT_EMBEDDING",
   TEXT_TOKENIZER_ENCODE: "TEXT_TOKENIZER_ENCODE",
   TEXT_TOKENIZER_DECODE: "TEXT_TOKENIZER_DECODE",
-  TEXT_REASONING_SMALL: "reasoning_small",
-  TEXT_REASONING_LARGE: "reasoning_large",
-  IMAGE: "image",
-  IMAGE_DESCRIPTION: "image_description",
-  TRANSCRIPTION: "transcription",
-  TEXT_TO_SPEECH: "text_to_speech",
-  AUDIO: "audio",
-  VIDEO: "video"
+  TEXT_REASONING_SMALL: "REASONING_SMALL",
+  TEXT_REASONING_LARGE: "REASONING_LARGE",
+  TEXT_COMPLETION: "TEXT_COMPLETION",
+  IMAGE: "IMAGE",
+  IMAGE_DESCRIPTION: "IMAGE_DESCRIPTION",
+  TRANSCRIPTION: "TRANSCRIPTION",
+  TEXT_TO_SPEECH: "TEXT_TO_SPEECH",
+  AUDIO: "AUDIO",
+  VIDEO: "VIDEO",
+  OBJECT_SMALL: "OBJECT_SMALL",
+  OBJECT_LARGE: "OBJECT_LARGE"
 };
 var ServiceTypes = {
   TRANSCRIPTION: "transcription",
@@ -59,17 +127,11 @@ var ChannelType = /* @__PURE__ */ ((ChannelType2) => {
   return ChannelType2;
 })(ChannelType || {});
 var Service = class {
-  /** Runtime instance */
-  runtime;
   constructor(runtime) {
     if (runtime) {
       this.runtime = runtime;
     }
   }
-  /** Service type */
-  static serviceType;
-  /** Service configuration */
-  config;
   /** Start service connection */
   static async start(_runtime) {
     throw new Error("Not implemented");
@@ -89,7 +151,6 @@ var CacheKeyPrefix = /* @__PURE__ */ ((CacheKeyPrefix2) => {
   return CacheKeyPrefix2;
 })(CacheKeyPrefix || {});
 var TeeLogDAO = class {
-  db;
 };
 var TEEMode = /* @__PURE__ */ ((TEEMode2) => {
   TEEMode2["OFF"] = "OFF";
@@ -109,6 +170,37 @@ var Role = /* @__PURE__ */ ((Role2) => {
   Role2["NONE"] = "NONE";
   return Role2;
 })(Role || {});
+var EventTypes = /* @__PURE__ */ ((EventTypes2) => {
+  EventTypes2["WORLD_JOINED"] = "WORLD_JOINED";
+  EventTypes2["WORLD_CONNECTED"] = "WORLD_CONNECTED";
+  EventTypes2["WORLD_LEFT"] = "WORLD_LEFT";
+  EventTypes2["ENTITY_JOINED"] = "ENTITY_JOINED";
+  EventTypes2["ENTITY_LEFT"] = "ENTITY_LEFT";
+  EventTypes2["ENTITY_UPDATED"] = "ENTITY_UPDATED";
+  EventTypes2["ROOM_JOINED"] = "ROOM_JOINED";
+  EventTypes2["ROOM_LEFT"] = "ROOM_LEFT";
+  EventTypes2["MESSAGE_RECEIVED"] = "MESSAGE_RECEIVED";
+  EventTypes2["MESSAGE_SENT"] = "MESSAGE_SENT";
+  EventTypes2["VOICE_MESSAGE_RECEIVED"] = "VOICE_MESSAGE_RECEIVED";
+  EventTypes2["VOICE_MESSAGE_SENT"] = "VOICE_MESSAGE_SENT";
+  EventTypes2["REACTION_RECEIVED"] = "REACTION_RECEIVED";
+  EventTypes2["POST_GENERATED"] = "POST_GENERATED";
+  EventTypes2["INTERACTION_RECEIVED"] = "INTERACTION_RECEIVED";
+  EventTypes2["RUN_STARTED"] = "RUN_STARTED";
+  EventTypes2["RUN_ENDED"] = "RUN_ENDED";
+  EventTypes2["RUN_TIMEOUT"] = "RUN_TIMEOUT";
+  EventTypes2["ACTION_STARTED"] = "ACTION_STARTED";
+  EventTypes2["ACTION_COMPLETED"] = "ACTION_COMPLETED";
+  EventTypes2["EVALUATOR_STARTED"] = "EVALUATOR_STARTED";
+  EventTypes2["EVALUATOR_COMPLETED"] = "EVALUATOR_COMPLETED";
+  return EventTypes2;
+})(EventTypes || {});
+var PlatformPrefix = /* @__PURE__ */ ((PlatformPrefix2) => {
+  PlatformPrefix2["DISCORD"] = "DISCORD";
+  PlatformPrefix2["TELEGRAM"] = "TELEGRAM";
+  PlatformPrefix2["TWITTER"] = "TWITTER";
+  return PlatformPrefix2;
+})(PlatformPrefix || {});
 
 // src/actions.ts
 import { names, uniqueNamesGenerator } from "unique-names-generator";
@@ -160,10 +252,6 @@ function formatActions(actions) {
 
 // src/database.ts
 var DatabaseAdapter = class {
-  /**
-   * The database instance.
-   */
-  db;
 };
 
 // src/prompts.ts
@@ -175,13 +263,21 @@ import { names as names2, uniqueNamesGenerator as uniqueNamesGenerator2 } from "
 import pino from "pino";
 import pretty from "pino-pretty";
 var InMemoryDestination = class {
-  logs = [];
-  maxLogs = 1e3;
-  // Keep last 1000 logs
-  stream;
+  /**
+   * Constructor for creating a new instance of the class.
+   * @param {DestinationStream|null} stream - The stream to assign to the instance. Can be null.
+   */
   constructor(stream2) {
+    this.logs = [];
+    this.maxLogs = 1e3;
     this.stream = stream2;
   }
+  /**
+   * 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) {
     const logEntry = typeof data === "string" ? JSON.parse(data) : data;
     if (!logEntry.time) {
@@ -196,6 +292,11 @@ var InMemoryDestination = class {
       this.stream.write(stringData);
     }
   }
+  /**
+   * Retrieves the recent logs from the system.
+   *
+   * @returns {LogEntry[]} An array of LogEntry objects representing the recent logs.
+   */
   recentLogs() {
     return this.logs;
   }
@@ -264,7 +365,27 @@ var composePrompt = ({
 }) => {
   const templateStr = typeof template === "function" ? template({ state }) : template;
   const templateFunction = handlebars.compile(templateStr);
-  const output = composeRandomUser(templateFunction(state.values), 10);
+  const output = composeRandomUser(templateFunction(state), 10);
+  return output;
+};
+var composePromptFromState = ({
+  state,
+  template
+}) => {
+  const templateStr = typeof template === "function" ? template({ state }) : template;
+  const templateFunction = handlebars.compile(templateStr);
+  const stateKeys = Object.keys(state);
+  const filteredKeys = stateKeys.filter(
+    (key) => !["text", "values", "data"].includes(key)
+  );
+  const 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) => {
@@ -279,7 +400,7 @@ var composeRandomUser = (template, length) => {
   );
   let result = template;
   for (let i = 0; i < exampleNames.length; i++) {
-    result = result.replaceAll(`{{user${i + 1}}}`, exampleNames[i]);
+    result = result.replaceAll(`{{name${i + 1}}}`, exampleNames[i]);
   }
   return result;
 };
@@ -390,6 +511,7 @@ Response format should be formatted in a valid JSON block like this:
 \`\`\`json
 {
     "name": "{{agentName}}",
+	"reasoning": "<string>",
     "action": "RESPOND" | "IGNORE" | "STOP",
     "providers": ["<string>", "<string>", ...]
 }
@@ -680,13 +802,13 @@ async function getRecentInteractions(runtime, sourceEntityId, candidateEntities,
 }
 async function findEntityByName(runtime, message, state) {
   try {
-    const room = state.data.room ?? await runtime.getDatabaseAdapter().getRoom(message.roomId);
+    const room = state.data.room ?? await runtime.getRoom(message.roomId);
     if (!room) {
       logger.warn("Room not found for entity search");
       return null;
     }
-    const world = room.worldId ? await runtime.getDatabaseAdapter().getWorld(room.worldId) : null;
-    const entitiesInRoom = await runtime.getDatabaseAdapter().getEntitiesForRoom(room.id, true);
+    const world = room.worldId ? await runtime.getWorld(room.worldId) : null;
+    const entitiesInRoom = await runtime.getEntitiesForRoom(room.id, true);
     const filteredEntities = await Promise.all(
       entitiesInRoom.map(async (entity) => {
         if (!entity.components) return entity;
@@ -703,13 +825,13 @@ async function findEntityByName(runtime, message, state) {
         return entity;
       })
     );
-    const relationships = await runtime.getDatabaseAdapter().getRelationships({
+    const relationships = await runtime.getRelationships({
       entityId: message.entityId
     });
     const relationshipEntities = await Promise.all(
       relationships.map(async (rel) => {
         const entityId = rel.sourceEntityId === message.entityId ? rel.targetEntityId : rel.sourceEntityId;
-        return runtime.getDatabaseAdapter().getEntityById(entityId);
+        return runtime.getEntityById(entityId);
       })
     );
     const allEntities = [
@@ -725,7 +847,6 @@ async function findEntityByName(runtime, message, state) {
     );
     const prompt = composePrompt({
       state: {
-        ...state,
         roomName: room.name || room.id,
         worldName: world?.name || "Unknown",
         entitiesInRoom: JSON.stringify(filteredEntities, null, 2),
@@ -744,7 +865,7 @@ async function findEntityByName(runtime, message, state) {
       return null;
     }
     if (resolution.type === "EXACT_MATCH" && resolution.entityId) {
-      const entity = await runtime.getDatabaseAdapter().getEntityById(resolution.entityId);
+      const entity = await runtime.getEntityById(resolution.entityId);
       if (entity) {
         if (entity.components) {
           const worldRoles = world?.metadata?.roles || {};
@@ -801,8 +922,8 @@ async function getEntityDetails({
   roomId
 }) {
   const [room, roomEntities] = await Promise.all([
-    runtime.getDatabaseAdapter().getRoom(roomId),
-    runtime.getDatabaseAdapter().getEntitiesForRoom(roomId, true)
+    runtime.getRoom(roomId),
+    runtime.getEntitiesForRoom(roomId, true)
   ]);
   const uniqueEntities = /* @__PURE__ */ new Map();
   for (const entity of roomEntities) {
@@ -834,9 +955,9 @@ async function getEntityDetails({
 }
 
 // src/environment.ts
-import { config } from "dotenv";
 import fs from "node:fs";
 import path from "node:path";
+import { config } from "dotenv";
 
 // ../../node_modules/zod/lib/index.mjs
 var util;
@@ -5078,14 +5199,6 @@ async function handlePluginImporting(plugins) {
 var defaultMatchThreshold = 0.1;
 var defaultMatchCount = 10;
 var MemoryManager = class {
-  /**
-   * The AgentRuntime instance associated with this manager.
-   */
-  runtime;
-  /**
-   * The name of the database table this manager operates on.
-   */
-  tableName;
   /**
    * Constructs a new MemoryManager instance.
    * @param opts Options for the manager.
@@ -5138,7 +5251,9 @@ var MemoryManager = class {
     try {
       memory.embedding = await this.runtime.useModel(
         ModelTypes.TEXT_EMBEDDING,
-        memoryText
+        {
+          text: memoryText
+        }
       );
     } catch (error) {
       logger_default.error("Failed to generate embedding:", error);
@@ -5158,7 +5273,7 @@ var MemoryManager = class {
    * @returns A Promise resolving to an array of Memory objects.
    */
   async getMemories(opts) {
-    return await this.runtime.getDatabaseAdapter().getMemories({
+    return await this.runtime.getMemories({
       roomId: opts.roomId,
       count: opts.count,
       unique: opts.unique,
@@ -5168,7 +5283,7 @@ var MemoryManager = class {
     });
   }
   async getCachedEmbeddings(content) {
-    return await this.runtime.getDatabaseAdapter().getCachedEmbeddings({
+    return await this.runtime.getCachedEmbeddings({
       query_table_name: this.tableName,
       query_threshold: 2,
       query_input: content,
@@ -5196,7 +5311,7 @@ var MemoryManager = class {
       agentId,
       unique = true
     } = opts;
-    return await this.runtime.getDatabaseAdapter().searchMemories({
+    return await this.runtime.searchMemories({
       tableName: this.tableName,
       roomId,
       embedding,
@@ -5216,7 +5331,7 @@ var MemoryManager = class {
       this.validateMetadata(memory.metadata);
       this.validateMetadataRequirements(memory.metadata);
     }
-    const existingMessage = await this.runtime.getDatabaseAdapter().getMemoryById(memory.id);
+    const existingMessage = await this.runtime.getMemoryById(memory.id);
     if (existingMessage) {
       logger_default.debug("Memory already exists, skipping");
       return;
@@ -5244,18 +5359,18 @@ var MemoryManager = class {
         null
       );
     }
-    const memoryId = await this.runtime.getDatabaseAdapter().createMemory(memory, this.tableName, unique);
+    const memoryId = await this.runtime.createMemory(memory, this.tableName, unique);
     return memoryId;
   }
   async getMemoriesByRoomIds(params) {
-    return await this.runtime.getDatabaseAdapter().getMemoriesByRoomIds({
+    return await this.runtime.getMemoriesByRoomIds({
       tableName: this.tableName,
       roomIds: params.roomIds,
       limit: params.limit
     });
   }
   async getMemoryById(id) {
-    const result = await this.runtime.getDatabaseAdapter().getMemoryById(id);
+    const result = await this.runtime.getMemoryById(id);
     if (result && result.agentId !== this.runtime.agentId) return null;
     return result;
   }
@@ -5265,7 +5380,7 @@ var MemoryManager = class {
    * @returns A Promise that resolves when the operation completes.
    */
   async removeMemory(memoryId) {
-    await this.runtime.getDatabaseAdapter().removeMemory(memoryId, this.tableName);
+    await this.runtime.removeMemory(memoryId, this.tableName);
   }
   /**
    * Removes all memories associated with a set of user IDs.
@@ -5273,7 +5388,7 @@ var MemoryManager = class {
    * @returns A Promise that resolves when the operation completes.
    */
   async removeAllMemories(roomId) {
-    await this.runtime.getDatabaseAdapter().removeAllMemories(roomId, this.tableName);
+    await this.runtime.removeAllMemories(roomId, this.tableName);
   }
   /**
    * Counts the number of memories associated with a set of user IDs, with an option for uniqueness.
@@ -5282,7 +5397,7 @@ var MemoryManager = class {
    * @returns A Promise resolving to the count of memories.
    */
   async countMemories(roomId, unique = true) {
-    return await this.runtime.getDatabaseAdapter().countMemories(roomId, unique, this.tableName);
+    return await this.runtime.countMemories(roomId, unique, this.tableName);
   }
   validateMetadataRequirements(metadata) {
     if (metadata.type === "fragment" /* FRAGMENT */) {
@@ -5300,15 +5415,15 @@ var MemoryManager = class {
 async function getUserServerRole(runtime, entityId, serverId) {
   try {
     const worldId = createUniqueUuid(runtime, serverId);
-    const world = await runtime.getDatabaseAdapter().getWorld(worldId);
+    const world = await runtime.getWorld(worldId);
     if (!world || !world.metadata?.roles) {
       return "NONE" /* NONE */;
     }
-    if (world.metadata.roles[entityId]?.role) {
-      return world.metadata.roles[entityId].role;
+    if (world.metadata.roles[entityId]) {
+      return world.metadata.roles[entityId];
     }
-    if (world.metadata.roles[entityId]?.role) {
-      return world.metadata.roles[entityId].role;
+    if (world.metadata.roles[entityId]) {
+      return world.metadata.roles[entityId];
     }
     return "NONE" /* NONE */;
   } catch (error) {
@@ -5322,7 +5437,7 @@ async function findWorldForOwner(runtime, entityId) {
       logger.error("User ID is required to find server");
       return null;
     }
-    const worlds = await runtime.getDatabaseAdapter().getAllWorlds();
+    const worlds = await runtime.getAllWorlds();
     if (!worlds || worlds.length === 0) {
       logger.info("No worlds found for this agent");
       return null;
@@ -5352,7 +5467,7 @@ var optionExtractionTemplate = `# Task: Extract selected task and option from us
 
 # Available Tasks:
 {{#each tasks}}
-Task {{taskId}}: {{name}}
+Task ID: {{taskId}} - {{name}}
 Available options:
 {{#each options}}
 - {{name}}: {{description}}
@@ -5367,13 +5482,13 @@ Available options:
 # Instructions:
 1. Review the user's message and identify which task and option they are selecting
 2. Match against the available tasks and their options, including ABORT
-3. Return the task ID and selected option name exactly as listed above
+3. Return the task ID (shortened UUID) and selected option name exactly as listed above
 4. If no clear selection is made, return null for both fields
 
 Return in JSON format:
 \`\`\`json
 {
-  "taskId": number | null,
+  "taskId": "string" | null,
   "selectedOption": "OPTION_NAME" | null
 }
 \`\`\`
@@ -5384,11 +5499,11 @@ var choiceAction = {
   similes: ["SELECT_OPTION", "SELECT", "PICK", "CHOOSE"],
   description: "Selects an option for a pending task that has multiple options",
   validate: async (runtime, message, state) => {
-    const pendingTasks = await runtime.getDatabaseAdapter().getTasks({
+    const pendingTasks = await runtime.getTasks({
       roomId: message.roomId,
       tags: ["AWAITING_CHOICE"]
     });
-    const room = state.data.room ?? await runtime.getDatabaseAdapter().getRoom(message.roomId);
+    const room = state.data.room ?? await runtime.getRoom(message.roomId);
     const userRole = await getUserServerRole(
       runtime,
       message.entityId,
@@ -5401,10 +5516,7 @@ var choiceAction = {
   },
   handler: async (runtime, message, state, _options, callback, responses) => {
     try {
-      for (const response of responses) {
-        await callback(response.content);
-      }
-      const pendingTasks = await runtime.getDatabaseAdapter().getTasks({
+      const pendingTasks = await runtime.getTasks({
         roomId: message.roomId,
         tags: ["AWAITING_CHOICE"]
       });
@@ -5417,18 +5529,26 @@ var choiceAction = {
       if (!tasksWithOptions.length) {
         throw new Error("No tasks currently have options to select from.");
       }
-      const formattedTasks = tasksWithOptions.map((task, index) => ({
-        taskId: index + 1,
-        name: task.name,
-        options: task.metadata.options.map((opt) => ({
-          name: typeof opt === "string" ? opt : opt.name,
-          description: typeof opt === "string" ? opt : opt.description || opt.name
-        }))
-      }));
+      const formattedTasks = tasksWithOptions.map((task) => {
+        const shortId = task.id.substring(0, 8);
+        return {
+          taskId: shortId,
+          fullId: task.id,
+          name: task.name,
+          options: task.metadata.options.map((opt) => ({
+            name: typeof opt === "string" ? opt : opt.name,
+            description: typeof opt === "string" ? opt : opt.description || opt.name
+          }))
+        };
+      });
+      const tasksString = formattedTasks.map((task) => {
+        return `Task ID: ${task.taskId} - ${task.name}
+Available options:
+${task.options.map((opt) => `- ${opt.name}: ${opt.description}`).join("\n")}`;
+      }).join("\n");
       const prompt = composePrompt({
         state: {
-          ...state,
-          tasks: formattedTasks,
+          tasks: tasksString,
           recentMessages: message.content.text
         },
         template: optionExtractionTemplate
@@ -5440,20 +5560,45 @@ var choiceAction = {
       const parsed = parseJSONObjectFromText(result);
       const { taskId, selectedOption } = parsed;
       if (taskId && selectedOption) {
-        const selectedTask = tasksWithOptions[taskId - 1];
+        const taskMap = new Map(
+          formattedTasks.map((task) => [task.taskId, task])
+        );
+        const taskInfo = taskMap.get(taskId);
+        if (!taskInfo) {
+          await callback({
+            text: `Could not find a task matching ID: ${taskId}. Please try again.`,
+            actions: ["SELECT_OPTION_ERROR"],
+            source: message.content.source
+          });
+          return;
+        }
+        const selectedTask = tasksWithOptions.find(
+          (task) => task.id === taskInfo.fullId
+        );
+        if (!selectedTask) {
+          await callback({
+            text: "Error locating the selected task. Please try again.",
+            actions: ["SELECT_OPTION_ERROR"],
+            source: message.content.source
+          });
+          return;
+        }
         if (selectedOption === "ABORT") {
-          await runtime.getDatabaseAdapter().deleteTask(selectedTask.id);
+          await runtime.deleteTask(selectedTask.id);
           await callback({
             text: `Task "${selectedTask.name}" has been cancelled.`,
-            actions: ["CHOOSE_OPTION"],
+            actions: ["CHOOSE_OPTION_CANCELLED"],
             source: message.content.source
           });
           return;
         }
         try {
           const taskWorker = runtime.getTaskWorker(selectedTask.name);
-          await taskWorker.execute(runtime, { option: selectedOption });
-          await runtime.getDatabaseAdapter().deleteTask(selectedTask.id);
+          await taskWorker.execute(
+            runtime,
+            { option: selectedOption },
+            selectedTask
+          );
           await callback({
             text: `Selected option: ${selectedOption} for task: ${selectedTask.name}`,
             actions: ["CHOOSE_OPTION"],
@@ -5471,8 +5616,9 @@ var choiceAction = {
         }
       }
       let optionsText = "Please select a valid option from one of these tasks:\n\n";
-      tasksWithOptions.forEach((task, index) => {
-        optionsText += `${index + 1}. **${task.name}**:
+      tasksWithOptions.forEach((task) => {
+        const shortId = task.id.substring(0, 8);
+        optionsText += `**${task.name}** (ID: ${shortId}):
 `;
         const options2 = task.metadata.options.map(
           (opt) => typeof opt === "string" ? opt : opt.name
@@ -5566,12 +5712,12 @@ var followRoomAction = {
       return false;
     }
     const roomId = message.roomId;
-    const roomState = await runtime.getDatabaseAdapter().getParticipantUserState(roomId, runtime.agentId);
+    const roomState = await runtime.getParticipantUserState(roomId, runtime.agentId);
     return roomState !== "FOLLOWED" && roomState !== "MUTED";
   },
   handler: async (runtime, message, state, _options, _callback, _responses) => {
     async function _shouldFollow(state2) {
-      const shouldFollowPrompt = composePrompt({
+      const shouldFollowPrompt = composePromptFromState({
         state: state2,
         template: shouldFollowTemplate
         // Define this template separately
@@ -5618,9 +5764,9 @@ var followRoomAction = {
       return false;
     }
     if (await _shouldFollow(state)) {
-      await runtime.getDatabaseAdapter().setParticipantUserState(message.roomId, runtime.agentId, "FOLLOWED");
+      await runtime.setParticipantUserState(message.roomId, runtime.agentId, "FOLLOWED");
     }
-    const room = state.data.room ?? await runtime.getDatabaseAdapter().getRoom(message.roomId);
+    const room = state.data.room ?? await runtime.getRoom(message.roomId);
     await runtime.getMemoryManager("messages").createMemory({
       entityId: message.entityId,
       agentId: message.agentId,
@@ -6150,12 +6296,12 @@ var muteRoomAction = {
   description: "Mutes a room, ignoring all messages unless explicitly mentioned. Only do this if explicitly asked to, or if you're annoying people.",
   validate: async (runtime, message) => {
     const roomId = message.roomId;
-    const roomState = await runtime.getDatabaseAdapter().getParticipantUserState(roomId, runtime.agentId);
+    const roomState = await runtime.getParticipantUserState(roomId, runtime.agentId);
     return roomState !== "MUTED";
   },
   handler: async (runtime, message, state, _options, _callback, _responses) => {
     async function _shouldMute(state2) {
-      const shouldMutePrompt = composePrompt({
+      const shouldMutePrompt = composePromptFromState({
         state: state2,
         template: shouldMuteTemplate
         // Define this template separately
@@ -6201,9 +6347,9 @@ var muteRoomAction = {
       return false;
     }
     if (await _shouldMute(state)) {
-      await runtime.getDatabaseAdapter().setParticipantUserState(message.roomId, runtime.agentId, "MUTED");
+      await runtime.setParticipantUserState(message.roomId, runtime.agentId, "MUTED");
     }
-    const room = state.data.room ?? await runtime.getDatabaseAdapter().getRoom(message.roomId);
+    const room = state.data.room ?? await runtime.getRoom(message.roomId);
     await runtime.getMemoryManager("messages").createMemory({
       entityId: message.entityId,
       agentId: message.agentId,
@@ -6328,14 +6474,7 @@ var muteRoomAction = {
 // src/actions/none.ts
 var noneAction = {
   name: "NONE",
-  similes: [
-    "NO_ACTION",
-    "NO_RESPONSE",
-    "NO_REACTION",
-    "RESPONSE",
-    "REPLY",
-    "DEFAULT"
-  ],
+  similes: ["NO_ACTION", "NO_RESPONSE", "NO_REACTION"],
   validate: async (_runtime, _message) => {
     return true;
   },
@@ -6494,7 +6633,7 @@ var replyAction = {
       ...message.content.providers ?? [],
       "RECENT_MESSAGES"
     ]);
-    const prompt = composePrompt({
+    const prompt = composePromptFromState({
       state,
       template: replyTemplate
     });
@@ -6574,233 +6713,110 @@ var replyAction = {
 };
 
 // src/actions/roles.ts
-var generateObject = async ({
-  runtime,
-  prompt,
-  modelType,
-  stopSequences = [],
-  output = "object",
-  enumValues = [],
-  schema
-}) => {
-  if (!prompt) {
-    const errorMessage = "generateObject prompt is empty";
-    console.error(errorMessage);
-    throw new Error(errorMessage);
-  }
-  if (output === "enum" && enumValues) {
-    const response2 = await runtime.useModel(modelType, {
-      runtime,
-      prompt,
-      modelType,
-      stopSequences,
-      maxTokens: 8,
-      object: true
-    });
-    const cleanedResponse = response2.trim();
-    if (enumValues.includes(cleanedResponse)) {
-      return cleanedResponse;
-    }
-    const matchedValue = enumValues.find(
-      (value) => cleanedResponse.toLowerCase().includes(value.toLowerCase())
-    );
-    if (matchedValue) {
-      return matchedValue;
-    }
-    logger.error(`Invalid enum value received: ${cleanedResponse}`);
-    logger.error(`Expected one of: ${enumValues.join(", ")}`);
-    return null;
-  }
-  const response = await runtime.useModel(modelType, {
-    runtime,
-    prompt,
-    modelType,
-    stopSequences,
-    object: true
-  });
-  let jsonString = response;
-  const firstChar = output === "array" ? "[" : "{";
-  const lastChar = output === "array" ? "]" : "}";
-  const firstBracket = response.indexOf(firstChar);
-  const lastBracket = response.lastIndexOf(lastChar);
-  if (firstBracket !== -1 && lastBracket !== -1 && firstBracket < lastBracket) {
-    jsonString = response.slice(firstBracket, lastBracket + 1);
-  }
-  if (jsonString.length === 0) {
-    logger.error(`Failed to extract JSON ${output} from model response`);
-    return null;
-  }
-  try {
-    const json = JSON.parse(jsonString);
-    if (schema) {
-      return schema.parse(json);
-    }
-    return json;
-  } catch (_error) {
-    logger.error(`Failed to parse JSON ${output}`);
-    logger.error(jsonString);
-    return null;
-  }
-};
+var import_dedent = __toESM(require_dedent(), 1);
 var canModifyRole = (currentRole, targetRole, newRole) => {
-  if (currentRole === "OWNER" /* OWNER */) {
-    return targetRole !== "OWNER" /* OWNER */;
-  }
-  if (currentRole === "ADMIN" /* ADMIN */) {
-    return (!targetRole || targetRole === "NONE" /* NONE */) && !["OWNER" /* OWNER */, "ADMIN" /* ADMIN */].includes(newRole);
+  if (targetRole === currentRole) return false;
+  switch (currentRole) {
+    // Owners can do everything
+    case "OWNER" /* OWNER */:
+      return true;
+    // Admins can only create/modify users up to their level
+    case "ADMIN" /* ADMIN */:
+      return newRole !== "OWNER" /* OWNER */;
+    // Normal users can't modify roles
+    case "NONE" /* NONE */:
+    default:
+      return false;
   }
-  return false;
 };
-var extractionTemplate = `# Task: Extract role assignments from the conversation
-
-# Current Server Members:
-{{serverMembers}}
-
-# Available Roles:
-- OWNER: Full control over the organization
-- ADMIN: Administrative privileges
-- NONE: Standard member access
-
-# Recent Conversation:
-{{recentMessages}}
-
-# Current speaker role: {{speakerRole}}
-
-# Instructions: Analyze the conversation and extract any role assignments being made by the speaker.
-Only extract role assignments if:
-1. The speaker has appropriate permissions to make the change
-2. The role assignment is clearly stated
-3. The target user is a valid server member
-4. The new role is one of: OWNER, ADMIN, or NONE
-
-Return the results in this JSON format:
-{
-"roleAssignments": [
-  {
-    "entityId": "<UUID of the entity being assigned to>",
-    "newRole": "ROLE_NAME"
-  }
-]
-}
-
-If no valid role assignments are found, return an empty array.`;
-async function generateObjectArray({
-  runtime,
-  prompt,
-  modelType = ModelTypes.TEXT_SMALL,
-  schema,
-  schemaName,
-  schemaDescription
-}) {
-  if (!prompt) {
-    logger.error("generateObjectArray prompt is empty");
-    return [];
-  }
-  const result = await generateObject({
-    runtime,
-    prompt,
-    modelType,
-    output: "array",
-    schema
-  });
-  if (!Array.isArray(result)) {
-    logger.error("Generated result is not an array");
-    return [];
-  }
-  return schema ? schema.parse(result) : result;
-}
 var updateRoleAction = {
   name: "UPDATE_ROLE",
-  similes: ["CHANGE_ROLE", "SET_ROLE", "MODIFY_ROLE"],
-  description: "Updates the role for a user with respect to the agent, world being the server they are in. For example, if an admin tells the agent that a user is their boss, set their role to ADMIN. Can only be used to set roles to ADMIN, OWNER or NONE. Can't be used to ban.",
+  similes: ["CHANGE_ROLE", "SET_PERMISSIONS", "ASSIGN_ROLE", "MAKE_ADMIN"],
+  description: "Assigns a role (Admin, Owner, None) to a user or list of users in a channel.",
   validate: async (runtime, message, state) => {
-    logger.info("Starting role update validation");
-    if (message.content.source !== "discord") {
-      logger.info("Validation failed: Not a discord message");
-      return false;
-    }
-    const room = state.data.room ?? await runtime.getDatabaseAdapter().getRoom(message.roomId);
-    if (!room) {
-      throw new Error("No room found");
-    }
-    if (room.type !== "GROUP" /* GROUP */) {
-      return false;
-    }
-    const serverId = room.serverId;
-    if (!serverId) {
-      throw new Error("No server ID found");
-    }
-    try {
-      const worldId = createUniqueUuid(runtime, serverId);
-      const world = await runtime.getDatabaseAdapter().getWorld(worldId);
-      const requesterId = message.entityId;
-      if (!world.metadata?.roles) {
-        logger.info(`No roles found for server ${serverId}`);
-        return false;
-      }
-      const requesterRole = world.metadata.roles[requesterId];
-      logger.info(`Requester ${requesterId} role:`, requesterRole);
-      if (!requesterRole) {
-        logger.info("Validation failed: No requester role found");
-        return false;
-      }
-      if (!["OWNER" /* OWNER */, "ADMIN" /* ADMIN */].includes(requesterRole)) {
-        logger.info(
-          `Validation failed: Role ${requesterRole} insufficient for role management`
-        );
-        return false;
-      }
-      return true;
-    } catch (error) {
-      logger.error("Error validating updateOrgRole action:", error);
-      return false;
-    }
+    const channelType = message.content.channelType;
+    const serverId = message.content.serverId;
+    return (
+      // First, check if this is a supported channel type
+      (channelType === "GROUP" /* GROUP */ || channelType === "WORLD" /* WORLD */) && // Then, check if we have a server ID
+      !!serverId
+    );
   },
-  handler: async (runtime, message, state, _options, callback, responses) => {
-    for (const response of responses) {
-      await callback(response.content);
-    }
-    const room = state.data.room ?? await runtime.getDatabaseAdapter().getRoom(message.roomId);
-    const world = await runtime.getDatabaseAdapter().getWorld(room.worldId);
-    if (!room) {
-      throw new Error("No room found");
+  handler: async (runtime, message, state, _options, callback) => {
+    const { roomId } = message;
+    const channelType = message.content.channelType;
+    const serverId = message.content.serverId;
+    const worldId = runtime.getSetting("WORLD_ID");
+    let world;
+    if (worldId) {
+      world = await runtime.getWorld(worldId);
     }
-    const serverId = world.serverId;
-    const requesterId = message.entityId;
-    if (!world || !world.metadata) {
-      logger.error(`No world or metadata found for server ${serverId}`);
+    if (!world) {
+      logger.error("World not found");
       await callback({
-        text: "Unable to process role changes due to missing server data.",
-        actions: ["UPDATE_ROLE"],
-        source: "discord"
+        text: "I couldn't find the world. This action only works in a world."
       });
       return;
     }
-    if (!world.metadata.roles) {
+    if (!world.metadata?.roles) {
+      world.metadata = world.metadata || {};
       world.metadata.roles = {};
     }
-    const requesterRole = world.metadata.roles[requesterId] || "NONE" /* NONE */;
-    const entities = await runtime.getDatabaseAdapter().getEntitiesForRoom(room.id, true);
-    const serverMembersContext = entities.map((entity) => {
-      const discordData = entity.components?.find(
-        (c) => c.type === "discord"
-      )?.data;
-      const name2 = discordData?.username || entity.names[0];
-      const id = entity.id;
-      return `${name2} (${id})`;
-    }).join("\n");
+    const entities = await runtime.getEntitiesForRoom(roomId);
+    const requesterRole = world.metadata.roles[message.entityId] || "NONE" /* NONE */;
     const extractionPrompt = composePrompt({
       state: {
-        ...state,
-        serverMembers: serverMembersContext,
-        speakerRole: requesterRole
-      },
-      template: extractionTemplate
-    });
-    const result = await generateObjectArray({
-      runtime,
+        ...state.values,
+        content: state.text
+      },
+      template: import_dedent.default`
+				# Task: Parse Role Assignment
+
+				I need to extract user role assignments from the input text. Users can be referenced by name, username, or mention.
+
+				The available role types are:
+				- OWNER: Full control over the server and all settings
+				- ADMIN: Ability to manage channels and moderate content
+				- NONE: Regular user with no special permissions
+
+				# Current context:
+				{{content}}
+
+				Format your response as a JSON array of objects, each with:
+				- entityId: The name or ID of the user
+				- newRole: The role to assign (OWNER, ADMIN, or NONE)
+
+				Example:
+				\`\`\`json
+				[
+					{
+						"entityId": "John",
+						"newRole": "ADMIN"
+					},
+					{
+						"entityId": "Sarah",
+						"newRole": "OWNER"
+					}
+				]
+				\`\`\`
+			`
+    });
+    const result = await runtime.useModel(ModelTypes.OBJECT_LARGE, {
       prompt: extractionPrompt,
-      modelType: ModelTypes.TEXT_SMALL
+      schema: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            entityId: { type: "string" },
+            newRole: {
+              type: "string",
+              enum: Object.values(Role)
+            }
+          },
+          required: ["entityId", "newRole"]
+        }
+      }
     });
     if (!result?.length) {
       await callback({
@@ -6838,7 +6854,7 @@ var updateRoleAction = {
       });
     }
     if (worldUpdated) {
-      await runtime.getDatabaseAdapter().updateWorld(world);
+      await runtime.updateWorld(world);
       logger.info(`Updated roles in world metadata for server ${serverId}`);
     }
   },
@@ -6949,7 +6965,7 @@ var sendMessageAction = {
   validate: async (runtime, message, _state) => {
     const worldId = message.roomId;
     const agentId = runtime.agentId;
-    const roomComponents = await runtime.getDatabaseAdapter().getComponents(message.roomId, worldId, agentId);
+    const roomComponents = await runtime.getComponents(message.roomId, worldId, agentId);
     const availableSources = new Set(roomComponents.map((c) => c.type));
     return availableSources.size > 0;
   },
@@ -6959,9 +6975,9 @@ var sendMessageAction = {
         await callback(response.content);
       }
       const sourceEntityId = message.entityId;
-      const room = state.data.room ?? await runtime.getDatabaseAdapter().getRoom(message.roomId);
+      const room = state.data.room ?? await runtime.getRoom(message.roomId);
       const worldId = room.worldId;
-      const targetPrompt = composePrompt({
+      const targetPrompt = composePromptFromState({
         state,
         template: targetExtractionTemplate
       });
@@ -6989,7 +7005,7 @@ var sendMessageAction = {
           });
           return;
         }
-        const userComponent = await runtime.getDatabaseAdapter().getComponent(targetEntity.id, source, worldId, sourceEntityId);
+        const userComponent = await runtime.getComponent(targetEntity.id, source, worldId, sourceEntityId);
         if (!userComponent) {
           await callback({
             text: `I couldn't find ${source} information for that user. Could you please provide their ${source} details?`,
@@ -7029,7 +7045,7 @@ var sendMessageAction = {
           });
         }
       } else if (targetData.targetType === "room") {
-        const rooms = await runtime.getDatabaseAdapter().getRooms(worldId);
+        const rooms = await runtime.getRooms(worldId);
         const targetRoom = rooms.find((r) => {
           return r.name.toLowerCase() === targetData.identifiers.roomName?.toLowerCase();
         });
@@ -7131,6 +7147,7 @@ var sendMessageAction = {
 };
 
 // src/actions/settings.ts
+var import_dedent2 = __toESM(require_dedent(), 1);
 var messageCompletionFooter = `
 # Instructions: Write the next message for {{agentName}}. Include the appropriate action from the list: {{actionNames}}
 Response format should be formatted in a valid JSON block like this:
@@ -7223,137 +7240,12 @@ var completionTemplate = `# Task: Generate a response for settings completion
 Write a natural, conversational response that {{agentName}} would send about the successful completion of settings.
 Include the actions array ["ONBOARDING_COMPLETE"] in your response.
 ${messageCompletionFooter}`;
-var extractionTemplate2 = `# Task: Extract setting values from the conversation
-
-# Available Settings:
-{{#each settings}}
-{{key}}:
-  Name: {{name}}
-  Description: {{description}}
-  Current Value: {{value}}
-  Required: {{required}}
-  Validation Rules: {{#if validation}}Present{{else}}None{{/if}}
-{{/each}}
-
-# Current Settings Status:
-{{settingsStatus}}
-
-# Recent Conversation:
-{{recentMessages}}
-
-# Instructions:
-1. Review the ENTIRE conversation and identify ALL values provided for settings
-2. For each setting mentioned, extract:
-   - The setting key (must exactly match one of the available settings above)
-   - The provided value that matches the setting's description and purpose
-3. Return an array of ALL setting updates found, even if mentioned earlier in the conversation
-
-Return ONLY a JSON array of objects with 'key' and 'value' properties. Format:
-[
-  { "key": "SETTING_NAME", "value": "extracted value" },
-  { "key": "ANOTHER_SETTING", "value": "another value" }
-]
-
-IMPORTANT: Only include settings from the Available Settings list above. Ignore any other potential settings.`;
-var generateObject2 = async ({
-  runtime,
-  prompt,
-  modelType = ModelTypes.TEXT_LARGE,
-  stopSequences = [],
-  output = "object",
-  enumValues = [],
-  schema
-}) => {
-  if (!prompt) {
-    const errorMessage = "generateObject prompt is empty";
-    console.error(errorMessage);
-    throw new Error(errorMessage);
-  }
-  if (output === "enum" && enumValues) {
-    const response2 = await runtime.useModel(modelType, {
-      runtime,
-      prompt,
-      modelType,
-      stopSequences,
-      maxTokens: 8,
-      object: true
-    });
-    const cleanedResponse = response2.trim();
-    if (enumValues.includes(cleanedResponse)) {
-      return cleanedResponse;
-    }
-    const matchedValue = enumValues.find(
-      (value) => cleanedResponse.toLowerCase().includes(value.toLowerCase())
-    );
-    if (matchedValue) {
-      return matchedValue;
-    }
-    logger.error(`Invalid enum value received: ${cleanedResponse}`);
-    logger.error(`Expected one of: ${enumValues.join(", ")}`);
-    return null;
-  }
-  const response = await runtime.useModel(modelType, {
-    runtime,
-    prompt,
-    modelType,
-    stopSequences,
-    object: true
-  });
-  let jsonString = response;
-  const firstChar = output === "array" ? "[" : "{";
-  const lastChar = output === "array" ? "]" : "}";
-  const firstBracket = response.indexOf(firstChar);
-  const lastBracket = response.lastIndexOf(lastChar);
-  if (firstBracket !== -1 && lastBracket !== -1 && firstBracket < lastBracket) {
-    jsonString = response.slice(firstBracket, lastBracket + 1);
-  }
-  if (jsonString.length === 0) {
-    logger.error(`Failed to extract JSON ${output} from model response`);
-    return null;
-  }
-  try {
-    const json = JSON.parse(jsonString);
-    if (schema) {
-      return schema.parse(json);
-    }
-    return json;
-  } catch (_error) {
-    logger.error(`Failed to parse JSON ${output}`);
-    logger.error(jsonString);
-    return null;
-  }
-};
-async function generateObjectArray2({
-  runtime,
-  prompt,
-  modelType = ModelTypes.TEXT_SMALL,
-  schema,
-  schemaName,
-  schemaDescription
-}) {
-  if (!prompt) {
-    logger.error("generateObjectArray prompt is empty");
-    return [];
-  }
-  const result = await generateObject2({
-    runtime,
-    prompt,
-    modelType,
-    output: "array",
-    schema
-  });
-  if (!Array.isArray(result)) {
-    logger.error("Generated result is not an array");
-    return [];
-  }
-  return schema ? schema.parse(result) : result;
-}
-async function getWorldSettings(runtime, serverId) {
-  try {
-    const worldId = createUniqueUuid(runtime, serverId);
-    const world = await runtime.getDatabaseAdapter().getWorld(worldId);
-    if (!world || !world.metadata?.settings) {
-      return null;
+async function getWorldSettings(runtime, serverId) {
+  try {
+    const worldId = createUniqueUuid(runtime, serverId);
+    const world = await runtime.getWorld(worldId);
+    if (!world || !world.metadata?.settings) {
+      return null;
     }
     return world.metadata.settings;
   } catch (error) {
@@ -7364,7 +7256,7 @@ async function getWorldSettings(runtime, serverId) {
 async function updateWorldSettings(runtime, serverId, worldSettings) {
   try {
     const worldId = createUniqueUuid(runtime, serverId);
-    const world = await runtime.getDatabaseAdapter().getWorld(worldId);
+    const world = await runtime.getWorld(worldId);
     if (!world) {
       logger.error(`No world found for server ${serverId}`);
       return false;
@@ -7373,7 +7265,7 @@ async function updateWorldSettings(runtime, serverId, worldSettings) {
       world.metadata = {};
     }
     world.metadata.settings = worldSettings;
-    await runtime.getDatabaseAdapter().updateWorld(world);
+    await runtime.updateWorld(world);
     return true;
   } catch (error) {
     logger.error(`Error updating settings state: ${error}`);
@@ -7405,40 +7297,48 @@ function categorizeSettings(worldSettings) {
   return { configured, requiredUnconfigured, optionalUnconfigured };
 }
 async function extractSettingValues(runtime, _message, state, worldSettings) {
+  const { requiredUnconfigured, optionalUnconfigured } = categorizeSettings(worldSettings);
+  const settingsContext = requiredUnconfigured.concat(optionalUnconfigured).map(([key, setting]) => {
+    const requiredStr = setting.required ? "Required." : "Optional.";
+    return `${key}: ${setting.description} ${requiredStr}`;
+  }).join("\n");
+  const basePrompt = import_dedent2.default`
+    I need to extract settings values from the user's message.
+    
+    Available settings:
+    ${settingsContext}
+    
+    User message: ${state.text}
+
+    For each setting mentioned in the user's message, extract the value.
+    
+    Only return settings that are clearly mentioned in the user's message.
+    If a setting is mentioned but no clear value is provided, do not include it.
+    `;
   try {
-    const prompt = composePrompt({
-      state: {
-        ...state,
-        settings: Object.entries(worldSettings).filter(([key]) => !key.startsWith("_")).map(([key, setting]) => ({
-          key,
-          ...setting
-        })),
-        settingsStatus: formatSettingsList(worldSettings)
-      },
-      template: extractionTemplate2
-    });
-    const extractions = await generateObjectArray2({
-      runtime,
-      prompt,
-      modelType: ModelTypes.TEXT_LARGE
-    });
-    logger.info(`Extracted ${extractions.length} potential setting updates`);
-    const validExtractions = extractions.filter((update) => {
-      const setting = worldSettings[update.key];
-      if (!setting) {
-        logger.info(`Ignored extraction for unknown setting: ${update.key}`);
-        return false;
-      }
-      if (setting.validation && !setting.validation(update.value)) {
-        logger.info(`Validation failed for setting ${update.key}`);
-        return false;
+    const result = await runtime.useModel(ModelTypes.OBJECT_LARGE, {
+      prompt: basePrompt,
+      output: "array",
+      schema: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            key: { type: "string" },
+            value: { type: "string" }
+          },
+          required: ["key", "value"]
+        }
       }
-      return true;
     });
-    logger.info(`Validated ${validExtractions.length} setting updates`);
-    return validExtractions;
+    if (!result || !Array.isArray(result)) {
+      return [];
+    }
+    return result.filter(({ key, value }) => {
+      return Boolean(key && value && worldSettings[key]);
+    });
   } catch (error) {
-    logger.error("Error extracting setting values:", error);
+    console.error("Error extracting settings:", error);
     return [];
   }
 }
@@ -7498,7 +7398,6 @@ async function handleOnboardingComplete(runtime, worldSettings, state, callback)
   try {
     const prompt = composePrompt({
       state: {
-        ...state,
         settingsStatus: formatSettingsList(worldSettings)
       },
       template: completionTemplate
@@ -7528,12 +7427,12 @@ async function generateSuccessResponse(runtime, worldSettings, state, messages,
       await handleOnboardingComplete(runtime, worldSettings, state, callback);
       return;
     }
+    const requiredUnconfiguredString = requiredUnconfigured.map(([key, setting]) => `${key}: ${setting.name}`).join("\n");
     const prompt = composePrompt({
       state: {
-        ...state,
         updateMessages: messages.join("\n"),
-        nextSetting: requiredUnconfigured[0][1],
-        remainingRequired: requiredUnconfigured.length
+        nextSetting: requiredUnconfiguredString,
+        remainingRequired: requiredUnconfigured.length.toString()
       },
       template: successTemplate
     });
@@ -7562,11 +7461,11 @@ async function generateFailureResponse(runtime, worldSettings, state, callback)
       await handleOnboardingComplete(runtime, worldSettings, state, callback);
       return;
     }
+    const requiredUnconfiguredString = requiredUnconfigured.map(([key, setting]) => `${key}: ${setting.name}`).join("\n");
     const prompt = composePrompt({
       state: {
-        ...state,
-        nextSetting: requiredUnconfigured[0][1],
-        remainingRequired: requiredUnconfigured.length
+        nextSetting: requiredUnconfiguredString,
+        remainingRequired: requiredUnconfigured.length.toString()
       },
       template: failureTemplate
     });
@@ -7590,7 +7489,7 @@ async function generateFailureResponse(runtime, worldSettings, state, callback)
 }
 async function generateErrorResponse(runtime, state, callback) {
   try {
-    const prompt = composePrompt({
+    const prompt = composePromptFromState({
       state,
       template: errorTemplate
     });
@@ -7615,7 +7514,7 @@ async function generateErrorResponse(runtime, state, callback) {
 var updateSettingsAction = {
   name: "UPDATE_SETTINGS",
   similes: ["UPDATE_SETTING", "SAVE_SETTING", "SET_CONFIGURATION", "CONFIGURE"],
-  description: "Saves a setting during the settings process",
+  description: "Saves a configuration setting during the onboarding process, or update an existing setting. Use this when you are onboarding with a world owner or admin.",
   validate: async (runtime, message, _state) => {
     try {
       if (message.content.channelType !== "DM" /* DM */) {
@@ -7909,12 +7808,12 @@ var unfollowRoomAction = {
   description: "Stop following this channel. You can still respond if explicitly mentioned, but you won't automatically chime in anymore. Unfollow if you're annoying people or have been asked to.",
   validate: async (runtime, message) => {
     const roomId = message.roomId;
-    const roomState = await runtime.getDatabaseAdapter().getParticipantUserState(roomId, runtime.agentId);
+    const roomState = await runtime.getParticipantUserState(roomId, runtime.agentId);
     return roomState === "FOLLOWED";
   },
   handler: async (runtime, message, state, _options, _callback, _responses) => {
     async function _shouldUnfollow(state2) {
-      const shouldUnfollowPrompt = composePrompt({
+      const shouldUnfollowPrompt = composePromptFromState({
         state: state2,
         template: shouldUnfollowTemplate
         // Define this template separately
@@ -7926,8 +7825,8 @@ var unfollowRoomAction = {
       return parsedResponse;
     }
     if (await _shouldUnfollow(state)) {
-      await runtime.getDatabaseAdapter().setParticipantUserState(message.roomId, runtime.agentId, null);
-      const room = state.data.room ?? await runtime.getDatabaseAdapter().getRoom(message.roomId);
+      await runtime.setParticipantUserState(message.roomId, runtime.agentId, null);
+      const room = state.data.room ?? await runtime.getRoom(message.roomId);
       await runtime.getMemoryManager("messages").createMemory({
         entityId: message.entityId,
         agentId: message.agentId,
@@ -8224,12 +8123,12 @@ var unmuteRoomAction = {
   description: "Unmutes a room, allowing the agent to consider responding to messages again.",
   validate: async (runtime, message) => {
     const roomId = message.roomId;
-    const roomState = await runtime.getDatabaseAdapter().getParticipantUserState(roomId, runtime.agentId);
+    const roomState = await runtime.getParticipantUserState(roomId, runtime.agentId);
     return roomState === "MUTED";
   },
   handler: async (runtime, message, state, _options, _callback, _responses) => {
     async function _shouldUnmute(state2) {
-      const shouldUnmutePrompt = composePrompt({
+      const shouldUnmutePrompt = composePromptFromState({
         state: state2,
         template: shouldUnmuteTemplate
         // Define this template separately
@@ -8276,9 +8175,9 @@ var unmuteRoomAction = {
       return false;
     }
     if (await _shouldUnmute(state)) {
-      await runtime.getDatabaseAdapter().setParticipantUserState(message.roomId, runtime.agentId, null);
+      await runtime.setParticipantUserState(message.roomId, runtime.agentId, null);
     }
-    const room = await runtime.getDatabaseAdapter().getRoom(message.roomId);
+    const room = await runtime.getRoom(message.roomId);
     await runtime.getMemoryManager("messages").createMemory({
       entityId: message.entityId,
       agentId: message.agentId,
@@ -8438,15 +8337,9 @@ Example outputs:
 
 Make sure to include the \`\`\`json\`\`\` tags around the JSON object.`;
 var updateEntityAction = {
-  name: "UPDATE_ENTITY",
-  similes: [
-    "CREATE_ENTITY",
-    "UPDATE_USER",
-    "EDIT_ENTITY",
-    "UPDATE_COMPONENT",
-    "CREATE_COMPONENT"
-  ],
-  description: "Add or edit contact details for a user entity (like twitter, discord, email address, etc.)",
+  name: "UPDATE_CONTACT",
+  similes: ["UPDATE_ENTITY"],
+  description: "Add or edit contact details for a person you are talking to or observing in the conversation. Use this when you learn this information from the conversation about a contact. This is for the agent to relate entities across platforms, not for world settings or configuration.",
   validate: async (_runtime, _message, _state) => {
     return true;
   },
@@ -8458,7 +8351,7 @@ var updateEntityAction = {
       const sourceEntityId = message.entityId;
       const _roomId = message.roomId;
       const agentId = runtime.agentId;
-      const room = state.data.room ?? await runtime.getDatabaseAdapter().getRoom(message.roomId);
+      const room = state.data.room ?? await runtime.getRoom(message.roomId);
       const worldId = room.worldId;
       const entity = await findEntityByName(runtime, message, state);
       if (!entity) {
@@ -8470,7 +8363,7 @@ var updateEntityAction = {
         return;
       }
       let existingComponent = null;
-      const prompt = composePrompt({
+      const prompt = composePromptFromState({
         state,
         template: componentTemplate
       });
@@ -8499,9 +8392,9 @@ var updateEntityAction = {
       }
       const componentType = parsedResult.source.toLowerCase();
       const componentData = parsedResult.data;
-      existingComponent = await runtime.getDatabaseAdapter().getComponent(entity.id, componentType, worldId, sourceEntityId);
+      existingComponent = await runtime.getComponent(entity.id, componentType, worldId, sourceEntityId);
       if (existingComponent) {
-        await runtime.getDatabaseAdapter().updateComponent({
+        await runtime.updateComponent({
           id: existingComponent.id,
           entityId: entity.id,
           worldId,
@@ -8517,7 +8410,7 @@ var updateEntityAction = {
           source: message.content.source
         });
       } else {
-        await runtime.getDatabaseAdapter().createComponent({
+        await runtime.createComponent({
           id: uuidv4(),
           entityId: entity.id,
           worldId,
@@ -8591,265 +8484,6 @@ var updateEntityAction = {
   ]
 };
 
-// src/evaluators/goal.ts
-var goalsTemplate = `# TASK: Update Goal
-Analyze the conversation and update the status of the goals based on the new information provided.
-
-# INSTRUCTIONS
-
-- Review the conversation and identify any progress towards the objectives of the current goals.
-- Update the objectives if they have been completed or if there is new information about them.
-- Update the status of the goal to 'DONE' if all objectives are completed.
-- If no progress is made, do not change the status of the goal.
-
-# START OF ACTUAL TASK INFORMATION
-
-{{goals}}
-{{recentMessages}}
-
-TASK: Analyze the conversation and update the status of the goals based on the new information provided. Respond with a JSON array of goals to update.
-- Each item must include the goal ID, as well as the fields in the goal to update.
-- For updating objectives, include the entire objectives array including unchanged fields.
-- Only include goals which need to be updated.
-- Goal status options are 'IN_PROGRESS', 'DONE' and 'FAILED'. If the goal is active it should always be 'IN_PROGRESS'.
-- If the goal has been successfully completed, set status to DONE. If the goal cannot be completed, set status to FAILED.
-- If those goal is still in progress, do not include the status field.
-
-Response format should be:
-\`\`\`json
-[
-  {
-    "id": <goal uuid>, // required
-    "status": "IN_PROGRESS" | "DONE" | "FAILED", // optional
-    "objectives": [ // optional
-      { "description": "Objective description", "completed": true | false },
-      { "description": "Objective description", "completed": true | false }
-    ] // NOTE: If updating objectives, include the entire objectives array including unchanged fields.
-  }
-]
-\`\`\``;
-async function handler(runtime, message, state, options2 = { onlyInProgress: true }) {
-  const prompt = composePrompt({
-    state,
-    template: runtime.character.templates?.goalsTemplate || goalsTemplate
-  });
-  const response = await runtime.useModel(ModelTypes.TEXT_SMALL, {
-    runtime,
-    prompt
-  });
-  const updates = parseJsonArrayFromText(response);
-  const goalsData = await runtime.getDatabaseAdapter().getGoals({
-    roomId: message.roomId,
-    onlyInProgress: options2.onlyInProgress
-  });
-  const updatedGoals = goalsData.map((goal) => {
-    const update = updates?.find((u) => u.id === goal.id);
-    if (update) {
-      return {
-        ...goal,
-        ...update,
-        objectives: goal.objectives.map((objective) => {
-          const updatedObjective = update.objectives?.find(
-            (uo) => uo.description === objective.description
-          );
-          return updatedObjective ? { ...objective, ...updatedObjective } : objective;
-        })
-      };
-    }
-    return null;
-  }).filter(Boolean);
-  for (const goal of updatedGoals) {
-    const id = goal.id;
-    if (goal.id) goal.id = void 0;
-    await runtime.getDatabaseAdapter().updateGoal({ ...goal, id });
-  }
-  return updatedGoals;
-}
-var goalEvaluator = {
-  name: "UPDATE_GOAL",
-  similes: [
-    "UPDATE_GOALS",
-    "EDIT_GOAL",
-    "UPDATE_GOAL_STATUS",
-    "UPDATE_OBJECTIVES"
-  ],
-  validate: async (runtime, message) => {
-    const goals = await runtime.getDatabaseAdapter().getGoals({
-      count: 1,
-      onlyInProgress: true,
-      roomId: message.roomId
-    });
-    return goals.length > 0;
-  },
-  description: "Analyze the conversation and update the status of the goals based on the new information provided.",
-  handler,
-  examples: [
-    {
-      prompt: `People in the scene:
-  {{name1}}: An avid reader and member of a book club.
-  {{name2}}: The organizer of the book club.
-
-  Goals:
-  - Name: Finish reading "War and Peace"
-    id: 12345-67890-12345-67890
-    Status: IN_PROGRESS
-    Objectives:
-      - Read up to chapter 20 by the end of the month
-      - Discuss the first part in the next meeting`,
-      messages: [
-        {
-          name: "{{name1}}",
-          content: {
-            text: "I've just finished chapter 20 of 'War and Peace'"
-          }
-        },
-        {
-          name: "{{name2}}",
-          content: {
-            text: "Were you able to grasp the complexities of the characters"
-          }
-        },
-        {
-          name: "{{name1}}",
-          content: {
-            text: "Yep. I've prepared some notes for our discussion"
-          }
-        }
-      ],
-      outcome: `[
-        {
-          "id": "12345-67890-12345-67890",
-          "status": "DONE",
-          "objectives": [
-            { "description": "Read up to chapter 20 by the end of the month", "completed": true },
-            { "description": "Prepare notes for the next discussion", "completed": true }
-          ]
-        }
-      ]`
-    },
-    {
-      prompt: `People in the scene:
-  {{name1}}: A fitness enthusiast working towards a marathon.
-  {{name2}}: A personal trainer.
-
-  Goals:
-  - Name: Complete a marathon
-    id: 23456-78901-23456-78901
-    Status: IN_PROGRESS
-    Objectives:
-      - Increase running distance to 30 miles a week
-      - Complete a half-marathon as practice`,
-      messages: [
-        {
-          name: "{{name1}}",
-          content: { text: "I managed to run 30 miles this week" }
-        },
-        {
-          name: "{{name2}}",
-          content: {
-            text: "Impressive progress! How do you feel about the half-marathon next month?"
-          }
-        },
-        {
-          name: "{{name1}}",
-          content: {
-            text: "I feel confident. The training is paying off."
-          }
-        }
-      ],
-      outcome: `[
-        {
-          "id": "23456-78901-23456-78901",
-          "objectives": [
-            { "description": "Increase running distance to 30 miles a week", "completed": true },
-            { "description": "Complete a half-marathon as practice", "completed": false }
-          ]
-        }
-      ]`
-    },
-    {
-      prompt: `People in the scene:
-  {{name1}}: A student working on a final year project.
-  {{name2}}: The project supervisor.
-
-  Goals:
-  - Name: Finish the final year project
-    id: 34567-89012-34567-89012
-    Status: IN_PROGRESS
-    Objectives:
-      - Submit the first draft of the thesis
-      - Complete the project prototype`,
-      messages: [
-        {
-          name: "{{name1}}",
-          content: {
-            text: "I've submitted the first draft of my thesis."
-          }
-        },
-        {
-          name: "{{name2}}",
-          content: {
-            text: "Well done. How is the prototype coming along?"
-          }
-        },
-        {
-          name: "{{name1}}",
-          content: {
-            text: "It's almost done. I just need to finalize the testing phase."
-          }
-        }
-      ],
-      outcome: `[
-        {
-          "id": "34567-89012-34567-89012",
-          "objectives": [
-            { "description": "Submit the first draft of the thesis", "completed": true },
-            { "description": "Complete the project prototype", "completed": false }
-          ]
-        }
-      ]`
-    },
-    {
-      prompt: `People in the scene:
-        {{name1}}: A project manager working on a software development project.
-        {{name2}}: A software developer in the project team.
-
-        Goals:
-        - Name: Launch the new software version
-          id: 45678-90123-45678-90123
-          Status: IN_PROGRESS
-          Objectives:
-            - Complete the coding for the new features
-            - Perform comprehensive testing of the software`,
-      messages: [
-        {
-          name: "{{name1}}",
-          content: {
-            text: "How's the progress on the new features?"
-          }
-        },
-        {
-          name: "{{name2}}",
-          content: {
-            text: "We've encountered some unexpected challenges and are currently troubleshooting."
-          }
-        },
-        {
-          name: "{{name1}}",
-          content: {
-            text: "Let's move on and cancel the task."
-          }
-        }
-      ],
-      outcome: `[
-        {
-          "id": "45678-90123-45678-90123",
-          "status": "FAILED"
-      ]`
-    }
-  ]
-};
-
 // src/evaluators/reflection.ts
 var relationshipSchema = z.object({
   sourceEntityId: z.string(),
@@ -8944,9 +8578,9 @@ function resolveEntity(entityId, entities) {
   if (entity) {
     return entity.id;
   }
-  throw new Error(`Could not resolve name "${name}" to a valid UUID`);
+  throw new Error(`Could not resolve entityId "${entityId}" to a valid UUID`);
 }
-var generateObject3 = async ({
+var generateObject = async ({
   runtime,
   prompt,
   modelType = ModelTypes.TEXT_SMALL,
@@ -9014,14 +8648,14 @@ var generateObject3 = async ({
     return null;
   }
 };
-async function handler2(runtime, message, state) {
+async function handler(runtime, message, state) {
   const { agentId, roomId } = message;
   const factsManager = new MemoryManager({
     runtime,
     tableName: "facts"
   });
   const [existingRelationships, entities, knownFacts] = await Promise.all([
-    runtime.getDatabaseAdapter().getRelationships({
+    runtime.getRelationships({
       entityId: message.entityId
     }),
     getEntityDetails({ runtime, roomId }),
@@ -9034,7 +8668,7 @@ async function handler2(runtime, message, state) {
   ]);
   const prompt = composePrompt({
     state: {
-      ...state,
+      ...state.values,
       knownFacts: formatFacts(knownFacts),
       roomType: message.content.channelType,
       entitiesInRoom: JSON.stringify(entities),
@@ -9043,7 +8677,7 @@ async function handler2(runtime, message, state) {
     },
     template: runtime.character.templates?.reflectionTemplate || reflectionTemplate
   });
-  const reflection = await generateObject3({
+  const reflection = await generateObject({
     runtime,
     prompt,
     modelType: ModelTypes.TEXT_SMALL,
@@ -9090,13 +8724,13 @@ async function handler2(runtime, message, state) {
       const updatedTags = Array.from(
         /* @__PURE__ */ new Set([...existingRelationship.tags || [], ...relationship.tags])
       );
-      await runtime.getDatabaseAdapter().updateRelationship({
+      await runtime.updateRelationship({
         ...existingRelationship,
         tags: updatedTags,
         metadata: updatedMetadata
       });
     } else {
-      await runtime.getDatabaseAdapter().createRelationship({
+      await runtime.createRelationship({
         sourceEntityId: sourceId,
         targetEntityId: targetId,
         tags: relationship.tags,
@@ -9107,7 +8741,7 @@ async function handler2(runtime, message, state) {
       });
     }
   }
-  await runtime.getDatabaseAdapter().setCache(
+  await runtime.setCache(
     `${message.roomId}-reflection-last-processed`,
     message.id
   );
@@ -9122,7 +8756,7 @@ var reflectionEvaluator = {
     "ASSESS_SITUATION"
   ],
   validate: async (runtime, message) => {
-    const lastMessageId = await runtime.getDatabaseAdapter().getCache(`${message.roomId}-reflection-last-processed`);
+    const lastMessageId = await runtime.getCache(`${message.roomId}-reflection-last-processed`);
     const messages = await runtime.getMemoryManager("messages").getMemories({
       roomId: message.roomId,
       count: runtime.getConversationLength()
@@ -9139,7 +8773,7 @@ var reflectionEvaluator = {
     return messages.length > reflectionInterval;
   },
   description: "Generate a self-reflective thought on the conversation, then extract facts and relationships between entities in the conversation.",
-  handler: handler2,
+  handler,
   examples: [
     {
       prompt: `Agent Name: Sarah
@@ -9309,42 +8943,7 @@ function formatFacts(facts) {
   return facts.reverse().map((fact) => fact.content.text).join("\n");
 }
 
-// src/providers/providers.ts
-var providersProvider = {
-  name: "PROVIDERS",
-  description: "List of all data providers the agent can use to get additional information",
-  get: async (runtime, _message) => {
-    const dynamicProviders = runtime.providers.filter(
-      (provider) => provider.dynamic === true
-    );
-    const providerDescriptions = dynamicProviders.map((provider) => {
-      return `- **${provider.name}**: ${provider.description || "No description available"}`;
-    });
-    const headerText = "# Providers\n\nThese providers are available for the agent to select and use:";
-    if (providerDescriptions.length === 0) {
-      return {
-        text: addHeader(
-          headerText,
-          "No dynamic providers are currently available."
-        )
-      };
-    }
-    const providersText = providerDescriptions.join("\n");
-    const text = addHeader(headerText, providersText);
-    const data = {
-      dynamicProviders: dynamicProviders.map((provider) => ({
-        name: provider.name,
-        description: provider.description || ""
-      }))
-    };
-    return {
-      text,
-      data
-    };
-  }
-};
-
-// src/providers/actionExamples.ts
+// src/providers/actions.ts
 var actionsProvider = {
   name: "ACTIONS",
   description: "Possible response actions",
@@ -9384,6 +8983,8 @@ var actionsProvider = {
 // src/providers/anxiety.ts
 var anxietyProvider = {
   name: "ANXIETY",
+  description: "Social directions for the AI to follow based on the channel type",
+  dynamic: true,
   get: async (_runtime, message) => {
     const channelType = message.content.channelType;
     const groupAnxietyExamples = [
@@ -9464,7 +9065,8 @@ var anxietyProvider = {
 // src/providers/attachments.ts
 var attachmentsProvider = {
   name: "ATTACHMENTS",
-  description: "List of attachments in the current conversation",
+  description: "List of attachments sent during the current conversation, including names, descriptions, and summaries",
+  dynamic: true,
   get: async (runtime, message) => {
     let allAttachments = message.content.attachments || [];
     const { roomId } = message;
@@ -9567,13 +9169,12 @@ var characterProvider = {
   get: async (runtime, message, state) => {
     const character = runtime.character;
     const agentName = character.name;
-    let bio = character.bio || "";
-    if (Array.isArray(bio)) {
-      bio = bio.sort(() => 0.5 - Math.random()).slice(0, 3).join(" ");
-    }
+    const bioText = Array.isArray(character.bio) ? character.bio.sort(() => 0.5 - Math.random()).slice(0, 10).join(" ") : character.bio || "";
+    const bio = addHeader(`# About ${character.name}`, bioText);
     const system = character.system ?? "";
-    const topic = character.topics && character.topics.length > 0 ? character.topics[Math.floor(Math.random() * character.topics.length)] : null;
-    const topics = character.topics && character.topics.length > 0 ? `${character.name} is interested in ${character.topics.sort(() => 0.5 - Math.random()).slice(0, 5).map((topic2, index, array) => {
+    const topicString = character.topics && character.topics.length > 0 ? character.topics[Math.floor(Math.random() * character.topics.length)] : null;
+    const topic = topicString ? `${character.name} is currently interested in ${topicString}` : "";
+    const topics = character.topics && character.topics.length > 0 ? `${character.name} is also interested in ${character.topics.filter((topic2) => topic2 !== topicString).sort(() => 0.5 - Math.random()).slice(0, 5).map((topic2, index, array) => {
       if (index === array.length - 2) {
         return `${topic2} and `;
       }
@@ -9582,7 +9183,8 @@ var characterProvider = {
       }
       return `${topic2}, `;
     }).join("")}` : "";
-    const adjective = character.adjectives && character.adjectives.length > 0 ? character.adjectives[Math.floor(Math.random() * character.adjectives.length)] : "";
+    const adjectiveString = character.adjectives && character.adjectives.length > 0 ? character.adjectives[Math.floor(Math.random() * character.adjectives.length)] : "";
+    const adjective = adjectiveString ? `${character.name} is ${adjectiveString}` : "";
     const formattedCharacterPostExamples = !character.postExamples ? "" : character.postExamples.sort(() => 0.5 - Math.random()).map((post) => {
       const messageString = `${post}`;
       return messageString;
@@ -9598,9 +9200,9 @@ var characterProvider = {
       );
       return example.map((message2) => {
         let messageString = `${message2.name}: ${message2.content.text}${message2.content.actions ? ` (actions: ${message2.content.actions.join(", ")})` : ""}`;
-        exampleNames.forEach((name2, index) => {
-          const placeholder = `{{user${index + 1}}}`;
-          messageString = messageString.replaceAll(placeholder, name2);
+        exampleNames.forEach((name, index) => {
+          const placeholder = `{{name${index + 1}}}`;
+          messageString = messageString.replaceAll(placeholder, name);
         });
         return messageString;
       }).join("\n");
@@ -9609,7 +9211,7 @@ var characterProvider = {
       `# Example Conversations for ${character.name}`,
       formattedCharacterMessageExamples
     ) : "";
-    const room = state.data.room ?? await runtime.getDatabaseAdapter().getRoom(message.roomId);
+    const room = state.data.room ?? await runtime.getRoom(message.roomId);
     const isPostFormat = room?.type === "FEED" /* FEED */ || room?.type === "THREAD" /* THREAD */;
     const postDirections = character?.style?.all?.length > 0 || character?.style?.post?.length > 0 ? addHeader(
       `# Post Directions for ${character.name}`,
@@ -9643,9 +9245,29 @@ var characterProvider = {
       characterPostExamples,
       characterMessageExamples
     };
-    const text = [directions, examples].filter(Boolean).join("\n\n");
+    const data = {
+      bio,
+      adjective,
+      topic,
+      topics,
+      character,
+      directions,
+      examples,
+      system
+    };
+    const text = [
+      bio,
+      adjective,
+      topic,
+      topics,
+      adjective,
+      directions,
+      examples,
+      system
+    ].filter(Boolean).join("\n\n");
     return {
       values,
+      data,
       text
     };
   }
@@ -9656,7 +9278,7 @@ var choiceProvider = {
   name: "CHOICE",
   get: async (runtime, message) => {
     try {
-      const pendingTasks = await runtime.getDatabaseAdapter().getTasks({
+      const pendingTasks = await runtime.getTasks({
         roomId: message.roomId,
         tags: ["AWAITING_CHOICE"]
       });
@@ -9748,7 +9370,8 @@ Data: ${JSON.stringify(entity.metadata)}
 }
 var entitiesProvider = {
   name: "ENTITIES",
-  description: "Entities in the current conversation",
+  description: "People in the current conversation",
+  dynamic: true,
   get: async (runtime, message) => {
     const { roomId, entityId } = message;
     const entitiesData = await getEntityDetails({ runtime, roomId });
@@ -9786,16 +9409,16 @@ function formatEvaluatorExamples(evaluators) {
       );
       let formattedPrompt = example.prompt;
       let formattedOutcome = example.outcome;
-      exampleNames.forEach((name2, index) => {
-        const placeholder = `{{user${index + 1}}}`;
-        formattedPrompt = formattedPrompt.replaceAll(placeholder, name2);
-        formattedOutcome = formattedOutcome.replaceAll(placeholder, name2);
+      exampleNames.forEach((name, index) => {
+        const placeholder = `{{name${index + 1}}}`;
+        formattedPrompt = formattedPrompt.replaceAll(placeholder, name);
+        formattedOutcome = formattedOutcome.replaceAll(placeholder, name);
       });
       const formattedMessages = example.messages.map((message) => {
         let messageString = `${message.name}: ${message.content.text}`;
-        exampleNames.forEach((name2, index) => {
-          const placeholder = `{{user${index + 1}}}`;
-          messageString = messageString.replaceAll(placeholder, name2);
+        exampleNames.forEach((name, index) => {
+          const placeholder = `{{name${index + 1}}}`;
+          messageString = messageString.replaceAll(placeholder, name);
         });
         return messageString + (message.content.actions ? ` (${message.content.actions.join(", ")})` : "");
       }).join("\n");
@@ -9857,7 +9480,7 @@ function formatFacts2(facts) {
 }
 var factsProvider = {
   name: "FACTS",
-  description: "Key facts that {{agentName}} knows",
+  description: "Key facts that the agent knows",
   dynamic: true,
   get: async (runtime, message, _state) => {
     const recentMessages = await runtime.getMemoryManager("messages").getMemories({
@@ -9866,10 +9489,9 @@ var factsProvider = {
       unique: false
     });
     const last5Messages = recentMessages.slice(-5).map((message2) => message2.content.text).join("\n");
-    const embedding = await runtime.useModel(
-      ModelTypes.TEXT_EMBEDDING,
-      last5Messages
-    );
+    const embedding = await runtime.useModel(ModelTypes.TEXT_EMBEDDING, {
+      text: last5Messages
+    });
     const memoryManager = new MemoryManager({
       runtime,
       tableName: "facts"
@@ -9919,7 +9541,7 @@ var factsProvider = {
 // src/providers/knowledge.ts
 var knowledgeProvider = {
   name: "KNOWLEDGE",
-  description: "Knowledge from the knowledge base that {{agentName}} knows",
+  description: "Knowledge from the knowledge base that the agent knows",
   dynamic: true,
   get: async (runtime, message) => {
     const knowledgeData = await runtime.getKnowledge(message);
@@ -9939,25 +9561,60 @@ var knowledgeProvider = {
   }
 };
 
-// src/providers/recentMessages.ts
-var getRecentInteractions2 = async (runtime, sourceEntityId, targetEntityId, excludeRoomId) => {
-  const rooms = await runtime.getDatabaseAdapter().getRoomsForParticipants([sourceEntityId, targetEntityId]);
-  return runtime.getMemoryManager("messages").getMemoriesByRoomIds({
-    // filter out the current room id from rooms
-    roomIds: rooms.filter((room) => room !== excludeRoomId),
-    limit: 20
-  });
-};
-var recentMessagesProvider = {
-  name: "RECENT_MESSAGES",
-  description: "Recent messages, interactions and other memories",
-  position: 100,
-  get: async (runtime, message) => {
-    const { roomId } = message;
-    const conversationLength = runtime.getConversationLength();
+// src/providers/providers.ts
+var providersProvider = {
+  name: "PROVIDERS",
+  description: "List of all data providers the agent can use to get additional information",
+  get: async (runtime, _message) => {
+    const dynamicProviders = runtime.providers.filter(
+      (provider) => provider.dynamic === true
+    );
+    const providerDescriptions = dynamicProviders.map((provider) => {
+      return `- **${provider.name}**: ${provider.description || "No description available"}`;
+    });
+    const headerText = "# Providers\n\nThese providers are available for the agent to select and use:";
+    if (providerDescriptions.length === 0) {
+      return {
+        text: addHeader(
+          headerText,
+          "No dynamic providers are currently available."
+        )
+      };
+    }
+    const providersText = providerDescriptions.join("\n");
+    const text = addHeader(headerText, providersText);
+    const data = {
+      dynamicProviders: dynamicProviders.map((provider) => ({
+        name: provider.name,
+        description: provider.description || ""
+      }))
+    };
+    return {
+      text,
+      data
+    };
+  }
+};
+
+// src/providers/recentMessages.ts
+var getRecentInteractions2 = async (runtime, sourceEntityId, targetEntityId, excludeRoomId) => {
+  const rooms = await runtime.getRoomsForParticipants([sourceEntityId, targetEntityId]);
+  return runtime.getMemoryManager("messages").getMemoriesByRoomIds({
+    // filter out the current room id from rooms
+    roomIds: rooms.filter((room) => room !== excludeRoomId),
+    limit: 20
+  });
+};
+var recentMessagesProvider = {
+  name: "RECENT_MESSAGES",
+  description: "Recent messages, interactions and other memories",
+  position: 100,
+  get: async (runtime, message) => {
+    const { roomId } = message;
+    const conversationLength = runtime.getConversationLength();
     const [entitiesData, room, recentMessagesData, recentInteractionsData] = await Promise.all([
       getEntityDetails({ runtime, roomId }),
-      runtime.getDatabaseAdapter().getRoom(roomId),
+      runtime.getRoom(roomId),
       runtime.getMemoryManager("messages").getMemories({
         roomId,
         count: conversationLength,
@@ -10005,7 +9662,7 @@ var recentMessagesProvider = {
       if (remainingEntityIds.length > 0) {
         const entities = await Promise.all(
           remainingEntityIds.map(
-            (entityId) => runtime.getDatabaseAdapter().getEntityById(entityId)
+            (entityId) => runtime.getEntityById(entityId)
           )
         );
         entities.forEach((entity, index) => {
@@ -10079,7 +9736,7 @@ async function formatRelationships(runtime, relationships) {
     new Set(sortedRelationships.map((rel) => rel.targetEntityId))
   );
   const entities = await Promise.all(
-    uniqueEntityIds.map((id) => runtime.getDatabaseAdapter().getEntityById(id))
+    uniqueEntityIds.map((id) => runtime.getEntityById(id))
   );
   const entityMap = /* @__PURE__ */ new Map();
   entities.forEach((entity, index) => {
@@ -10111,8 +9768,9 @@ ${formatMetadata(entity.metadata)}
 var relationshipsProvider = {
   name: "RELATIONSHIPS",
   description: "Relationships between {{agentName}} and other people, or between other people that {{agentName}} has observed interacting with",
+  dynamic: true,
   get: async (runtime, message) => {
-    const relationships = await runtime.getDatabaseAdapter().getRelationships({
+    const relationships = await runtime.getRelationships({
       entityId: message.entityId
     });
     if (!relationships || relationships.length === 0) {
@@ -10159,7 +9817,7 @@ var roleProvider = {
   name: "ROLES",
   description: "Roles in the server, default are OWNER, ADMIN and MEMBER (as well as NONE)",
   get: async (runtime, message, state) => {
-    const room = state.data.room ?? await runtime.getDatabaseAdapter().getRoom(message.roomId);
+    const room = state.data.room ?? await runtime.getRoom(message.roomId);
     if (!room) {
       throw new Error("No room found");
     }
@@ -10181,7 +9839,7 @@ var roleProvider = {
     try {
       logger.info(`Using server ID: ${serverId}`);
       const worldId = createUniqueUuid(runtime, serverId);
-      const world = await runtime.getDatabaseAdapter().getWorld(worldId);
+      const world = await runtime.getWorld(worldId);
       if (!world || !world.metadata?.ownership?.ownerId) {
         logger.info(
           `No ownership data found for server ${serverId}, initializing empty role hierarchy`
@@ -10214,8 +9872,8 @@ var roleProvider = {
       const members = [];
       for (const entityId of Object.keys(roles)) {
         const userRole = roles[entityId];
-        const user = await runtime.getDatabaseAdapter().getEntityById(entityId);
-        const name2 = user.metadata[room.source]?.name;
+        const user = await runtime.getEntityById(entityId);
+        const name = user.metadata[room.source]?.name;
         const username = user.metadata[room.source]?.username;
         const names4 = user.names;
         if (owners.some((owner) => owner.username === username) || admins.some((admin) => admin.username === username) || members.some((member) => member.username === username)) {
@@ -10223,13 +9881,13 @@ var roleProvider = {
         }
         switch (userRole) {
           case "OWNER":
-            owners.push({ name: name2, username, names: names4 });
+            owners.push({ name, username, names: names4 });
             break;
           case "ADMIN":
-            admins.push({ name: name2, username, names: names4 });
+            admins.push({ name, username, names: names4 });
             break;
           default:
-            members.push({ name: name2, username, names: names4 });
+            members.push({ name, username, names: names4 });
             break;
         }
       }
@@ -10300,17 +9958,43 @@ function createSettingFromConfig(configSetting) {
 }
 function getSalt(runtime) {
   const secretSalt = process.env.SECRET_SALT || "secretsalt";
-  return secretSalt + runtime.agentId;
+  const agentId = runtime.agentId;
+  if (!agentId) {
+    logger.warn("AgentId is missing when generating encryption salt");
+  }
+  const salt = secretSalt + (agentId || "");
+  logger.debug(
+    `Generated salt with length: ${salt.length} (truncated for security)`
+  );
+  return salt;
 }
 function saltSettingValue(setting, salt) {
   const settingCopy = { ...setting };
   if (setting.secret === true && typeof setting.value === "string" && setting.value) {
-    const key = crypto.createHash("sha256").update(salt).digest().slice(0, 32);
-    const iv = crypto.randomBytes(16);
-    const cipher = crypto.createCipheriv("aes-256-cbc", key, iv);
-    let encrypted = cipher.update(setting.value, "utf8", "hex");
-    encrypted += cipher.final("hex");
-    settingCopy.value = `${iv.toString("hex")}:${encrypted}`;
+    try {
+      const parts = setting.value.split(":");
+      if (parts.length === 2) {
+        try {
+          const possibleIv = Buffer.from(parts[0], "hex");
+          if (possibleIv.length === 16) {
+            logger.debug(
+              "Value appears to be already encrypted, skipping re-encryption"
+            );
+            return settingCopy;
+          }
+        } catch (e) {
+        }
+      }
+      const key = crypto.createHash("sha256").update(salt).digest().slice(0, 32);
+      const iv = crypto.randomBytes(16);
+      const cipher = crypto.createCipheriv("aes-256-cbc", key, iv);
+      let encrypted = cipher.update(setting.value, "utf8", "hex");
+      encrypted += cipher.final("hex");
+      settingCopy.value = `${iv.toString("hex")}:${encrypted}`;
+      logger.debug(`Successfully encrypted value with IV length: ${iv.length}`);
+    } catch (error) {
+      logger.error(`Error encrypting setting value: ${error}`);
+    }
   }
   return settingCopy;
 }
@@ -10320,10 +10004,17 @@ function unsaltSettingValue(setting, salt) {
     try {
       const parts = setting.value.split(":");
       if (parts.length !== 2) {
-        throw new Error("Invalid encrypted value format");
+        logger.warn(
+          `Invalid encrypted value format for setting - expected 'iv:encrypted'`
+        );
+        return settingCopy;
       }
       const iv = Buffer.from(parts[0], "hex");
       const encrypted = parts[1];
+      if (iv.length !== 16) {
+        logger.warn(`Invalid IV length (${iv.length}) - expected 16 bytes`);
+        return settingCopy;
+      }
       const key = crypto.createHash("sha256").update(salt).digest().slice(0, 32);
       const decipher = crypto.createDecipheriv("aes-256-cbc", key, iv);
       let decrypted = decipher.update(encrypted, "hex", "utf8");
@@ -10352,7 +10043,7 @@ function unsaltWorldSettings(worldSettings, salt) {
 async function updateWorldSettings2(runtime, serverId, worldSettings) {
   try {
     const worldId = createUniqueUuid(runtime, serverId);
-    const world = await runtime.getDatabaseAdapter().getWorld(worldId);
+    const world = await runtime.getWorld(worldId);
     if (!world) {
       logger.error(`No world found for server ${serverId}`);
       return false;
@@ -10363,7 +10054,7 @@ async function updateWorldSettings2(runtime, serverId, worldSettings) {
     const salt = getSalt(runtime);
     const saltedSettings = saltWorldSettings(worldSettings, salt);
     world.metadata.settings = saltedSettings;
-    await runtime.getDatabaseAdapter().updateWorld(world);
+    await runtime.updateWorld(world);
     return true;
   } catch (error) {
     logger.error(`Error updating settings state: ${error}`);
@@ -10373,7 +10064,7 @@ async function updateWorldSettings2(runtime, serverId, worldSettings) {
 async function getWorldSettings2(runtime, serverId) {
   try {
     const worldId = createUniqueUuid(runtime, serverId);
-    const world = await runtime.getDatabaseAdapter().getWorld(worldId);
+    const world = await runtime.getWorld(worldId);
     if (!world || !world.metadata?.settings) {
       return null;
     }
@@ -10405,7 +10096,7 @@ async function initializeOnboarding(runtime, world, config2) {
       world.metadata = {};
     }
     world.metadata.settings = worldSettings;
-    await runtime.getDatabaseAdapter().updateWorld(world);
+    await runtime.updateWorld(world);
     logger.info(`Initialized settings config for server ${world.serverId}`);
     return worldSettings;
   } catch (error) {
@@ -10422,7 +10113,7 @@ var formatSettingValue = (setting, isOnboarding) => {
 };
 function generateStatusMessage(runtime, worldSettings, isOnboarding, state) {
   try {
-    const formattedSettings = Object.entries(worldSettings).map(([_key, setting]) => {
+    const formattedSettings = Object.entries(worldSettings).map(([key, setting]) => {
       if (typeof setting !== "object" || !setting.name) return null;
       const description = setting.description || "";
       const usageDescription = setting.usageDescription || "";
@@ -10430,6 +10121,7 @@ function generateStatusMessage(runtime, worldSettings, isOnboarding, state) {
         return null;
       }
       return {
+        key,
         name: setting.name,
         value: formatSettingValue(setting, isOnboarding),
         description,
@@ -10446,9 +10138,13 @@ function generateStatusMessage(runtime, worldSettings, isOnboarding, state) {
         return `# PRIORITY TASK: Onboarding with ${state.senderName}
 ${runtime.character.name} still needs to configure ${requiredUnconfigured} required settings:
 
-${formattedSettings.filter((s) => s.required && !s.configured).map((s) => `${s.name}: ${s.usageDescription}
-Value: ${s.value}`).join(
-          "\n\n"
+${formattedSettings.filter((s) => s.required && !s.configured).map((s) => `${s.key}: ${s.value}
+(${s.name}) ${s.usageDescription}`).join("\n\n")}
+
+Valid settings keys: ${Object.keys(
+          worldSettings
+        ).join(
+          ", "
         )}
 
 If the user gives any information related to the settings, ${runtime.character.name} should use the UPDATE_SETTINGS action to update the settings with this new information. ${runtime.character.name} can update any, some or all settings.`;
@@ -10478,7 +10174,7 @@ var settingsProvider = {
   get: async (runtime, message, state) => {
     try {
       const [room, userWorld] = await Promise.all([
-        runtime.getDatabaseAdapter().getRoom(message.roomId),
+        runtime.getRoom(message.roomId),
         findWorldForOwner(runtime, message.entityId)
       ]).catch((error) => {
         logger.error(`Error fetching initial data: ${error}`);
@@ -10516,7 +10212,7 @@ var settingsProvider = {
         }
       } else {
         try {
-          world = await runtime.getDatabaseAdapter().getWorld(room.worldId);
+          world = await runtime.getWorld(room.worldId);
           serverId = world.serverId;
           if (serverId) {
             worldSettings = await getWorldSettings2(runtime, serverId);
@@ -10625,18 +10321,266 @@ var timeProvider = {
   }
 };
 
+// src/services/scenario.ts
+import { v4 as uuidv42 } from "uuid";
+var ScenarioService = class _ScenarioService extends Service {
+  /**
+   * Constructor for creating a new instance of the class.
+   *
+   * @param runtime - The IAgentRuntime instance to be passed to the constructor.
+   */
+  constructor(runtime) {
+    super(runtime);
+    this.runtime = runtime;
+    this.capabilityDescription = "The agent is currently in a scenario testing environment. It can create rooms, send messages, and talk to other agents in a live interactive testing environment.";
+    this.messageHandlers = /* @__PURE__ */ new Map();
+    this.worlds = /* @__PURE__ */ new Map();
+    this.activeActions = /* @__PURE__ */ new Map();
+    this.activeEvaluators = /* @__PURE__ */ new Map();
+    this.setupEventListeners();
+  }
+  static {
+    this.serviceType = "scenario";
+  }
+  setupEventListeners() {
+    this.runtime.registerEvent("ACTION_STARTED" /* ACTION_STARTED */, async (data) => {
+      this.activeActions.set(data.actionId, {
+        actionId: data.actionId,
+        actionName: data.actionName,
+        startTime: Date.now(),
+        completed: false
+      });
+      return Promise.resolve();
+    });
+    this.runtime.registerEvent("ACTION_COMPLETED" /* ACTION_COMPLETED */, async (data) => {
+      const action = this.activeActions.get(data.actionId);
+      if (action) {
+        action.completed = true;
+        action.error = data.error;
+      }
+      return Promise.resolve();
+    });
+    this.runtime.registerEvent("EVALUATOR_STARTED" /* EVALUATOR_STARTED */, async (data) => {
+      this.activeEvaluators.set(data.evaluatorId, {
+        evaluatorId: data.evaluatorId,
+        evaluatorName: data.evaluatorName,
+        startTime: Date.now(),
+        completed: false
+      });
+      logger_default.debug("Evaluator started", data);
+      return Promise.resolve();
+    });
+    this.runtime.registerEvent("EVALUATOR_COMPLETED" /* EVALUATOR_COMPLETED */, async (data) => {
+      const evaluator = this.activeEvaluators.get(data.evaluatorId);
+      if (evaluator) {
+        evaluator.completed = true;
+        evaluator.error = data.error;
+      }
+      logger_default.debug("Evaluator completed", data);
+      return Promise.resolve();
+    });
+  }
+  /**
+   * Start the scenario service with the given runtime.
+   * @param {IAgentRuntime} runtime - The agent runtime
+   * @returns {Promise<ScenarioService>} - The started scenario service
+   */
+  static async start(runtime) {
+    const service = new _ScenarioService(runtime);
+    return service;
+  }
+  /**
+   * Stops the Scenario service associated with the given runtime.
+   *
+   * @param {IAgentRuntime} runtime The runtime to stop the service for.
+   * @throws {Error} When the Scenario service is not found.
+   */
+  static async stop(runtime) {
+    const service = runtime.getService(_ScenarioService.serviceType);
+    if (!service) {
+      throw new Error("Scenario service not found");
+    }
+    service.stop();
+  }
+  /**
+   * Asynchronously stops the current process by clearing all message handlers and worlds.
+   */
+  async stop() {
+    this.messageHandlers.clear();
+    this.worlds.clear();
+    this.activeActions.clear();
+    this.activeEvaluators.clear();
+  }
+  /**
+   * Creates a new world with the specified name and owner.
+   * @param name The name of the world
+   * @param ownerName The name of the world owner
+   * @returns The created world's ID
+   */
+  async createWorld(name, ownerName) {
+    const serverId = createUniqueUuid(this.runtime.agentId, name);
+    const worldId = uuidv42();
+    const ownerId = uuidv42();
+    const world = {
+      id: worldId,
+      name,
+      serverId,
+      agentId: this.runtime.agentId,
+      // TODO: get the server id, create it or whatever
+      metadata: {
+        // this is wrong, the owner needs to be tracked by scenario and similar to how we do it with Discord etc
+        owner: {
+          id: ownerId,
+          name: ownerName
+        }
+      }
+    };
+    this.worlds.set(worldId, world);
+    return worldId;
+  }
+  /**
+   * Creates a room in the specified world.
+   * @param worldId The ID of the world to create the room in
+   * @param name The name of the room
+   * @returns The created room's ID
+   */
+  async createRoom(worldId, name) {
+    const world = this.worlds.get(worldId);
+    if (!world) {
+      throw new Error(`World ${worldId} not found`);
+    }
+    const roomId = uuidv42();
+    await this.runtime.ensureRoomExists({
+      id: roomId,
+      name,
+      source: "scenario",
+      type: "GROUP" /* GROUP */,
+      channelId: roomId,
+      serverId: worldId
+    });
+    return roomId;
+  }
+  /**
+   * Adds a participant to a room
+   * @param worldId The world ID
+   * @param roomId The room ID
+   * @param participantId The participant's ID
+   */
+  async addParticipant(worldId, roomId, participantId) {
+    const world = this.worlds.get(worldId);
+    if (!world) {
+      throw new Error(`World ${worldId} not found`);
+    }
+    const room = this.runtime.getRoom(roomId);
+    if (!room) {
+      throw new Error(`Room ${roomId} not found in world ${worldId}`);
+    }
+    await this.runtime.addParticipant(roomId, participantId);
+  }
+  /**
+   * Sends a message in a specific room
+   * @param sender The runtime of the sending agent
+   * @param worldId The world ID
+   * @param roomId The room ID
+   * @param text The message text
+   */
+  async sendMessage(sender, worldId, roomId, text) {
+    const world = this.worlds.get(worldId);
+    if (!world) {
+      throw new Error(`World ${worldId} not found`);
+    }
+    const memory = {
+      entityId: sender.agentId,
+      agentId: sender.agentId,
+      roomId,
+      content: {
+        text,
+        source: "scenario",
+        name: sender.character.name,
+        userName: sender.character.name,
+        channelType: "GROUP" /* GROUP */
+      }
+    };
+    const participants = await this.runtime.getParticipantsForRoom(roomId);
+    for (const participantId of participants) {
+      this.runtime.emitEvent("MESSAGE_RECEIVED", {
+        runtime: this.runtime,
+        message: memory,
+        roomId,
+        entityId: participantId,
+        source: "scenario",
+        type: "GROUP" /* GROUP */
+      });
+    }
+  }
+  /**
+   * Waits for all active actions and evaluators to complete
+   * @param timeout Maximum time to wait in milliseconds
+   * @returns True if all completed successfully, false if timeout occurred
+   */
+  async waitForCompletion(timeout = 3e4) {
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeout) {
+      const allActionsComplete = Array.from(this.activeActions.values()).every(
+        (action) => action.completed
+      );
+      const allEvaluatorsComplete = Array.from(this.activeEvaluators.values()).every(
+        (evaluator) => evaluator.completed
+      );
+      if (allActionsComplete && allEvaluatorsComplete) {
+        return true;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    return false;
+  }
+  /**
+   * Gets the current state of all active actions and evaluators
+   */
+  getActiveState() {
+    return {
+      actions: Array.from(this.activeActions.values()),
+      evaluators: Array.from(this.activeEvaluators.values())
+    };
+  }
+  /**
+   * Cleans up the scenario state
+   */
+  async cleanup() {
+    this.worlds.clear();
+    this.activeActions.clear();
+    this.activeEvaluators.clear();
+    this.messageHandlers.clear();
+  }
+};
+
 // src/services/task.ts
 var TaskService = class _TaskService extends Service {
-  timer = null;
-  TICK_INTERVAL = 1e3;
-  // Check every second
-  static serviceType = ServiceTypes.TASK;
-  capabilityDescription = "The agent is able to schedule and execute tasks";
+  constructor() {
+    super(...arguments);
+    this.timer = null;
+    this.TICK_INTERVAL = 1e3;
+    this.capabilityDescription = "The agent is able to schedule and execute tasks";
+  }
+  static {
+    // Check every second
+    this.serviceType = ServiceTypes.TASK;
+  }
+  /**
+   * Start the TaskService with the given runtime.
+   * @param {IAgentRuntime} runtime - The runtime for the TaskService.
+   * @returns {Promise<TaskService>} A promise that resolves with the TaskService instance.
+   */
   static async start(runtime) {
     const service = new _TaskService(runtime);
     await service.startTimer();
+    await service.createTestTasks();
     return service;
   }
+  /**
+   * Asynchronously creates test tasks by registering task workers for repeating and one-time tasks,
+   * validates the tasks, executes the tasks, and creates the tasks if they do not already exist.
+   */
   async createTestTasks() {
     this.runtime.registerTaskWorker({
       name: "REPEATING_TEST_TASK",
@@ -10658,9 +10602,9 @@ var TaskService = class _TaskService extends Service {
         logger_default.debug("Executing one-time test task");
       }
     });
-    const tasks = await this.runtime.getDatabaseAdapter().getTasksByName("REPEATING_TEST_TASK");
+    const tasks = await this.runtime.getTasksByName("REPEATING_TEST_TASK");
     if (tasks.length === 0) {
-      await this.runtime.getDatabaseAdapter().createTask({
+      await this.runtime.createTask({
         name: "REPEATING_TEST_TASK",
         description: "A test task that repeats every minute",
         metadata: {
@@ -10672,7 +10616,7 @@ var TaskService = class _TaskService extends Service {
         tags: ["queue", "repeat", "test"]
       });
     }
-    await this.runtime.getDatabaseAdapter().createTask({
+    await this.runtime.createTask({
       name: "ONETIME_TEST_TASK",
       description: "A test task that runs once",
       metadata: {
@@ -10681,14 +10625,29 @@ var TaskService = class _TaskService extends Service {
       tags: ["queue", "test"]
     });
   }
+  /**
+   * Starts a timer that runs a function to check tasks at a specified interval.
+   */
   startTimer() {
     if (this.timer) {
       clearInterval(this.timer);
     }
     this.timer = setInterval(async () => {
-      await this.checkTasks();
+      try {
+        await this.checkTasks();
+      } catch (error) {
+        logger_default.error("Error checking tasks:", error);
+      }
     }, this.TICK_INTERVAL);
   }
+  /**
+   * Validates an array of Task objects.
+   * Skips tasks without IDs or if no worker is found for the task.
+   * If a worker has a `validate` function, it will run the validation using the `runtime`, `Memory`, and `State` parameters.
+   * If the validation fails, the task will be skipped and the error will be logged.
+   * @param {Task[]} tasks - An array of Task objects to validate.
+   * @returns {Promise<Task[]>} - A Promise that resolves with an array of validated Task objects.
+   */
   async validateTasks(tasks) {
     const validatedTasks = [];
     for (const task of tasks) {
@@ -10718,9 +10677,14 @@ var TaskService = class _TaskService extends Service {
     }
     return validatedTasks;
   }
+  /**
+   * Asynchronous method that checks tasks with "queue" tag, validates and sorts them, then executes them based on interval and tags.
+   *
+   * @returns {Promise<void>} Promise that resolves once all tasks are checked and executed
+   */
   async checkTasks() {
     try {
-      const allTasks = await this.runtime.getDatabaseAdapter().getTasks({
+      const allTasks = await this.runtime.getTasks({
         tags: ["queue"]
       });
       const tasks = await this.validateTasks(allTasks);
@@ -10729,8 +10693,17 @@ var TaskService = class _TaskService extends Service {
       }
       const now = Date.now();
       for (const task of tasks) {
-        const taskStartTime = new Date(task.updatedAt || 0).getTime();
-        const updateIntervalMs = task.metadata.updateInterval ?? 0;
+        let taskStartTime;
+        if (typeof task.updatedAt === "number") {
+          taskStartTime = task.updatedAt;
+        } else if (task.metadata?.updatedAt && typeof task.metadata.updatedAt === "number") {
+          taskStartTime = task.metadata.updatedAt;
+        } else if (task.updatedAt) {
+          taskStartTime = new Date(task.updatedAt).getTime();
+        } else {
+          taskStartTime = 0;
+        }
+        const updateIntervalMs = task.metadata?.updateInterval ?? 0;
         if (!task.tags?.includes("repeat")) {
           await this.executeTask(task);
           continue;
@@ -10746,6 +10719,11 @@ var TaskService = class _TaskService extends Service {
       logger_default.error("Error checking tasks:", error);
     }
   }
+  /**
+   * Executes a given task asynchronously.
+   *
+   * @param {Task} task - The task to be executed.
+   */
   async executeTask(task) {
     try {
       if (!task) {
@@ -10758,10 +10736,10 @@ var TaskService = class _TaskService extends Service {
         return;
       }
       logger_default.debug(`Executing task ${task.name} (${task.id})`);
-      await worker.execute(this.runtime, task.metadata || {});
+      await worker.execute(this.runtime, task.metadata || {}, task);
       logger_default.debug("task.tags are", task.tags);
       if (task.tags?.includes("repeat")) {
-        await this.runtime.getDatabaseAdapter().updateTask(task.id, {
+        await this.runtime.updateTask(task.id, {
           metadata: {
             ...task.metadata,
             updatedAt: Date.now()
@@ -10771,7 +10749,7 @@ var TaskService = class _TaskService extends Service {
           `Updated repeating task ${task.name} (${task.id}) with new timestamp`
         );
       } else {
-        await this.runtime.getDatabaseAdapter().deleteTask(task.id);
+        await this.runtime.deleteTask(task.id);
         logger_default.debug(
           `Deleted non-repeating task ${task.name} (${task.id}) after execution`
         );
@@ -10780,12 +10758,21 @@ var TaskService = class _TaskService extends Service {
       logger_default.error(`Error executing task ${task.id}:`, error);
     }
   }
+  /**
+   * Stops the TASK service in the given agent runtime.
+   *
+   * @param {IAgentRuntime} runtime - The agent runtime containing the service.
+   * @returns {Promise<void>} - A promise that resolves once the service has been stopped.
+   */
   static async stop(runtime) {
     const service = runtime.getService(ServiceTypes.TASK);
     if (service) {
       await service.stop();
     }
   }
+  /**
+   * Stops the timer if it is currently running.
+   */
   async stop() {
     if (this.timer) {
       clearInterval(this.timer);
@@ -10794,270 +10781,276 @@ var TaskService = class _TaskService extends Service {
   }
 };
 
-// src/services/scenario.ts
-import { v4 as uuidv42 } from "uuid";
-var ScenarioService = class _ScenarioService extends Service {
-  constructor(runtime) {
-    super(runtime);
-    this.runtime = runtime;
-  }
-  static serviceType = "scenario";
-  capabilityDescription = "The agent is currently in a scenario testing environment. It can create rooms, send messages, and talk to other agents in a live interactive testing environment.";
-  messageHandlers = /* @__PURE__ */ new Map();
-  rooms = /* @__PURE__ */ new Map();
-  static async start(runtime) {
-    const service = new _ScenarioService(runtime);
-    return service;
-  }
-  static async stop(runtime) {
-    const service = runtime.getService(_ScenarioService.serviceType);
-    if (!service) {
-      throw new Error("Scenario service not found");
-    }
-    service.stop();
-  }
-  async stop() {
-    this.messageHandlers.clear();
-    this.rooms.clear();
-  }
-  // Create a room for an agent
-  async createRoom(agentId, name2) {
-    const roomId = uuidv42();
-    await this.runtime.ensureRoomExists({
-      id: roomId,
-      name: name2 || `Room for ${agentId}`,
-      source: "scenario",
-      type: "GROUP" /* GROUP */,
-      channelId: roomId,
-      serverId: null
-    });
-    this.rooms.set(agentId, { roomId });
+// src/bootstrap.ts
+var latestResponseIds = /* @__PURE__ */ new Map();
+var messageReceivedHandler = async ({
+  runtime,
+  message,
+  callback
+}) => {
+  const responseId = v4();
+  if (!latestResponseIds.has(runtime.agentId)) {
+    latestResponseIds.set(runtime.agentId, /* @__PURE__ */ new Map());
   }
-  // Save a message in all agents' memory without emitting events
-  async saveMessage(sender, receivers, text) {
-    for (const receiver of receivers) {
-      const roomData = this.rooms.get(receiver.agentId);
-      if (!roomData) continue;
-      const entityId = createUniqueUuid(receiver, sender.agentId);
-      await receiver.ensureConnection({
-        entityId,
-        roomId: roomData.roomId,
-        userName: sender.character.name,
-        name: sender.character.name,
-        source: "scenario",
-        type: "GROUP" /* GROUP */
+  const agentResponses = latestResponseIds.get(runtime.agentId);
+  agentResponses.set(message.roomId, responseId);
+  const runId = v4();
+  const startTime = Date.now();
+  await runtime.emitEvent("RUN_STARTED" /* RUN_STARTED */, {
+    runtime,
+    runId,
+    messageId: message.id,
+    roomId: message.roomId,
+    entityId: message.entityId,
+    startTime,
+    status: "started",
+    source: "messageHandler"
+  });
+  const timeoutDuration = 5 * 60 * 1e3;
+  let timeoutId;
+  const timeoutPromise = new Promise((_, reject) => {
+    timeoutId = setTimeout(async () => {
+      await runtime.emitEvent("RUN_TIMEOUT" /* RUN_TIMEOUT */, {
+        runtime,
+        runId,
+        messageId: message.id,
+        roomId: message.roomId,
+        entityId: message.entityId,
+        startTime,
+        status: "timeout",
+        endTime: Date.now(),
+        duration: Date.now() - startTime,
+        error: "Run exceeded 5 minute timeout",
+        source: "messageHandler"
       });
-      const memory = {
-        entityId,
-        agentId: receiver.agentId,
-        roomId: roomData.roomId,
-        content: {
-          text,
-          source: "scenario",
-          name: sender.character.name,
-          userName: sender.character.name,
-          channelType: "GROUP" /* GROUP */
-        }
-      };
-      await receiver.getMemoryManager("messages").createMemory(memory);
-    }
-  }
-  // Send a live message that triggers handlers
-  async sendMessage(sender, receivers, text) {
-    for (const receiver of receivers) {
-      const roomData = this.rooms.get(receiver.agentId);
-      if (!roomData) continue;
-      const entityId = createUniqueUuid(receiver, sender.agentId);
-      if (receiver.agentId !== sender.agentId) {
-        await receiver.ensureConnection({
-          entityId,
-          roomId: roomData.roomId,
-          userName: sender.character.name,
-          name: sender.character.name,
-          source: "scenario",
-          type: "GROUP" /* GROUP */
+      reject(new Error("Run exceeded 5 minute timeout"));
+    }, timeoutDuration);
+  });
+  const processingPromise = (async () => {
+    try {
+      if (message.entityId === runtime.agentId) {
+        throw new Error("Message is from the agent itself");
+      }
+      await Promise.all([
+        runtime.getMemoryManager("messages").addEmbeddingToMemory(message),
+        runtime.getMemoryManager("messages").createMemory(message)
+      ]);
+      const agentUserState = await runtime.getParticipantUserState(message.roomId, runtime.agentId);
+      if (agentUserState === "MUTED" && !message.content.text.toLowerCase().includes(runtime.character.name.toLowerCase())) {
+        console.log("Ignoring muted room");
+        return;
+      }
+      let state = await runtime.composeState(message, [
+        "PROVIDERS",
+        "SHOULD_RESPOND",
+        "CHARACTER",
+        "RECENT_MESSAGES",
+        "ENTITIES"
+      ]);
+      const shouldRespondPrompt = composePromptFromState({
+        state,
+        template: runtime.character.templates?.shouldRespondTemplate || shouldRespondTemplate
+      });
+      logger.debug(
+        `*** Should Respond Prompt for ${runtime.character.name} ***`,
+        shouldRespondPrompt
+      );
+      const response = await runtime.useModel(ModelTypes.TEXT_SMALL, {
+        prompt: shouldRespondPrompt
+      });
+      logger.debug(
+        `*** Should Respond Response for ${runtime.character.name} ***`,
+        response
+      );
+      const responseObject = parseJSONObjectFromText(response);
+      const providers = responseObject.providers;
+      const shouldRespond = responseObject?.action && responseObject.action === "RESPOND";
+      state = await runtime.composeState(message, null, providers);
+      let responseMessages = [];
+      if (shouldRespond) {
+        const prompt = composePromptFromState({
+          state,
+          template: runtime.character.templates?.messageHandlerTemplate || messageHandlerTemplate
         });
-      } else {
-        await receiver.ensureConnection({
-          entityId: sender.agentId,
-          roomId: roomData.roomId,
-          userName: sender.character.name,
-          name: sender.character.name,
-          source: "scenario",
-          type: "GROUP" /* GROUP */
+        let responseContent = null;
+        let retries = 0;
+        const maxRetries = 3;
+        while (retries < maxRetries && (!responseContent?.thought || !responseContent?.plan || !responseContent?.actions)) {
+          const response2 = await runtime.useModel(ModelTypes.TEXT_SMALL, {
+            prompt
+          });
+          responseContent = parseJSONObjectFromText(response2);
+          retries++;
+          if (!responseContent?.thought || !responseContent?.plan || !responseContent?.actions) {
+            logger.warn("*** Missing required fields, retrying... ***");
+          }
+        }
+        const currentResponseId = agentResponses.get(message.roomId);
+        if (currentResponseId !== responseId) {
+          logger.info(
+            `Response discarded - newer message being processed for agent: ${runtime.agentId}, room: ${message.roomId}`
+          );
+          return;
+        }
+        responseContent.plan = responseContent.plan?.trim();
+        responseContent.inReplyTo = createUniqueUuid(runtime, message.id);
+        responseMessages = [
+          {
+            id: v4(),
+            entityId: runtime.agentId,
+            agentId: runtime.agentId,
+            content: responseContent,
+            roomId: message.roomId,
+            createdAt: Date.now()
+          }
+        ];
+        await runtime.getMemoryManager("messages").createMemory({
+          entityId: runtime.agentId,
+          agentId: runtime.agentId,
+          content: {
+            thought: responseContent.thought,
+            plan: responseContent.plan,
+            actions: responseContent.actions,
+            providers: responseContent.providers
+          },
+          roomId: message.roomId,
+          createdAt: Date.now()
         });
-      }
-      const memory = {
-        entityId: receiver.agentId !== sender.agentId ? entityId : sender.agentId,
-        agentId: receiver.agentId,
-        roomId: roomData.roomId,
-        content: {
-          text,
-          source: "scenario",
-          name: sender.character.name,
-          userName: sender.character.name,
-          channelType: "GROUP" /* GROUP */
+        agentResponses.delete(message.roomId);
+        if (agentResponses.size === 0) {
+          latestResponseIds.delete(runtime.agentId);
         }
-      };
-      receiver.emitEvent("MESSAGE_RECEIVED", {
-        runtime: receiver,
-        message: memory,
-        roomId: roomData.roomId,
-        entityId: receiver.agentId !== sender.agentId ? entityId : sender.agentId,
-        source: "scenario",
-        type: "GROUP" /* GROUP */
+        await runtime.processActions(message, responseMessages, state, callback);
+      }
+      await runtime.evaluate(
+        message,
+        state,
+        shouldRespond,
+        callback,
+        responseMessages
+      );
+      await runtime.emitEvent("RUN_ENDED" /* RUN_ENDED */, {
+        runtime,
+        runId,
+        messageId: message.id,
+        roomId: message.roomId,
+        entityId: message.entityId,
+        startTime,
+        status: "completed",
+        endTime: Date.now(),
+        duration: Date.now() - startTime,
+        source: "messageHandler"
       });
+    } catch (error) {
+      await runtime.emitEvent("RUN_ENDED" /* RUN_ENDED */, {
+        runtime,
+        runId,
+        messageId: message.id,
+        roomId: message.roomId,
+        entityId: message.entityId,
+        startTime,
+        status: "completed",
+        endTime: Date.now(),
+        duration: Date.now() - startTime,
+        error: error.message,
+        source: "messageHandler"
+      });
+      throw error;
     }
-  }
-  // Get conversation history for all participants
-  async getConversations(participants) {
-    const conversations = await Promise.all(
-      participants.map(async (member) => {
-        const roomData = this.rooms.get(member.agentId);
-        if (!roomData) return [];
-        return member.getMemoryManager("messages").getMemories({
-          roomId: roomData.roomId
-        });
-      })
-    );
-    logger.info("\nConversation logs per agent:");
-    conversations.forEach((convo, i) => {
-      logger.info(`
-${participants[i].character.name}'s perspective:`);
-      convo.forEach(
-        (msg) => logger.info(`${msg.content.name}: ${msg.content.text}`)
-      );
-    });
-    return conversations;
+  })();
+  try {
+    await Promise.race([processingPromise, timeoutPromise]);
+  } finally {
+    clearTimeout(timeoutId);
   }
 };
-
-// src/bootstrap.ts
-var latestResponseIds = /* @__PURE__ */ new Map();
-var messageReceivedHandler = async ({
+var reactionReceivedHandler = async ({
+  runtime,
+  message
+}) => {
+  try {
+    await runtime.getMemoryManager("messages").createMemory(message);
+  } catch (error) {
+    if (error.code === "23505") {
+      logger.warn("Duplicate reaction memory, skipping");
+      return;
+    }
+    logger.error("Error in reaction handler:", error);
+  }
+};
+var postGeneratedHandler = async ({
   runtime,
   message,
   callback
 }) => {
-  const responseId = v4();
-  if (!latestResponseIds.has(runtime.agentId)) {
-    latestResponseIds.set(runtime.agentId, /* @__PURE__ */ new Map());
-  }
-  const agentResponses = latestResponseIds.get(runtime.agentId);
-  agentResponses.set(message.roomId, responseId);
-  if (message.entityId === runtime.agentId) {
-    throw new Error("Message is from the agent itself");
-  }
   await Promise.all([
     runtime.getMemoryManager("messages").addEmbeddingToMemory(message),
     runtime.getMemoryManager("messages").createMemory(message)
   ]);
-  const agentUserState = await runtime.getDatabaseAdapter().getParticipantUserState(message.roomId, runtime.agentId);
-  if (agentUserState === "MUTED" && !message.content.text.toLowerCase().includes(runtime.character.name.toLowerCase())) {
-    console.log("Ignoring muted room");
-    return;
-  }
   let state = await runtime.composeState(message, [
     "PROVIDERS",
-    "SHOULD_RESPOND",
     "CHARACTER",
     "RECENT_MESSAGES",
     "ENTITIES"
   ]);
-  const shouldRespondPrompt = composePrompt({
+  const providers = state.providers || [];
+  state = await runtime.composeState(message, null, providers);
+  const promptTemplate = runtime.character.templates?.postTemplate || runtime.character.templates?.messageHandlerTemplate || messageHandlerTemplate;
+  const prompt = composePromptFromState({
     state,
-    template: runtime.character.templates?.shouldRespondTemplate || shouldRespondTemplate
-  });
-  const response = await runtime.useModel(ModelTypes.TEXT_SMALL, {
-    prompt: shouldRespondPrompt
+    template: promptTemplate
   });
-  const responseObject = parseJSONObjectFromText(response);
-  const providers = responseObject.providers;
-  const shouldRespond = responseObject?.action && responseObject.action === "RESPOND";
-  state = await runtime.composeState(message, null, providers);
-  let responseMessages = [];
-  if (shouldRespond) {
-    const prompt = composePrompt({
-      state,
-      template: runtime.character.templates?.messageHandlerTemplate || messageHandlerTemplate
-    });
-    let responseContent = null;
-    let retries = 0;
-    const maxRetries = 3;
-    while (retries < maxRetries && (!responseContent?.thought || !responseContent?.plan || !responseContent?.actions)) {
-      const response2 = await runtime.useModel(ModelTypes.TEXT_SMALL, {
-        prompt
-      });
-      responseContent = parseJSONObjectFromText(response2);
-      retries++;
-      if (!responseContent?.thought || !responseContent?.plan || !responseContent?.actions) {
-        logger.warn("*** Missing required fields, retrying... ***");
-      }
-    }
-    const currentResponseId = agentResponses.get(message.roomId);
-    if (currentResponseId !== responseId) {
-      logger.info(
-        `Response discarded - newer message being processed for agent: ${runtime.agentId}, room: ${message.roomId}`
-      );
-      return;
+  let responseContent = null;
+  let retries = 0;
+  const maxRetries = 3;
+  while (retries < maxRetries && (!responseContent?.thought || !responseContent?.plan || !responseContent?.text)) {
+    const response = await runtime.useModel(ModelTypes.TEXT_SMALL, {
+      prompt
+    });
+    responseContent = parseJSONObjectFromText(response);
+    retries++;
+    if (!responseContent?.thought || !responseContent?.plan || !responseContent?.text) {
+      logger.warn("*** Missing required fields, retrying... ***");
     }
-    responseContent.plan = responseContent.plan?.trim();
-    responseContent.inReplyTo = createUniqueUuid(runtime, message.id);
-    responseMessages = [
-      {
-        id: v4(),
-        entityId: runtime.agentId,
-        agentId: runtime.agentId,
-        content: responseContent,
-        roomId: message.roomId,
-        createdAt: Date.now()
-      }
-    ];
-    await runtime.getMemoryManager("messages").createMemory({
+  }
+  const responseMessages = [
+    {
+      id: v4(),
       entityId: runtime.agentId,
       agentId: runtime.agentId,
-      content: {
-        thought: responseContent.thought,
-        plan: responseContent.plan,
-        actions: responseContent.actions,
-        providers: responseContent.providers
-      },
+      content: responseContent,
       roomId: message.roomId,
       createdAt: Date.now()
-    });
-    agentResponses.delete(message.roomId);
-    if (agentResponses.size === 0) {
-      latestResponseIds.delete(runtime.agentId);
     }
-    await runtime.processActions(message, responseMessages, state, callback);
-  }
+  ];
+  await runtime.getMemoryManager("messages").createMemory({
+    entityId: runtime.agentId,
+    agentId: runtime.agentId,
+    content: {
+      thought: responseContent.thought,
+      plan: responseContent.plan,
+      text: responseContent.text,
+      providers: responseContent.providers
+    },
+    roomId: message.roomId,
+    createdAt: Date.now()
+  });
+  await runtime.processActions(message, responseMessages, state, callback);
   await runtime.evaluate(
     message,
     state,
-    shouldRespond,
+    true,
+    // Post generation is always a "responding" scenario
     callback,
     responseMessages
   );
 };
-var reactionReceivedHandler = async ({
-  runtime,
-  message
-}) => {
-  try {
-    await runtime.getMemoryManager("messages").createMemory(message);
-  } catch (error) {
-    if (error.code === "23505") {
-      logger.warn("Duplicate reaction memory, skipping");
-      return;
-    }
-    logger.error("Error in reaction handler:", error);
-  }
-};
-var syncSingleUser = async (entityId, runtime, user, serverId, channelId, type, source) => {
-  logger.info(`Syncing user: ${user.username || user.id}`);
+var syncSingleUser = async (entityId, runtime, serverId, channelId, type, source) => {
+  const entity = await runtime.getEntityById(entityId);
+  logger.info(`Syncing user: ${entity.metadata[source].username || entity.id}`);
   try {
     if (!channelId) {
-      logger.warn(`Cannot sync user ${user.id} without a valid channelId`);
+      logger.warn(`Cannot sync user ${entity.id} without a valid channelId`);
       return;
     }
     const roomId = createUniqueUuid(runtime, channelId);
@@ -11065,15 +11058,15 @@ var syncSingleUser = async (entityId, runtime, user, serverId, channelId, type,
     await runtime.ensureConnection({
       entityId,
       roomId,
-      userName: user.username || user.displayName || `User${user.id}`,
-      name: user.displayName || user.username || `User${user.id}`,
+      userName: entity.metadata[source].username || entity.id,
+      name: entity.metadata[source].name || entity.metadata[source].username || `User${entity.id}`,
       source,
       channelId,
       serverId,
       type,
       worldId
     });
-    logger.success(`Successfully synced user: ${user.username || user.id}`);
+    logger.success(`Successfully synced user: ${entity.id}`);
   } catch (error) {
     logger.error(
       `Error syncing user: ${error instanceof Error ? error.message : String(error)}`
@@ -11084,7 +11077,7 @@ var handleServerSync = async ({
   runtime,
   world,
   rooms,
-  users,
+  entities,
   source
 }) => {
   logger.info(`Handling server sync event for server: ${world.name}`);
@@ -11111,10 +11104,10 @@ var handleServerSync = async ({
         });
       }
     }
-    if (users && users.length > 0) {
+    if (entities && entities.length > 0) {
       const batchSize = 50;
-      for (let i = 0; i < users.length; i += batchSize) {
-        const entityBatch = users.slice(i, i + batchSize);
+      for (let i = 0; i < entities.length; i += batchSize) {
+        const entityBatch = entities.slice(i, i + batchSize);
         const firstRoomUserIsIn = rooms.length > 0 ? rooms[0] : null;
         await Promise.all(
           entityBatch.map(async (entity) => {
@@ -11137,7 +11130,7 @@ var handleServerSync = async ({
             }
           })
         );
-        if (i + batchSize < users.length) {
+        if (i + batchSize < entities.length) {
           await new Promise((resolve) => setTimeout(resolve, 500));
         }
       }
@@ -11152,54 +11145,114 @@ var handleServerSync = async ({
   }
 };
 var events = {
-  MESSAGE_RECEIVED: [
-    async ({ runtime, message, callback }) => {
+  ["MESSAGE_RECEIVED" /* MESSAGE_RECEIVED */]: [
+    async (payload) => {
       await messageReceivedHandler({
-        runtime,
-        message,
-        callback
+        runtime: payload.runtime,
+        message: payload.message,
+        callback: payload.callback
       });
     }
   ],
-  VOICE_MESSAGE_RECEIVED: [
-    async ({ runtime, message, callback }) => {
+  ["VOICE_MESSAGE_RECEIVED" /* VOICE_MESSAGE_RECEIVED */]: [
+    async (payload) => {
       await messageReceivedHandler({
-        runtime,
-        message,
-        callback
+        runtime: payload.runtime,
+        message: payload.message,
+        callback: payload.callback
       });
     }
   ],
-  REACTION_RECEIVED: [reactionReceivedHandler],
-  // Both events now use the same handler function
-  SERVER_JOINED: [handleServerSync],
-  SERVER_CONNECTED: [handleServerSync],
-  USER_JOINED: [
-    async ({
-      runtime,
-      user,
-      serverId,
-      entityId,
-      channelId,
-      channelType,
-      source
-    }) => {
+  ["REACTION_RECEIVED" /* REACTION_RECEIVED */]: [
+    async (payload) => {
+      await reactionReceivedHandler({
+        runtime: payload.runtime,
+        message: payload.message
+      });
+    }
+  ],
+  ["POST_GENERATED" /* POST_GENERATED */]: [
+    async (payload) => {
+      await postGeneratedHandler({
+        runtime: payload.runtime,
+        message: payload.message,
+        callback: payload.callback
+      });
+    }
+  ],
+  ["MESSAGE_SENT" /* MESSAGE_SENT */]: [
+    async (payload) => {
+      logger.debug(`Message sent: ${payload.message.content.text}`);
+    }
+  ],
+  ["WORLD_JOINED" /* WORLD_JOINED */]: [
+    async (payload) => {
+      await handleServerSync(payload);
+    }
+  ],
+  ["WORLD_CONNECTED" /* WORLD_CONNECTED */]: [
+    async (payload) => {
+      await handleServerSync(payload);
+    }
+  ],
+  ["ENTITY_JOINED" /* ENTITY_JOINED */]: [
+    async (payload) => {
       await syncSingleUser(
-        entityId,
-        runtime,
-        user,
-        serverId,
-        channelId,
-        channelType,
-        source
+        payload.entityId,
+        payload.runtime,
+        payload.worldId,
+        payload.roomId,
+        payload.metadata.type,
+        payload.source
       );
     }
+  ],
+  ["ENTITY_LEFT" /* ENTITY_LEFT */]: [
+    async (payload) => {
+      try {
+        const entity = await payload.runtime.getEntityById(payload.entityId);
+        if (entity) {
+          entity.metadata = {
+            ...entity.metadata,
+            status: "INACTIVE",
+            leftAt: Date.now()
+          };
+          await payload.runtime.updateEntity(entity);
+        }
+        logger.info(`User ${payload.entityId} left world ${payload.worldId}`);
+      } catch (error) {
+        logger.error(`Error handling user left: ${error.message}`);
+      }
+    }
+  ],
+  ["ACTION_STARTED" /* ACTION_STARTED */]: [
+    async (payload) => {
+      logger.debug(`Action started: ${payload.actionName} (${payload.actionId})`);
+    }
+  ],
+  ["ACTION_COMPLETED" /* ACTION_COMPLETED */]: [
+    async (payload) => {
+      const status = payload.error ? `failed: ${payload.error.message}` : "completed";
+      logger.debug(`Action ${status}: ${payload.actionName} (${payload.actionId})`);
+    }
+  ],
+  ["EVALUATOR_STARTED" /* EVALUATOR_STARTED */]: [
+    async (payload) => {
+      logger.debug(`Evaluator started: ${payload.evaluatorName} (${payload.evaluatorId})`);
+    }
+  ],
+  ["EVALUATOR_COMPLETED" /* EVALUATOR_COMPLETED */]: [
+    async (payload) => {
+      const status = payload.error ? `failed: ${payload.error.message}` : "completed";
+      logger.debug(`Evaluator ${status}: ${payload.evaluatorName} (${payload.evaluatorId})`);
+    }
   ]
 };
 var bootstrapPlugin = {
   name: "bootstrap",
   description: "Agent bootstrap with basic actions and evaluators",
   actions: [
+    replyAction,
     followRoomAction,
     unfollowRoomAction,
     ignoreAction,
@@ -11210,17 +11263,15 @@ var bootstrapPlugin = {
     updateEntityAction,
     choiceAction,
     roles_default,
-    settings_default,
-    replyAction
+    settings_default
   ],
   events,
-  evaluators: [reflectionEvaluator, goalEvaluator],
+  evaluators: [reflectionEvaluator],
   providers: [
     evaluatorsProvider,
     anxietyProvider,
     knowledgeProvider,
     timeProvider,
-    characterProvider,
     entitiesProvider,
     relationshipsProvider,
     choiceProvider,
@@ -11231,6 +11282,7 @@ var bootstrapPlugin = {
     attachmentsProvider,
     providersProvider,
     actionsProvider,
+    characterProvider,
     recentMessagesProvider
   ],
   services: [TaskService, ScenarioService]
@@ -11278,24 +11330,21 @@ function stringToUuid(target) {
 
 // src/runtime.ts
 var AgentRuntime = class {
-  #conversationLength = 32;
-  agentId;
-  character;
-  databaseAdapter;
-  actions = [];
-  evaluators = [];
-  providers = [];
-  plugins = [];
-  events = /* @__PURE__ */ new Map();
-  stateCache = /* @__PURE__ */ new Map();
-  fetch = fetch;
-  services = /* @__PURE__ */ new Map();
-  adapters;
-  knowledgeRoot;
-  models = /* @__PURE__ */ new Map();
-  routes = [];
-  taskWorkers = /* @__PURE__ */ new Map();
   constructor(opts) {
+    this.#conversationLength = 32;
+    this.actions = [];
+    this.evaluators = [];
+    this.providers = [];
+    this.plugins = [];
+    this.events = /* @__PURE__ */ new Map();
+    this.stateCache = /* @__PURE__ */ new Map();
+    this.fetch = fetch;
+    this.services = /* @__PURE__ */ new Map();
+    this.models = /* @__PURE__ */ new Map();
+    this.routes = [];
+    this.taskWorkers = /* @__PURE__ */ new Map();
+    // Event emitter methods
+    this.eventHandlers = /* @__PURE__ */ new Map();
     this.agentId = opts.character?.id ?? opts?.agentId ?? stringToUuid(opts.character?.name ?? uuidv43());
     this.character = opts.character;
     logger.debug(`[AgentRuntime] Process working directory: ${process.cwd()}`);
@@ -11307,29 +11356,46 @@ var AgentRuntime = class {
     }
     logger.success(`Agent ID: ${this.agentId}`);
     this.fetch = opts.fetch ?? this.fetch;
-    this.adapters = opts.adapters ?? [];
+    this.adapter = opts.adapter;
     const plugins = opts?.plugins ?? [];
     if (!opts?.ignoreBootstrap) {
       plugins.push(bootstrapPlugin);
     }
     this.plugins = plugins;
   }
+  #conversationLength;
   /**
    * Registers a plugin with the runtime and initializes its components
    * @param plugin The plugin to register
    */
   async registerPlugin(plugin) {
     if (!plugin) {
-      return;
+      throw new Error("*** registerPlugin plugin is undefined");
     }
     if (!this.plugins.some((p) => p.name === plugin.name)) {
       this.plugins.push(plugin);
     }
-    if (plugin.adapters) {
-      for (const adapter of plugin.adapters) {
-        this.adapters.push(adapter);
+    if (plugin.init) {
+      try {
+        await plugin.init(plugin.config || {}, this);
+      } 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 .eliza/.env file.");
+        } else {
+          throw error;
+        }
       }
     }
+    if (plugin.adapter) {
+      this.registerDatabaseAdapter(plugin.adapter);
+    }
     if (plugin.actions) {
       for (const action of plugin.actions) {
         this.registerAction(action);
@@ -11346,10 +11412,10 @@ var AgentRuntime = class {
       }
     }
     if (plugin.models) {
-      for (const [modelType, handler3] of Object.entries(plugin.models)) {
+      for (const [modelType, handler2] of Object.entries(plugin.models)) {
         this.registerModel(
           modelType,
-          handler3
+          handler2
         );
       }
     }
@@ -11370,9 +11436,6 @@ var AgentRuntime = class {
         plugin.services.map((service) => this.registerService(service))
       );
     }
-    if (plugin.init) {
-      await plugin.init(plugin.config, this);
-    }
   }
   getAllServices() {
     return this.services;
@@ -11385,15 +11448,39 @@ var AgentRuntime = class {
     }
   }
   async initialize() {
+    const registeredPluginNames = /* @__PURE__ */ new Set();
+    const pluginRegistrationPromises = [];
+    if (this.character.plugins) {
+      const characterPlugins = await handlePluginImporting(
+        this.character.plugins
+      );
+      for (const plugin of characterPlugins) {
+        if (plugin && !registeredPluginNames.has(plugin.name)) {
+          registeredPluginNames.add(plugin.name);
+          pluginRegistrationPromises.push(this.registerPlugin(plugin));
+        }
+      }
+    }
+    for (const plugin of [...this.plugins]) {
+      if (plugin && !registeredPluginNames.has(plugin.name)) {
+        registeredPluginNames.add(plugin.name);
+        pluginRegistrationPromises.push(this.registerPlugin(plugin));
+      }
+    }
+    await this.adapter.init();
     try {
-      await this.getDatabaseAdapter().ensureAgentExists(
+      const agentExists = await this.adapter.ensureAgentExists(
         this.character
       );
-      const agentEntity = await this.getDatabaseAdapter().getEntityById(
+      const agent = await this.adapter.getAgent(this.agentId);
+      if (!agent) {
+        throw new Error(`Agent ${this.agentId} does not exist in database after ensureAgentExists call`);
+      }
+      const agentEntity = await this.adapter.getEntityById(
         this.agentId
       );
       if (!agentEntity) {
-        const created = await this.getDatabaseAdapter().createEntity({
+        const created = await this.adapter.createEntity({
           id: this.agentId,
           agentId: this.agentId,
           names: Array.from(
@@ -11414,25 +11501,6 @@ var AgentRuntime = class {
       );
       throw error;
     }
-    const registeredPluginNames = /* @__PURE__ */ new Set();
-    const pluginRegistrationPromises = [];
-    if (this.character.plugins) {
-      const characterPlugins = await handlePluginImporting(
-        this.character.plugins
-      );
-      for (const plugin of characterPlugins) {
-        if (plugin && !registeredPluginNames.has(plugin.name)) {
-          registeredPluginNames.add(plugin.name);
-          pluginRegistrationPromises.push(this.registerPlugin(plugin));
-        }
-      }
-    }
-    for (const plugin of [...this.plugins]) {
-      if (plugin && !registeredPluginNames.has(plugin.name)) {
-        registeredPluginNames.add(plugin.name);
-        pluginRegistrationPromises.push(this.registerPlugin(plugin));
-      }
-    }
     try {
       await Promise.all([
         this.ensureRoomExists({
@@ -11450,9 +11518,9 @@ var AgentRuntime = class {
       throw error;
     }
     try {
-      const participants = await this.getDatabaseAdapter().getParticipantsForRoom(this.agentId);
+      const participants = await this.adapter.getParticipantsForRoom(this.agentId);
       if (!participants.includes(this.agentId)) {
-        const added = await this.getDatabaseAdapter().addParticipant(
+        const added = await this.adapter.addParticipant(
           this.agentId,
           this.agentId
         );
@@ -11510,10 +11578,9 @@ var AgentRuntime = class {
       logger.warn("Empty text for knowledge query");
       return [];
     }
-    const embedding = await this.useModel(
-      ModelTypes.TEXT_EMBEDDING,
-      message?.content?.text
-    );
+    const embedding = await this.useModel(ModelTypes.TEXT_EMBEDDING, {
+      text: message?.content?.text
+    });
     const fragments = await this.getMemoryManager("knowledge").searchMemories({
       embedding,
       roomId: message.agentId,
@@ -11626,13 +11693,13 @@ var AgentRuntime = class {
     return this.#conversationLength;
   }
   registerDatabaseAdapter(adapter) {
-    this.adapters.push(adapter);
-  }
-  getDatabaseAdapters() {
-    return this.adapters;
-  }
-  getDatabaseAdapter() {
-    return this.adapters[0];
+    if (this.adapter) {
+      logger.warn(
+        "Database adapter already registered. Additional adapters will be ignored. This may lead to unexpected behavior."
+      );
+    } else {
+      this.adapter = adapter;
+    }
   }
   /**
    * Register a provider for the agent to use.
@@ -11649,7 +11716,13 @@ var AgentRuntime = class {
     logger.success(
       `${this.character.name}(${this.agentId}) - Registering action: ${action.name}`
     );
-    this.actions.push(action);
+    if (this.actions.find((a) => a.name === action.name)) {
+      logger.warn(
+        `${this.character.name}(${this.agentId}) - Action ${action.name} already exists. Skipping registration.`
+      );
+    } else {
+      this.actions.push(action);
+    }
   }
   /**
    * Register an evaluator to assess and guide the agent's responses.
@@ -11722,11 +11795,11 @@ var AgentRuntime = class {
           logger.error(`Action ${action.name} has no handler.`);
           continue;
         }
-        logger.success(`Executing handler for action: ${action.name}`);
         try {
           logger.info(`Executing handler for action: ${action.name}`);
           await action.handler(this, message, state, {}, callback, responses);
-          await this.getDatabaseAdapter().log({
+          logger.success(`Action ${action.name} executed successfully.`);
+          this.adapter.log({
             entityId: message.entityId,
             roomId: message.roomId,
             type: "action",
@@ -11787,7 +11860,7 @@ var AgentRuntime = class {
             callback,
             responses
           );
-          await this.getDatabaseAdapter().log({
+          this.adapter.log({
             entityId: message.entityId,
             roomId: message.roomId,
             type: "evaluator",
@@ -11804,13 +11877,13 @@ var AgentRuntime = class {
     return evaluators;
   }
   async ensureParticipantInRoom(entityId, roomId) {
-    const entity = await this.getDatabaseAdapter().getEntityById(entityId);
+    const entity = await this.adapter.getEntityById(entityId);
     if (!entity) {
       throw new Error(`User ${entityId} not found`);
     }
-    const participants = await this.getDatabaseAdapter().getParticipantsForRoom(roomId);
+    const participants = await this.adapter.getParticipantsForRoom(roomId);
     if (!participants.includes(entityId)) {
-      const added = await this.getDatabaseAdapter().addParticipant(
+      const added = await this.adapter.addParticipant(
         entityId,
         roomId
       );
@@ -11832,7 +11905,7 @@ var AgentRuntime = class {
     entityId,
     roomId,
     userName,
-    name: name2,
+    name,
     source,
     type,
     channelId,
@@ -11845,16 +11918,16 @@ var AgentRuntime = class {
     if (!worldId && serverId) {
       worldId = createUniqueUuid(this, serverId);
     }
-    const names4 = [name2, userName];
+    const names4 = [name, userName];
     const metadata = {
       [source]: {
-        name: name2,
+        name,
         userName
       }
     };
-    const entity = await this.getDatabaseAdapter().getEntityById(entityId);
+    const entity = await this.adapter.getEntityById(entityId);
     if (!entity) {
-      await this.getDatabaseAdapter().createEntity({
+      await this.adapter.createEntity({
         id: entityId,
         names: names4,
         metadata,
@@ -11891,19 +11964,19 @@ var AgentRuntime = class {
   /**
    * Ensure the existence of a world.
    */
-  async ensureWorldExists({ id, name: name2, serverId, metadata }) {
+  async ensureWorldExists({ id, name, serverId, metadata }) {
     try {
-      const world = await this.getDatabaseAdapter().getWorld(id);
+      const world = await this.adapter.getWorld(id);
       if (!world) {
         logger.info("Creating world:", {
           id,
-          name: name2,
+          name,
           serverId,
           agentId: this.agentId
         });
-        await this.getDatabaseAdapter().createWorld({
+        await this.adapter.createWorld({
           id,
-          name: name2,
+          name,
           agentId: this.agentId,
           serverId: serverId || "default",
           metadata
@@ -11926,18 +11999,18 @@ var AgentRuntime = class {
    */
   async ensureRoomExists({
     id,
-    name: name2,
+    name,
     source,
     type,
     channelId,
     serverId,
     worldId
   }) {
-    const room = await this.getDatabaseAdapter().getRoom(id);
+    const room = await this.adapter.getRoom(id);
     if (!room) {
-      await this.getDatabaseAdapter().createRoom({
+      await this.adapter.createRoom({
         id,
-        name: name2,
+        name,
         agentId: this.agentId,
         source,
         type,
@@ -11964,14 +12037,14 @@ var AgentRuntime = class {
     const existingProviderNames = cachedState.data.providers ? Object.keys(cachedState.data.providers) : [];
     const providerNames = /* @__PURE__ */ new Set();
     if (filterList && filterList.length > 0) {
-      filterList.forEach((name2) => providerNames.add(name2));
+      filterList.forEach((name) => providerNames.add(name));
     } else {
       this.providers.filter(
         (p) => !p.private && !p.dynamic && !existingProviderNames.includes(p.name)
       ).forEach((p) => providerNames.add(p.name));
     }
     if (includeList && includeList.length > 0) {
-      includeList.forEach((name2) => providerNames.add(name2));
+      includeList.forEach((name) => providerNames.add(name));
     }
     const providersToGet = Array.from(
       new Set(this.providers.filter((p) => providerNames.has(p.name)))
@@ -12035,7 +12108,7 @@ ${newProvidersText}`;
   getService(service) {
     const serviceInstance = this.services.get(service);
     if (!serviceInstance) {
-      logger.error(`Service ${service} not found`);
+      logger.warn(`Service ${service} not found`);
       return null;
     }
     return serviceInstance;
@@ -12061,12 +12134,12 @@ ${newProvidersText}`;
       `${this.character.name}(${this.agentId}) - Service ${serviceType} registered successfully`
     );
   }
-  registerModel(modelType, handler3) {
+  registerModel(modelType, handler2) {
     const modelKey = typeof modelType === "string" ? modelType : ModelTypes[modelType];
     if (!this.models.has(modelKey)) {
       this.models.set(modelKey, []);
     }
-    this.models.get(modelKey)?.push(handler3);
+    this.models.get(modelKey)?.push(handler2);
   }
   getModel(modelType) {
     const modelKey = typeof modelType === "string" ? modelType : ModelTypes[modelType];
@@ -12076,43 +12149,71 @@ ${newProvidersText}`;
     }
     return models[0];
   }
+  /**
+   * Use a model with strongly typed parameters and return values based on model type
+   * @template T - The model type to use
+   * @template R - The expected return type, defaults to the type defined in ModelResultMap[T]
+   * @param {T} modelType - The type of model to use
+   * @param {ModelParamsMap[T] | any} params - The parameters for the model, typed based on model type
+   * @returns {Promise<R>} - The model result, typed based on the provided generic type parameter
+   */
   async useModel(modelType, params) {
     const modelKey = typeof modelType === "string" ? modelType : ModelTypes[modelType];
     const model = this.getModel(modelKey);
     if (!model) {
       throw new Error(`No handler found for delegate type: ${modelKey}`);
     }
-    const response = await model(this, params);
-    await this.getDatabaseAdapter().log({
+    logger.debug(
+      `[useModel] ${modelKey} input:`,
+      JSON.stringify(params, null, 2)
+    );
+    let paramsWithRuntime;
+    if (params === null || params === void 0 || typeof params !== "object" || Array.isArray(params)) {
+      paramsWithRuntime = params;
+    } else {
+      paramsWithRuntime = {
+        ...params,
+        runtime: this
+      };
+    }
+    const startTime = performance.now();
+    const response = await model(this, paramsWithRuntime);
+    const elapsedTime = performance.now() - startTime;
+    logger.info(
+      `[useModel] ${modelKey} completed in ${elapsedTime.toFixed(2)}ms`
+    );
+    logger.debug(
+      `[useModel] ${modelKey} output:`,
+      JSON.stringify(response, null, 2)
+    );
+    this.adapter.log({
       entityId: this.agentId,
       roomId: this.agentId,
       body: {
         modelType,
         modelKey,
-        params: params ? Object.keys(params) : [],
+        params: params ? typeof params === "object" ? Object.keys(params) : typeof params : null,
         response: Array.isArray(response) && response.every((x) => typeof x === "number") ? "[array]" : response
       },
-      type: `useModel:${modelType}`
+      type: `useModel:${modelKey}`
     });
     return response;
   }
-  registerEvent(event, handler3) {
+  registerEvent(event, handler2) {
     if (!this.events.has(event)) {
       this.events.set(event, []);
     }
-    this.events.get(event)?.push(handler3);
+    this.events.get(event)?.push(handler2);
   }
   getEvent(event) {
     return this.events.get(event);
   }
-  emitEvent(event, params) {
+  async emitEvent(event, params) {
     const events2 = Array.isArray(event) ? event : [event];
     for (const eventName of events2) {
       const eventHandlers = this.events.get(eventName);
       if (eventHandlers) {
-        for (const handler3 of eventHandlers) {
-          handler3(params);
-        }
+        await Promise.all(eventHandlers.map((handler2) => handler2(params)));
       }
     }
   }
@@ -12120,7 +12221,7 @@ ${newProvidersText}`;
     logger.debug(
       `[AgentRuntime][${this.character.name}] Starting ensureEmbeddingDimension`
     );
-    if (!this.getDatabaseAdapter()) {
+    if (!this.adapter) {
       throw new Error(
         `[AgentRuntime][${this.character.name}] Database adapter not initialized before ensureEmbeddingDimension`
       );
@@ -12144,7 +12245,7 @@ ${newProvidersText}`;
       logger.debug(
         `[AgentRuntime][${this.character.name}] Setting embedding dimension: ${embedding.length}`
       );
-      await this.getDatabaseAdapter().ensureEmbeddingDimension(
+      await this.adapter.ensureEmbeddingDimension(
         embedding.length
       );
       logger.debug(
@@ -12166,8 +12267,230 @@ ${newProvidersText}`;
     }
     this.taskWorkers.set(taskHandler.name, taskHandler);
   }
-  getTaskWorker(name2) {
-    return this.taskWorkers.get(name2);
+  /**
+   * Get a task worker by name
+   */
+  getTaskWorker(name) {
+    return this.taskWorkers.get(name);
+  }
+  // Implement database adapter methods
+  get db() {
+    return this.adapter.db;
+  }
+  async init() {
+    await this.adapter.init();
+  }
+  async close() {
+    await this.adapter.close();
+  }
+  async getAgent(agentId) {
+    return await this.adapter.getAgent(agentId);
+  }
+  async getAgents() {
+    return await this.adapter.getAgents();
+  }
+  async createAgent(agent) {
+    return await this.adapter.createAgent(agent);
+  }
+  async updateAgent(agentId, agent) {
+    return await this.adapter.updateAgent(agentId, agent);
+  }
+  async deleteAgent(agentId) {
+    return await this.adapter.deleteAgent(agentId);
+  }
+  async ensureAgentExists(agent) {
+    await this.adapter.ensureAgentExists(agent);
+  }
+  async getEntityById(entityId) {
+    return await this.adapter.getEntityById(entityId);
+  }
+  async getEntitiesForRoom(roomId, includeComponents) {
+    return await this.adapter.getEntitiesForRoom(roomId, includeComponents);
+  }
+  async createEntity(entity) {
+    return await this.adapter.createEntity(entity);
+  }
+  async updateEntity(entity) {
+    await this.adapter.updateEntity(entity);
+  }
+  async getComponent(entityId, type, worldId, sourceEntityId) {
+    return await this.adapter.getComponent(entityId, type, worldId, sourceEntityId);
+  }
+  async getComponents(entityId, worldId, sourceEntityId) {
+    return await this.adapter.getComponents(entityId, worldId, sourceEntityId);
+  }
+  async createComponent(component) {
+    return await this.adapter.createComponent(component);
+  }
+  async updateComponent(component) {
+    await this.adapter.updateComponent(component);
+  }
+  async deleteComponent(componentId) {
+    await this.adapter.deleteComponent(componentId);
+  }
+  async getMemories(params) {
+    return await this.adapter.getMemories(params);
+  }
+  async getMemoryById(id) {
+    return await this.adapter.getMemoryById(id);
+  }
+  async getMemoriesByIds(ids, tableName) {
+    return await this.adapter.getMemoriesByIds(ids, tableName);
+  }
+  async getMemoriesByRoomIds(params) {
+    return await this.adapter.getMemoriesByRoomIds(params);
+  }
+  async getCachedEmbeddings(params) {
+    return await this.adapter.getCachedEmbeddings(params);
+  }
+  async log(params) {
+    await this.adapter.log(params);
+  }
+  async searchMemories(params) {
+    return await this.adapter.searchMemories(params);
+  }
+  async createMemory(memory, tableName, unique) {
+    return await this.adapter.createMemory(memory, tableName, unique);
+  }
+  async removeMemory(memoryId, tableName) {
+    await this.adapter.removeMemory(memoryId, tableName);
+  }
+  async removeAllMemories(roomId, tableName) {
+    await this.adapter.removeAllMemories(roomId, tableName);
+  }
+  async countMemories(roomId, unique, tableName) {
+    return await this.adapter.countMemories(roomId, unique, tableName);
+  }
+  async createWorld(world) {
+    return await this.adapter.createWorld(world);
+  }
+  async getWorld(id) {
+    return await this.adapter.getWorld(id);
+  }
+  async getAllWorlds() {
+    return await this.adapter.getAllWorlds();
+  }
+  async updateWorld(world) {
+    await this.adapter.updateWorld(world);
+  }
+  async getRoom(roomId) {
+    return await this.adapter.getRoom(roomId);
+  }
+  async createRoom({
+    id,
+    name,
+    source,
+    type,
+    channelId,
+    serverId,
+    worldId
+  }) {
+    return await this.adapter.createRoom({
+      id,
+      name,
+      source,
+      type,
+      channelId,
+      serverId,
+      worldId
+    });
+  }
+  async deleteRoom(roomId) {
+    await this.adapter.deleteRoom(roomId);
+  }
+  async updateRoom(room) {
+    await this.adapter.updateRoom(room);
+  }
+  async getRoomsForParticipant(entityId) {
+    return await this.adapter.getRoomsForParticipant(entityId);
+  }
+  async getRoomsForParticipants(userIds) {
+    return await this.adapter.getRoomsForParticipants(userIds);
+  }
+  async getRooms(worldId) {
+    return await this.adapter.getRooms(worldId);
+  }
+  async addParticipant(entityId, roomId) {
+    return await this.adapter.addParticipant(entityId, roomId);
+  }
+  async removeParticipant(entityId, roomId) {
+    return await this.adapter.removeParticipant(entityId, roomId);
+  }
+  async getParticipantsForEntity(entityId) {
+    return await this.adapter.getParticipantsForEntity(entityId);
+  }
+  async getParticipantsForRoom(roomId) {
+    return await this.adapter.getParticipantsForRoom(roomId);
+  }
+  async getParticipantUserState(roomId, entityId) {
+    return await this.adapter.getParticipantUserState(roomId, entityId);
+  }
+  async setParticipantUserState(roomId, entityId, state) {
+    await this.adapter.setParticipantUserState(roomId, entityId, state);
+  }
+  async createRelationship(params) {
+    return await this.adapter.createRelationship(params);
+  }
+  async updateRelationship(relationship) {
+    await this.adapter.updateRelationship(relationship);
+  }
+  async getRelationship(params) {
+    return await this.adapter.getRelationship(params);
+  }
+  async getRelationships(params) {
+    return await this.adapter.getRelationships(params);
+  }
+  async getCache(key) {
+    return await this.adapter.getCache(key);
+  }
+  async setCache(key, value) {
+    return await this.adapter.setCache(key, value);
+  }
+  async deleteCache(key) {
+    return await this.adapter.deleteCache(key);
+  }
+  async createTask(task) {
+    return await this.adapter.createTask(task);
+  }
+  async getTasks(params) {
+    return await this.adapter.getTasks(params);
+  }
+  async getTask(id) {
+    return await this.adapter.getTask(id);
+  }
+  async getTasksByName(name) {
+    return await this.adapter.getTasksByName(name);
+  }
+  async updateTask(id, task) {
+    await this.adapter.updateTask(id, task);
+  }
+  async deleteTask(id) {
+    await this.adapter.deleteTask(id);
+  }
+  // Event emitter methods
+  on(event, callback) {
+    if (!this.eventHandlers.has(event)) {
+      this.eventHandlers.set(event, []);
+    }
+    this.eventHandlers.get(event).push(callback);
+  }
+  off(event, callback) {
+    if (!this.eventHandlers.has(event)) {
+      return;
+    }
+    const handlers = this.eventHandlers.get(event);
+    const index = handlers.indexOf(callback);
+    if (index !== -1) {
+      handlers.splice(index, 1);
+    }
+  }
+  emit(event, data) {
+    if (!this.eventHandlers.has(event)) {
+      return;
+    }
+    for (const handler2 of this.eventHandlers.get(event)) {
+      handler2(data);
+    }
   }
 };
 export {
@@ -12176,12 +12499,13 @@ export {
   ChannelType,
   CharacterSchema,
   DatabaseAdapter,
-  GoalStatus,
+  EventTypes,
   KnowledgeScope,
   MemoryManager,
   MemoryType,
   MessageExampleSchema,
   ModelTypes,
+  PlatformPrefix,
   PluginSchema,
   Role,
   Service,
@@ -12194,6 +12518,7 @@ export {
   cleanJsonResponse,
   composeActionExamples,
   composePrompt,
+  composePromptFromState,
   composeRandomUser,
   configureSettings,
   createUniqueUuid,