@elizaos/plugin-bootstrap 1.0.0-beta.8 → 1.0.0

package/dist/index.js

@@ -72,17 +72,19 @@ var require_dedent = __commonJS({
 // src/index.ts
 import {
   asUUID,
-  ChannelType as ChannelType9,
+  ChannelType as ChannelType10,
   composePromptFromState as composePromptFromState9,
   createUniqueUuid as createUniqueUuid4,
   EventType as EventType2,
-  logger as logger16,
+  logger as logger19,
   messageHandlerTemplate,
   ModelType as ModelType13,
-  parseJSONObjectFromText as parseJSONObjectFromText4,
   postCreationTemplate,
   shouldRespondTemplate,
-  truncateToCompleteSentence
+  truncateToCompleteSentence,
+  parseKeyValueXml,
+  imageDescriptionTemplate,
+  ContentType
 } from "@elizaos/core";
 
 // ../../node_modules/uuid/dist/esm/stringify.js
@@ -174,6 +176,10 @@ 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) => {
+    if (!state) {
+      logger.error("State is required for validating the action");
+      throw new Error("State is required for validating the action");
+    }
     const pendingTasks = await runtime.getTasks({
       roomId: message.roomId,
       tags: ["AWAITING_CHOICE"]
@@ -186,121 +192,120 @@ var choiceAction = {
     return pendingTasks && pendingTasks.length > 0 && pendingTasks.some((task) => task.metadata?.options);
   },
   handler: async (runtime, message, state, _options, callback, responses) => {
-    try {
-      const pendingTasks = await runtime.getTasks({
-        roomId: message.roomId,
-        tags: ["AWAITING_CHOICE"]
-      });
-      if (!pendingTasks?.length) {
-        throw new Error("No pending tasks with options found");
+    const pendingTasks = await runtime.getTasks({
+      roomId: message.roomId,
+      tags: ["AWAITING_CHOICE"]
+    });
+    if (!pendingTasks?.length) {
+      throw new Error("No pending tasks with options found");
+    }
+    const tasksWithOptions = pendingTasks.filter((task) => task.metadata?.options);
+    if (!tasksWithOptions.length) {
+      throw new Error("No tasks currently have options to select from.");
+    }
+    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: {
+        tasks: tasksString,
+        recentMessages: message.content.text || ""
+      },
+      template: optionExtractionTemplate
+    });
+    const result = await runtime.useModel(ModelType.TEXT_SMALL, {
+      prompt,
+      stopSequences: []
+    });
+    const parsed = parseJSONObjectFromText(result);
+    const { taskId, selectedOption } = parsed;
+    if (taskId && selectedOption) {
+      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 tasksWithOptions = pendingTasks.filter((task) => task.metadata?.options);
-      if (!tasksWithOptions.length) {
-        throw new Error("No tasks currently have options to select from.");
+      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;
       }
-      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: {
-          tasks: tasksString,
-          recentMessages: message.content.text
-        },
-        template: optionExtractionTemplate
-      });
-      const result = await runtime.useModel(ModelType.TEXT_SMALL, {
-        prompt,
-        stopSequences: []
-      });
-      const parsed = parseJSONObjectFromText(result);
-      const { taskId, selectedOption } = parsed;
-      if (taskId && selectedOption) {
-        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({
+      if (selectedOption === "ABORT") {
+        if (!selectedTask?.id) {
+          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.deleteTask(selectedTask.id);
-          await callback({
-            text: `Task "${selectedTask.name}" has been cancelled.`,
-            actions: ["CHOOSE_OPTION_CANCELLED"],
-            source: message.content.source
-          });
-          return;
-        }
-        try {
-          const taskWorker = runtime.getTaskWorker(selectedTask.name);
-          await taskWorker.execute(runtime, { option: selectedOption }, selectedTask);
-          await callback({
-            text: `Selected option: ${selectedOption} for task: ${selectedTask.name}`,
-            actions: ["CHOOSE_OPTION"],
-            source: message.content.source
-          });
-          return;
-        } catch (error) {
-          logger.error("Error executing task with option:", error);
-          await callback({
-            text: "There was an error processing your selection.",
-            actions: ["SELECT_OPTION_ERROR"],
-            source: message.content.source
-          });
-          return;
-        }
+        await runtime.deleteTask(selectedTask.id);
+        await callback?.({
+          text: `Task "${selectedTask.name}" has been cancelled.`,
+          actions: ["CHOOSE_OPTION_CANCELLED"],
+          source: message.content.source
+        });
+        return;
+      }
+      try {
+        const taskWorker = runtime.getTaskWorker(selectedTask.name);
+        await taskWorker?.execute(runtime, { option: selectedOption }, selectedTask);
+        await callback?.({
+          text: `Selected option: ${selectedOption} for task: ${selectedTask.name}`,
+          actions: ["CHOOSE_OPTION"],
+          source: message.content.source
+        });
+        return;
+      } catch (error) {
+        logger.error("Error executing task with option:", error);
+        await callback?.({
+          text: "There was an error processing your selection.",
+          actions: ["SELECT_OPTION_ERROR"],
+          source: message.content.source
+        });
+        return;
       }
-      let optionsText = "Please select a valid option from one of these tasks:\n\n";
-      tasksWithOptions.forEach((task) => {
-        const shortId = task.id.substring(0, 8);
-        optionsText += `**${task.name}** (ID: ${shortId}):
-`;
-        const options = task.metadata.options.map(
-          (opt) => typeof opt === "string" ? opt : opt.name
-        );
-        options.push("ABORT");
-        optionsText += options.map((opt) => `- ${opt}`).join("\n");
-        optionsText += "\n\n";
-      });
-      await callback({
-        text: optionsText,
-        actions: ["SELECT_OPTION_INVALID"],
-        source: message.content.source
-      });
-    } catch (error) {
-      logger.error("Error in select option handler:", error);
-      await callback({
-        text: "There was an error processing the option selection.",
-        actions: ["SELECT_OPTION_ERROR"],
-        source: message.content.source
-      });
     }
+    let optionsText = "Please select a valid option from one of these tasks:\n\n";
+    tasksWithOptions.forEach((task) => {
+      const shortId = task.id?.substring(0, 8);
+      optionsText += `**${task.name}** (ID: ${shortId}):
+`;
+      const options = task.metadata?.options?.map(
+        (opt) => typeof opt === "string" ? opt : opt.name
+      );
+      options?.push("ABORT");
+      optionsText += options?.map((opt) => `- ${opt}`).join("\n");
+      optionsText += "\n\n";
+    });
+    await callback?.({
+      text: optionsText,
+      actions: ["SELECT_OPTION_INVALID"],
+      source: message.content.source
+    });
   },
   examples: [
     [
@@ -369,6 +374,10 @@ var followRoomAction = {
     return roomState !== "FOLLOWED" && roomState !== "MUTED";
   },
   handler: async (runtime, message, state, _options, _callback, _responses) => {
+    if (!state) {
+      logger2.error("State is required for followRoomAction");
+      throw new Error("State is required for followRoomAction");
+    }
     async function _shouldFollow(state2) {
       const shouldFollowPrompt = composePromptFromState({
         state: state2,
@@ -722,7 +731,10 @@ var ignoreAction = {
     return true;
   },
   description: "Call this action if ignoring the user. If the user is aggressive, creepy or is finished with the conversation, use this action. Or, if both you and the user have already said goodbye, use this action instead of saying bye again. Use IGNORE any time the conversation has naturally ended. Do not use IGNORE if the user has engaged directly, or if something went wrong an you need to tell them. Only ignore if the user should be ignored.",
-  handler: async (_runtime, _message) => {
+  handler: async (_runtime, _message, _state, _options, callback, responses) => {
+    if (callback && responses?.[0]?.content) {
+      await callback(responses[0].content);
+    }
     return true;
   },
   examples: [
@@ -962,6 +974,10 @@ var muteRoomAction = {
     return roomState !== "MUTED";
   },
   handler: async (runtime, message, state, _options, _callback, _responses) => {
+    if (!state) {
+      logger3.error("State is required for muting a room");
+      throw new Error("State is required for muting a room");
+    }
     async function _shouldMute(state2) {
       const shouldMutePrompt = composePromptFromState2({
         state: state2,
@@ -1278,15 +1294,12 @@ import {
   composePromptFromState as composePromptFromState3,
   ModelType as ModelType4
 } from "@elizaos/core";
-var replyTemplate = `# Task: Generate dialog and actions for the character {{agentName}}.
+var replyTemplate = `# Task: Generate dialog for the character {{agentName}}.
 {{providers}}
 # Instructions: Write the next message for {{agentName}}.
-First, think about what you want to do next and plan your actions. Then, write the next message and include the actions you plan to take.
 "thought" should be a short description of what the agent is thinking about and planning.
 "message" should be the next message for {{agentName}} which they will send to the conversation.
 
-These are the available valid actions: {{actionNames}}
-
 Response format should be formatted in a valid JSON block like this:
 \`\`\`json
 {
@@ -1296,6 +1309,25 @@ Response format should be formatted in a valid JSON block like this:
 \`\`\`
 
 Your response should include the valid JSON block and nothing else.`;
+function getFirstAvailableField(obj, fields) {
+  for (const field of fields) {
+    if (typeof obj[field] === "string" && obj[field].trim() !== "") {
+      return obj[field];
+    }
+  }
+  return null;
+}
+function extractReplyContent(response, replyFieldKeys) {
+  const hasReplyAction = response.content.actions?.includes("REPLY");
+  const text = getFirstAvailableField(response.content, replyFieldKeys);
+  if (!hasReplyAction || !text) return null;
+  return {
+    ...response.content,
+    thought: response.content.thought,
+    text,
+    actions: ["REPLY"]
+  };
+}
 var replyAction = {
   name: "REPLY",
   similes: ["GREET", "REPLY_TO_MESSAGE", "SEND_REPLY", "RESPOND", "RESPONSE"],
@@ -1303,11 +1335,17 @@ var replyAction = {
   validate: async (_runtime) => {
     return true;
   },
-  handler: async (runtime, message, state, _options, callback) => {
-    state = await runtime.composeState(message, [
-      ...message.content.providers ?? [],
-      "RECENT_MESSAGES"
-    ]);
+  handler: async (runtime, message, state, _options, callback, responses) => {
+    const replyFieldKeys = ["message", "text"];
+    const existingReplies = responses?.map((r) => extractReplyContent(r, replyFieldKeys)).filter((reply) => reply !== null) ?? [];
+    const allProviders = responses?.flatMap((res) => res.content?.providers ?? []) ?? [];
+    if (existingReplies.length > 0 && allProviders.length === 0) {
+      for (const reply of existingReplies) {
+        await callback(reply);
+      }
+      return;
+    }
+    state = await runtime.composeState(message, [...allProviders ?? [], "RECENT_MESSAGES"]);
     const prompt = composePromptFromState3({
       state,
       template: replyTemplate
@@ -1424,17 +1462,20 @@ var updateRoleAction = {
     );
   },
   handler: async (runtime, message, state, _options, callback) => {
+    if (!state) {
+      logger4.error("State is required for role assignment");
+      throw new Error("State is required for role assignment");
+    }
     const { roomId } = message;
-    const channelType = message.content.channelType;
     const serverId = message.content.serverId;
     const worldId = runtime.getSetting("WORLD_ID");
-    let world;
+    let world = null;
     if (worldId) {
       world = await runtime.getWorld(worldId);
     }
     if (!world) {
       logger4.error("World not found");
-      await callback({
+      await callback?.({
         text: "I couldn't find the world. This action only works in a world."
       });
       return;
@@ -1504,7 +1545,7 @@ var updateRoleAction = {
       }
     );
     if (!result?.length) {
-      await callback({
+      await callback?.({
         text: "No valid role assignments found in the request.",
         actions: ["UPDATE_ROLE"],
         source: "discord"
@@ -1519,8 +1560,8 @@ var updateRoleAction = {
       }
       const currentRole = world.metadata.roles[assignment.entityId];
       if (!canModifyRole(requesterRole, currentRole, assignment.newRole)) {
-        await callback({
-          text: `You don't have permission to change ${targetEntity.names[0]}'s role to ${assignment.newRole}.`,
+        await callback?.({
+          text: `You don't have permission to change ${targetEntity?.names[0]}'s role to ${assignment.newRole}.`,
           actions: ["UPDATE_ROLE"],
           source: "discord"
         });
@@ -1528,8 +1569,8 @@ var updateRoleAction = {
       }
       world.metadata.roles[assignment.entityId] = assignment.newRole;
       worldUpdated = true;
-      await callback({
-        text: `Updated ${targetEntity.names[0]}'s role to ${assignment.newRole}.`,
+      await callback?.({
+        text: `Updated ${targetEntity?.names[0]}'s role to ${assignment.newRole}.`,
         actions: ["UPDATE_ROLE"],
         source: "discord"
       });
@@ -1590,7 +1631,6 @@ var updateRoleAction = {
     ]
   ]
 };
-var roles_default = updateRoleAction;
 
 // src/actions/sendMessage.ts
 import {
@@ -1659,6 +1699,18 @@ var sendMessageAction = {
   },
   handler: async (runtime, message, state, _options, callback, responses) => {
     try {
+      if (!state) {
+        logger5.error("State is required for sendMessage action");
+        throw new Error("State is required for sendMessage action");
+      }
+      if (!callback) {
+        logger5.error("Callback is required for sendMessage action");
+        throw new Error("Callback is required for sendMessage action");
+      }
+      if (!responses) {
+        logger5.error("Responses are required for sendMessage action");
+        throw new Error("Responses are required for sendMessage action");
+      }
       for (const response of responses) {
         await callback(response.content);
       }
@@ -1734,7 +1786,7 @@ var sendMessageAction = {
       } else if (targetData.targetType === "room") {
         const rooms = await runtime.getRooms(worldId);
         const targetRoom = rooms.find((r) => {
-          return r.name.toLowerCase() === targetData.identifiers.roomName?.toLowerCase();
+          return r.name?.toLowerCase() === targetData.identifiers.roomName?.toLowerCase();
         });
         if (!targetRoom) {
           await callback({
@@ -1771,7 +1823,7 @@ var sendMessageAction = {
       }
     } catch (error) {
       logger5.error(`Error in sendMessage handler: ${error}`);
-      await callback({
+      await callback?.({
         text: "There was an error processing your message request.",
         actions: ["SEND_MESSAGE_ERROR"],
         source: message.content.source
@@ -2007,7 +2059,7 @@ async function extractSettingValues(runtime, _message, state, worldSettings) {
     If a setting is mentioned but no clear value is provided, do not include it.
     `;
   try {
-    let extractValidSettings = function(obj, worldSettings2) {
+    let extractValidSettings2 = function(obj, worldSettings2) {
       const extracted = [];
       function traverse(node) {
         if (Array.isArray(node)) {
@@ -2027,6 +2079,7 @@ async function extractSettingValues(runtime, _message, state, worldSettings) {
       traverse(obj);
       return extracted;
     };
+    var extractValidSettings = extractValidSettings2;
     const result = await runtime.useModel(
       ModelType7.OBJECT_LARGE,
       {
@@ -2048,7 +2101,7 @@ async function extractSettingValues(runtime, _message, state, worldSettings) {
     if (!result) {
       return [];
     }
-    const extractedSettings = extractValidSettings(result, worldSettings);
+    const extractedSettings = extractValidSettings2(result, worldSettings);
     return extractedSettings;
   } catch (error) {
     console.error("Error extracting settings:", error);
@@ -2237,10 +2290,10 @@ var updateSettingsAction = {
       if (!worlds) {
         return false;
       }
-      const world = worlds.find((world2) => world2.metadata.settings);
-      const worldSettings = world.metadata.settings;
+      const world = worlds.find((world2) => world2.metadata?.settings);
+      const worldSettings = world?.metadata?.settings;
       if (!worldSettings) {
-        logger6.error(`No settings state found for server ${world.serverId}`);
+        logger6.error(`No settings state found for server ${world?.serverId}`);
         return false;
       }
       logger6.debug(`Found valid settings state for server ${world.serverId}`);
@@ -2252,16 +2305,32 @@ var updateSettingsAction = {
   },
   handler: async (runtime, message, state, _options, callback) => {
     try {
+      if (!state) {
+        logger6.error("State is required for settings handler");
+        throw new Error("State is required for settings handler");
+      }
+      if (!message) {
+        logger6.error("Message is required for settings handler");
+        throw new Error("Message is required for settings handler");
+      }
+      if (!callback) {
+        logger6.error("Callback is required for settings handler");
+        throw new Error("Callback is required for settings handler");
+      }
       logger6.info(`Handler looking for server for user ${message.entityId}`);
       const worlds = await findWorldsForOwner(runtime, message.entityId);
-      const serverOwnership = worlds.find((world) => world.metadata.settings);
+      const serverOwnership = worlds?.find((world) => world.metadata?.settings);
       if (!serverOwnership) {
         logger6.error(`No server found for user ${message.entityId} in handler`);
         await generateErrorResponse(runtime, state, callback);
         return;
       }
-      const serverId = serverOwnership.serverId;
+      const serverId = serverOwnership?.serverId;
       logger6.info(`Using server ID: ${serverId}`);
+      if (!serverId) {
+        logger6.error(`No server ID found for user ${message.entityId} in handler`);
+        return;
+      }
       const worldSettings = await getWorldSettings(runtime, serverId);
       if (!worldSettings) {
         logger6.error(`No settings state found for server ${serverId} in handler`);
@@ -2298,7 +2367,9 @@ var updateSettingsAction = {
       }
     } catch (error) {
       logger6.error(`Error in settings handler: ${error}`);
-      await generateErrorResponse(runtime, state, callback);
+      if (state && callback) {
+        await generateErrorResponse(runtime, state, callback);
+      }
     }
   },
   examples: [
@@ -2474,7 +2545,6 @@ var updateSettingsAction = {
     ]
   ]
 };
-var settings_default = updateSettingsAction;
 
 // src/actions/unfollowRoom.ts
 import {
@@ -2517,7 +2587,7 @@ var unfollowRoomAction = {
       const parsedResponse = parseBooleanFromText(response.trim());
       return parsedResponse;
     }
-    if (await _shouldUnfollow(state)) {
+    if (state && await _shouldUnfollow(state)) {
       await runtime.setParticipantUserState(message.roomId, runtime.agentId, null);
       const room = state.data.room ?? await runtime.getRoom(message.roomId);
       await runtime.createMemory(
@@ -2880,10 +2950,14 @@ var unmuteRoomAction = {
       logger7.warn(`Unclear boolean response: ${response}, defaulting to false`);
       return false;
     }
-    if (await _shouldUnmute(state)) {
+    if (state && await _shouldUnmute(state)) {
       await runtime.setParticipantUserState(message.roomId, runtime.agentId, null);
     }
     const room = await runtime.getRoom(message.roomId);
+    if (!room) {
+      logger7.warn(`Room not found: ${message.roomId}`);
+      return false;
+    }
     await runtime.createMemory(
       {
         entityId: message.entityId,
@@ -3059,6 +3133,22 @@ var updateEntityAction = {
   },
   handler: async (runtime, message, state, _options, callback, responses) => {
     try {
+      if (!state) {
+        logger8.error("State is required for the updateEntity action");
+        throw new Error("State is required for the updateEntity action");
+      }
+      if (!callback) {
+        logger8.error("State is required for the updateEntity action");
+        throw new Error("Callback is required for the updateEntity action");
+      }
+      if (!responses) {
+        logger8.error("Responses are required for the updateEntity action");
+        throw new Error("Responses are required for the updateEntity action");
+      }
+      if (!message) {
+        logger8.error("Message is required for the updateEntity action");
+        throw new Error("Message is required for the updateEntity action");
+      }
       for (const response of responses) {
         await callback(response.content);
       }
@@ -3121,7 +3211,8 @@ var updateEntityAction = {
           data: componentData,
           agentId,
           roomId: message.roomId,
-          sourceEntityId
+          sourceEntityId,
+          createdAt: existingComponent.createdAt
         });
         await callback({
           text: `I've updated the ${componentType} information for ${entity.names[0]}.`,
@@ -3137,7 +3228,8 @@ var updateEntityAction = {
           data: componentData,
           agentId,
           roomId: message.roomId,
-          sourceEntityId
+          sourceEntityId,
+          createdAt: Date.now()
         });
         await callback({
           text: `I've added new ${componentType} information for ${entity.names[0]}.`,
@@ -3147,7 +3239,7 @@ var updateEntityAction = {
       }
     } catch (error) {
       logger8.error(`Error in updateEntity handler: ${error}`);
-      await callback({
+      await callback?.({
         text: "There was an error processing the entity information.",
         actions: ["UPDATE_ENTITY_ERROR"],
         source: message.content.source
@@ -3254,7 +3346,7 @@ Message Sender: {{senderName}} (ID: {{senderId}})
 {{knownFacts}}
 
 # Instructions:
-1. Generate a self-reflective thought on the conversation. How are you doing? You're not being annoying, are you?
+1. Generate a self-reflective thought on the conversation about your performance and interaction quality.
 2. Extract new facts from the conversation.
 3. Identify and describe relationships between entities.
   - The sourceEntityId is the UUID of the entity initiating the interaction.
@@ -3288,23 +3380,27 @@ function resolveEntity(entityId, entities) {
   }
   let entity;
   entity = entities.find((a2) => a2.id === entityId);
-  if (entity) {
+  if (entity?.id) {
     return entity.id;
   }
-  entity = entities.find((a2) => a2.id.includes(entityId));
-  if (entity) {
+  entity = entities.find((a2) => a2.id?.includes(entityId));
+  if (entity?.id) {
     return entity.id;
   }
   entity = entities.find(
     (a2) => a2.names.some((n2) => n2.toLowerCase().includes(entityId.toLowerCase()))
   );
-  if (entity) {
+  if (entity?.id) {
     return entity.id;
   }
   throw new Error(`Could not resolve entityId "${entityId}" to a valid UUID`);
 }
 async function handler(runtime, message, state) {
   const { agentId, roomId } = message;
+  if (!agentId || !roomId) {
+    logger9.warn("Missing agentId or roomId in message", message);
+    return;
+  }
   const [existingRelationships, entities, knownFacts] = await Promise.all([
     runtime.getRelationships({
       entityId: message.entityId
@@ -3319,7 +3415,7 @@ async function handler(runtime, message, state) {
   ]);
   const prompt = composePrompt4({
     state: {
-      ...state.values,
+      ...state?.values || {},
       knownFacts: formatFacts(knownFacts),
       roomType: message.content.channelType,
       entitiesInRoom: JSON.stringify(entities),
@@ -3399,7 +3495,10 @@ async function handler(runtime, message, state) {
         });
       }
     }
-    await runtime.setCache(`${message.roomId}-reflection-last-processed`, message.id);
+    await runtime.setCache(
+      `${message.roomId}-reflection-last-processed`,
+      message?.id || ""
+    );
     return reflection;
   } catch (error) {
     logger9.error("Error in reflection handler:", error);
@@ -3606,9 +3705,13 @@ var actionsProvider = {
   position: -1,
   get: async (runtime, message, state) => {
     const actionPromises = runtime.actions.map(async (action) => {
-      const result = await action.validate(runtime, message, state);
-      if (result) {
-        return action;
+      try {
+        const result = await action.validate(runtime, message, state);
+        if (result) {
+          return action;
+        }
+      } catch (e2) {
+        console.error("ACTIONS GET -> validate err", action, e2);
       }
       return null;
     });
@@ -3639,7 +3742,6 @@ import { addHeader as addHeader2, ChannelType as ChannelType3 } from "@elizaos/c
 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 = [
@@ -3724,7 +3826,8 @@ var attachmentsProvider = {
   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 currentMessageAttachments = message.content.attachments || [];
+    let allAttachments = [...currentMessageAttachments];
     const { roomId } = message;
     const conversationLength = runtime.getConversationLength();
     const recentMessagesData = await runtime.getMemories({
@@ -3740,17 +3843,24 @@ var attachmentsProvider = {
       if (lastMessageWithAttachment) {
         const lastMessageTime = lastMessageWithAttachment?.createdAt ?? Date.now();
         const oneHourBeforeLastMessage = lastMessageTime - 60 * 60 * 1e3;
-        allAttachments = recentMessagesData.reverse().flatMap((msg) => {
+        const currentAttachmentsMap = new Map(
+          currentMessageAttachments.map((att) => [att.id, att])
+        );
+        const recentAttachments = recentMessagesData.reverse().flatMap((msg) => {
           const msgTime = msg.createdAt ?? Date.now();
           const isWithinTime = msgTime >= oneHourBeforeLastMessage;
           const attachments = msg.content.attachments || [];
-          if (!isWithinTime) {
-            for (const attachment of attachments) {
-              attachment.text = "[Hidden]";
+          return attachments.map((attachment) => {
+            if (currentAttachmentsMap.has(attachment.id)) {
+              return null;
             }
-          }
-          return attachments;
+            if (!isWithinTime) {
+              return { ...attachment, text: "[Hidden]" };
+            }
+            return attachment;
+          }).filter((att) => att !== null);
         });
+        allAttachments = [...currentMessageAttachments, ...recentAttachments];
       }
     }
     const formattedAttachments = allAttachments.map(
@@ -3832,7 +3942,7 @@ var characterProvider = {
     const bio = addHeader4(`# About ${character.name}`, bioText);
     const system = character.system ?? "";
     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 topic = 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 `;
@@ -3843,7 +3953,7 @@ var characterProvider = {
       return `${topic2}, `;
     }).join("")}` : "";
     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 adjective = adjectiveString || "";
     const formattedCharacterPostExamples = !character.postExamples ? "" : character.postExamples.sort(() => 0.5 - Math.random()).map((post) => {
       const messageString = `${post}`;
       return messageString;
@@ -3855,7 +3965,7 @@ var characterProvider = {
         () => Math.random().toString(36).substring(2, 8)
       );
       return example.map((message2) => {
-        let messageString = `${message2.name}: ${message2.content.text}${message2.content.action || message2.content.actions ? ` (actions: ${message2.content.action || message2.content.actions.join(", ")})` : ""}`;
+        let messageString = `${message2.name}: ${message2.content.text}${message2.content.action || message2.content.actions ? ` (actions: ${message2.content.action || message2.content.actions?.join(", ")})` : ""}`;
         exampleNames.forEach((name, index) => {
           const placeholder = `{{name${index + 1}}}`;
           messageString = messageString.replaceAll(placeholder, name);
@@ -3869,7 +3979,7 @@ var characterProvider = {
     ) : "";
     const room = state.data.room ?? await runtime.getRoom(message.roomId);
     const isPostFormat = room?.type === ChannelType4.FEED || room?.type === ChannelType4.THREAD;
-    const postDirections = character?.style?.all?.length > 0 || character?.style?.post?.length > 0 ? addHeader4(
+    const postDirections = character?.style?.all?.length && character?.style?.all?.length > 0 || character?.style?.post?.length && character?.style?.post?.length > 0 ? addHeader4(
       `# Post Directions for ${character.name}`,
       (() => {
         const all = character?.style?.all || [];
@@ -3877,7 +3987,7 @@ var characterProvider = {
         return [...all, ...post].join("\n");
       })()
     ) : "";
-    const messageDirections = character?.style?.all?.length > 0 || character?.style?.chat?.length > 0 ? addHeader4(
+    const messageDirections = character?.style?.all?.length && character?.style?.all?.length > 0 || character?.style?.chat?.length && character?.style?.chat?.length > 0 ? addHeader4(
       `# Message Directions for ${character.name}`,
       (() => {
         const all = character?.style?.all || [];
@@ -3911,7 +4021,9 @@ var characterProvider = {
       examples,
       system
     };
-    const text = [bio, adjective, topic, topics, adjective, directions, examples, system].filter(Boolean).join("\n\n");
+    const topicSentence = topicString ? `${character.name} is currently interested in ${topicString}` : "";
+    const adjectiveSentence = adjectiveString ? `${character.name} is ${adjectiveString}` : "";
+    const text = [bio, adjectiveSentence, topicSentence, topics, directions, examples, system].filter(Boolean).join("\n\n");
     return {
       values,
       data,
@@ -3967,7 +4079,7 @@ var choiceProvider = {
           const options = task.metadata.options;
           options.forEach((option) => {
             if (typeof option === "string") {
-              const description = task.metadata?.options.find((o) => o.name === option)?.description || "";
+              const description = task.metadata?.options?.find((o) => o.name === option)?.description || "";
               output += `   - \`${option}\` ${description ? `- ${description}` : ""}
 `;
             } else {
@@ -4102,7 +4214,7 @@ function formatEvaluatorExamples(evaluators) {
           const placeholder = `{{name${index + 1}}}`;
           messageString = messageString.replaceAll(placeholder, name);
         });
-        return messageString + (message.content.action || message.content.actions ? ` (${message.content.action || message.content.actions.join(", ")})` : "");
+        return messageString + (message.content.action || message.content.actions ? ` (${message.content.action || message.content.actions?.join(", ")})` : "");
       }).join("\n");
       return `Prompt:
 ${formattedPrompt}
@@ -4151,6 +4263,7 @@ var evaluatorsProvider = {
 
 // src/providers/facts.ts
 import { ModelType as ModelType12 } from "@elizaos/core";
+import { logger as logger12 } from "@elizaos/core";
 function formatFacts2(facts) {
   return facts.reverse().map((fact) => fact.content.text).join("\n");
 }
@@ -4159,85 +4272,77 @@ var factsProvider = {
   description: "Key facts that the agent knows",
   dynamic: true,
   get: async (runtime, message, _state) => {
-    const recentMessages = await runtime.getMemories({
-      tableName: "messages",
-      roomId: message.roomId,
-      count: 10,
-      unique: false
-    });
-    const last5Messages = recentMessages.slice(-5).map((message2) => message2.content.text).join("\n");
-    const embedding = await runtime.useModel(ModelType12.TEXT_EMBEDDING, {
-      text: last5Messages
-    });
-    const [relevantFacts, recentFactsData] = await Promise.all([
-      runtime.searchMemories({
-        tableName: "facts",
-        embedding,
-        roomId: message.roomId,
-        count: 10
-      }),
-      runtime.getMemories({
-        tableName: "facts",
+    try {
+      const recentMessages = await runtime.getMemories({
+        tableName: "messages",
         roomId: message.roomId,
         count: 10,
-        start: 0,
-        end: Date.now()
-      })
-    ]);
-    const allFacts = [...relevantFacts, ...recentFactsData].filter(
-      (fact, index, self) => index === self.findIndex((t) => t.id === fact.id)
-    );
-    if (allFacts.length === 0) {
+        unique: false
+      });
+      const last5Messages = recentMessages.slice(-5).map((message2) => message2.content.text).join("\n");
+      const embedding = await runtime.useModel(ModelType12.TEXT_EMBEDDING, {
+        text: last5Messages
+      });
+      const [relevantFacts, recentFactsData] = await Promise.all([
+        runtime.searchMemories({
+          tableName: "facts",
+          embedding,
+          roomId: message.roomId,
+          worldId: message.worldId,
+          count: 6,
+          query: message.content.text
+        }),
+        runtime.searchMemories({
+          embedding,
+          query: message.content.text,
+          tableName: "facts",
+          roomId: message.roomId,
+          entityId: message.entityId,
+          count: 6
+        })
+      ]);
+      const allFacts = [...relevantFacts, ...recentFactsData].filter(
+        (fact, index, self) => index === self.findIndex((t) => t.id === fact.id)
+      );
+      if (allFacts.length === 0) {
+        return {
+          values: {
+            facts: ""
+          },
+          data: {
+            facts: allFacts
+          },
+          text: "No facts available."
+        };
+      }
+      const formattedFacts = formatFacts2(allFacts);
+      const text = "Key facts that {{agentName}} knows:\n{{formattedFacts}}".replace("{{agentName}}", runtime.character.name).replace("{{formattedFacts}}", formattedFacts);
       return {
         values: {
-          facts: ""
+          facts: formattedFacts
         },
         data: {
           facts: allFacts
         },
-        text: ""
+        text
+      };
+    } catch (error) {
+      logger12.error("Error in factsProvider:", error);
+      return {
+        values: {
+          facts: ""
+        },
+        data: {
+          facts: []
+        },
+        text: "Error retrieving facts."
       };
     }
-    const formattedFacts = formatFacts2(allFacts);
-    const text = "Key facts that {{agentName}} knows:\n{{formattedFacts}}".replace("{{agentName}}", runtime.character.name).replace("{{formattedFacts}}", formattedFacts);
-    return {
-      values: {
-        facts: formattedFacts
-      },
-      data: {
-        facts: allFacts
-      },
-      text
-    };
-  }
-};
-
-// src/providers/knowledge.ts
-import { addHeader as addHeader7 } from "@elizaos/core";
-var knowledgeProvider = {
-  name: "KNOWLEDGE",
-  description: "Knowledge from the knowledge base that the agent knows",
-  dynamic: true,
-  get: async (runtime, message) => {
-    const knowledgeData = await runtime.getKnowledge(message);
-    const knowledge = knowledgeData && knowledgeData.length > 0 ? addHeader7(
-      "# Knowledge",
-      knowledgeData.map((knowledge2) => `- ${knowledge2.content.text}`).join("\n")
-    ) : "";
-    return {
-      data: {
-        knowledge
-      },
-      values: {
-        knowledge
-      },
-      text: knowledge
-    };
   }
 };
 
 // src/providers/providers.ts
-import { addHeader as addHeader8 } from "@elizaos/core";
+import { addHeader as addHeader7 } from "@elizaos/core";
 var providersProvider = {
   name: "PROVIDERS",
   description: "List of all data providers the agent can use to get additional information",
@@ -4249,11 +4354,11 @@ var providersProvider = {
     const headerText = "# Providers\n\nThese providers are available for the agent to select and use:";
     if (providerDescriptions.length === 0) {
       return {
-        text: addHeader8(headerText, "No dynamic providers are currently available.")
+        text: addHeader7(headerText, "No dynamic providers are currently available.")
       };
     }
     const providersText = providerDescriptions.join("\n");
-    const text = addHeader8(headerText, providersText);
+    const text = addHeader7(headerText, providersText);
     const data = {
       dynamicProviders: dynamicProviders.map((provider) => ({
         name: provider.name,
@@ -4269,11 +4374,12 @@ var providersProvider = {
 
 // src/providers/recentMessages.ts
 import {
-  addHeader as addHeader9,
+  addHeader as addHeader8,
   ChannelType as ChannelType5,
   formatMessages,
   formatPosts,
-  getEntityDetails as getEntityDetails3
+  getEntityDetails as getEntityDetails3,
+  logger as logger13
 } from "@elizaos/core";
 var getRecentInteractions = async (runtime, sourceEntityId, targetEntityId, excludeRoomId) => {
   const rooms = await runtime.getRoomsForParticipants([sourceEntityId, targetEntityId]);
@@ -4289,114 +4395,158 @@ var recentMessagesProvider = {
   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([
-      getEntityDetails3({ runtime, roomId }),
-      runtime.getRoom(roomId),
-      runtime.getMemories({
-        tableName: "messages",
-        roomId,
-        count: conversationLength,
-        unique: false
-      }),
-      message.entityId !== runtime.agentId ? getRecentInteractions(runtime, message.entityId, runtime.agentId, roomId) : Promise.resolve([])
-    ]);
-    const isPostFormat = room?.type === ChannelType5.FEED || room?.type === ChannelType5.THREAD;
-    const [formattedRecentMessages, formattedRecentPosts] = await Promise.all([
-      formatMessages({
-        messages: recentMessagesData,
-        entities: entitiesData
-      }),
-      formatPosts({
-        messages: recentMessagesData,
-        entities: entitiesData,
-        conversationHeader: false
-      })
-    ]);
-    const recentPosts = formattedRecentPosts && formattedRecentPosts.length > 0 ? addHeader9("# Posts in Thread", formattedRecentPosts) : "";
-    const metaData = message.metadata;
-    const recieveMessage = addHeader9(
-      "# Received Message:",
-      `${metaData?.entityName || "unknown"}: ${message.content.text}`
-    );
-    const recentMessages = formattedRecentMessages && formattedRecentMessages.length > 0 ? addHeader9("# Conversation Messages", formattedRecentMessages) : "";
-    const interactionEntityMap = /* @__PURE__ */ new Map();
-    if (recentInteractionsData.length > 0) {
-      const uniqueEntityIds = [
-        ...new Set(
-          recentInteractionsData.map((message2) => message2.entityId).filter((id) => id !== runtime.agentId)
-        )
-      ];
-      const uniqueEntityIdSet = new Set(uniqueEntityIds);
-      const entitiesDataIdSet = /* @__PURE__ */ new Set();
-      entitiesData.forEach((entity) => {
-        if (uniqueEntityIdSet.has(entity.id)) {
-          interactionEntityMap.set(entity.id, entity);
-          entitiesDataIdSet.add(entity.id);
-        }
-      });
-      const remainingEntityIds = uniqueEntityIds.filter((id) => !entitiesDataIdSet.has(id));
-      if (remainingEntityIds.length > 0) {
-        const entities = await Promise.all(
-          remainingEntityIds.map((entityId) => runtime.getEntityById(entityId))
-        );
-        entities.forEach((entity, index) => {
-          if (entity) {
-            interactionEntityMap.set(remainingEntityIds[index], entity);
+    try {
+      const { roomId } = message;
+      const conversationLength = runtime.getConversationLength();
+      const [entitiesData, room, recentMessagesData, recentInteractionsData] = await Promise.all([
+        getEntityDetails3({ runtime, roomId }),
+        runtime.getRoom(roomId),
+        runtime.getMemories({
+          tableName: "messages",
+          roomId,
+          count: conversationLength,
+          unique: false
+        }),
+        message.entityId !== runtime.agentId ? getRecentInteractions(runtime, message.entityId, runtime.agentId, roomId) : Promise.resolve([])
+      ]);
+      const isPostFormat = room?.type ? room.type === ChannelType5.FEED || room.type === ChannelType5.THREAD : false;
+      const [formattedRecentMessages, formattedRecentPosts] = await Promise.all([
+        formatMessages({
+          messages: recentMessagesData,
+          entities: entitiesData
+        }),
+        formatPosts({
+          messages: recentMessagesData,
+          entities: entitiesData,
+          conversationHeader: false
+        })
+      ]);
+      const recentPosts = formattedRecentPosts && formattedRecentPosts.length > 0 ? addHeader8("# Posts in Thread", formattedRecentPosts) : "";
+      const recentMessages = formattedRecentMessages && formattedRecentMessages.length > 0 ? addHeader8("# Conversation Messages", formattedRecentMessages) : "";
+      if (!recentPosts && !recentMessages && recentMessagesData.length === 0 && !message.content.text) {
+        return {
+          data: {
+            recentMessages: [],
+            recentInteractions: []
+          },
+          values: {
+            recentPosts: "",
+            recentMessages: "",
+            recentMessageInteractions: "",
+            recentPostInteractions: "",
+            recentInteractions: ""
+          },
+          text: "No recent messages available"
+        };
+      }
+      const metaData = message.metadata;
+      const senderName = entitiesData.find((entity) => entity.id === message.entityId)?.names[0] || metaData?.entityName || "Unknown User";
+      const receivedMessageContent = message.content.text;
+      const hasReceivedMessage = !!receivedMessageContent?.trim();
+      const receivedMessageHeader = hasReceivedMessage ? addHeader8("# Received Message", `${senderName}: ${receivedMessageContent}`) : "";
+      const focusHeader = hasReceivedMessage ? addHeader8(
+        "# Focus your response",
+        `You are replying to the above message from **${senderName}**. Keep your answer relevant to that message. Do not repeat earlier replies unless the sender asks again.`
+      ) : "";
+      const interactionEntityMap = /* @__PURE__ */ new Map();
+      if (recentInteractionsData.length > 0) {
+        const uniqueEntityIds = [
+          ...new Set(
+            recentInteractionsData.map((message2) => message2.entityId).filter((id) => id !== runtime.agentId)
+          )
+        ];
+        const uniqueEntityIdSet = new Set(uniqueEntityIds);
+        const entitiesDataIdSet = /* @__PURE__ */ new Set();
+        entitiesData.forEach((entity) => {
+          if (uniqueEntityIdSet.has(entity.id)) {
+            interactionEntityMap.set(entity.id, entity);
+            entitiesDataIdSet.add(entity.id);
           }
         });
+        const remainingEntityIds = uniqueEntityIds.filter((id) => !entitiesDataIdSet.has(id));
+        if (remainingEntityIds.length > 0) {
+          const entities = await Promise.all(
+            remainingEntityIds.map((entityId) => runtime.getEntityById(entityId))
+          );
+          entities.forEach((entity, index) => {
+            if (entity) {
+              interactionEntityMap.set(remainingEntityIds[index], entity);
+            }
+          });
+        }
       }
-    }
-    const getRecentMessageInteractions = async (recentInteractionsData2) => {
-      const formattedInteractions = recentInteractionsData2.map((message2) => {
-        const isSelf = message2.entityId === runtime.agentId;
-        let sender;
-        if (isSelf) {
-          sender = runtime.character.name;
-        } else {
-          sender = interactionEntityMap.get(message2.entityId)?.metadata?.username || "unknown";
+      const getRecentMessageInteractions = async (recentInteractionsData2) => {
+        const formattedInteractions = recentInteractionsData2.map((message2) => {
+          const isSelf = message2.entityId === runtime.agentId;
+          let sender;
+          if (isSelf) {
+            sender = runtime.character.name;
+          } else {
+            sender = interactionEntityMap.get(message2.entityId)?.metadata?.username || "unknown";
+          }
+          return `${sender}: ${message2.content.text}`;
+        });
+        return formattedInteractions.join("\n");
+      };
+      const getRecentPostInteractions = async (recentInteractionsData2, entities) => {
+        const combinedEntities = [...entities];
+        const actorIds = new Set(entities.map((entity) => entity.id));
+        for (const [id, entity] of interactionEntityMap.entries()) {
+          if (!actorIds.has(id)) {
+            combinedEntities.push(entity);
+          }
         }
-        return `${sender}: ${message2.content.text}`;
-      });
-      return formattedInteractions.join("\n");
-    };
-    const getRecentPostInteractions = async (recentInteractionsData2, entities) => {
-      const combinedEntities = [...entities];
-      const actorIds = new Set(entities.map((entity) => entity.id));
-      for (const [id, entity] of interactionEntityMap.entries()) {
-        if (!actorIds.has(id)) {
-          combinedEntities.push(entity);
-        }
-      }
-      const formattedInteractions = formatPosts({
-        messages: recentInteractionsData2,
-        entities: combinedEntities,
-        conversationHeader: true
-      });
-      return formattedInteractions;
-    };
-    const [recentMessageInteractions, recentPostInteractions] = await Promise.all([
-      getRecentMessageInteractions(recentInteractionsData),
-      getRecentPostInteractions(recentInteractionsData, entitiesData)
-    ]);
-    const data = {
-      recentMessages: recentMessagesData,
-      recentInteractions: recentInteractionsData
-    };
-    const values = {
-      recentPosts,
-      recentMessages,
-      recentMessageInteractions,
-      recentPostInteractions,
-      recentInteractions: isPostFormat ? recentPostInteractions : recentMessageInteractions
-    };
-    const text = [isPostFormat ? recentPosts : recentMessages + recieveMessage].filter(Boolean).join("\n\n");
-    return {
-      data,
-      values,
-      text
-    };
+        const formattedInteractions = formatPosts({
+          messages: recentInteractionsData2,
+          entities: combinedEntities,
+          conversationHeader: true
+        });
+        return formattedInteractions;
+      };
+      const [recentMessageInteractions, recentPostInteractions] = await Promise.all([
+        getRecentMessageInteractions(recentInteractionsData),
+        getRecentPostInteractions(recentInteractionsData, entitiesData)
+      ]);
+      const data = {
+        recentMessages: recentMessagesData,
+        recentInteractions: recentInteractionsData
+      };
+      const values = {
+        recentPosts,
+        recentMessages,
+        recentMessageInteractions,
+        recentPostInteractions,
+        recentInteractions: isPostFormat ? recentPostInteractions : recentMessageInteractions
+      };
+      const text = [
+        isPostFormat ? recentPosts : recentMessages,
+        // Only add received message and focus headers if there are messages or a current message to process
+        recentMessages || recentPosts || message.content.text ? receivedMessageHeader : "",
+        recentMessages || recentPosts || message.content.text ? focusHeader : ""
+      ].filter(Boolean).join("\n\n");
+      return {
+        data,
+        values,
+        text
+      };
+    } catch (error) {
+      logger13.error("Error in recentMessagesProvider:", error);
+      return {
+        data: {
+          recentMessages: [],
+          recentInteractions: []
+        },
+        values: {
+          recentPosts: "",
+          recentMessages: "",
+          recentMessageInteractions: "",
+          recentPostInteractions: "",
+          recentInteractions: ""
+        },
+        text: "Error retrieving recent messages."
+        // Or 'No recent messages available' as the test expects
+      };
+    }
   }
 };
 
@@ -4485,7 +4635,7 @@ ${formattedRelationships}`
 import {
   ChannelType as ChannelType6,
   createUniqueUuid as createUniqueUuid2,
-  logger as logger12
+  logger as logger14
 } from "@elizaos/core";
 var roleProvider = {
   name: "ROLES",
@@ -4510,106 +4660,108 @@ var roleProvider = {
     if (!serverId) {
       throw new Error("No server ID found");
     }
-    try {
-      logger12.info(`Using server ID: ${serverId}`);
-      const worldId = createUniqueUuid2(runtime, serverId);
-      const world = await runtime.getWorld(worldId);
-      if (!world || !world.metadata?.ownership?.ownerId) {
-        logger12.info(
-          `No ownership data found for server ${serverId}, initializing empty role hierarchy`
-        );
-        return {
-          data: {
-            roles: []
-          },
-          values: {
-            roles: "No role information available for this server."
-          },
-          text: "No role information available for this server."
-        };
-      }
-      const roles = world.metadata.roles || {};
-      if (Object.keys(roles).length === 0) {
-        logger12.info(`No roles found for server ${serverId}`);
-        return {
-          data: {
-            roles: []
-          },
-          values: {
-            roles: "No role information available for this server."
-          }
-        };
-      }
-      logger12.info(`Found ${Object.keys(roles).length} roles`);
-      const owners = [];
-      const admins = [];
-      const members = [];
-      for (const entityId of Object.keys(roles)) {
-        const userRole = roles[entityId];
-        const user = await runtime.getEntityById(entityId);
-        const name = user.metadata[room.source]?.name;
-        const username = user.metadata[room.source]?.username;
-        const names = user.names;
-        if (owners.some((owner) => owner.username === username) || admins.some((admin) => admin.username === username) || members.some((member) => member.username === username)) {
-          continue;
-        }
-        switch (userRole) {
-          case "OWNER":
-            owners.push({ name, username, names });
-            break;
-          case "ADMIN":
-            admins.push({ name, username, names });
-            break;
-          default:
-            members.push({ name, username, names });
-            break;
-        }
-      }
-      let response = "# Server Role Hierarchy\n\n";
-      if (owners.length > 0) {
-        response += "## Owners\n";
-        owners.forEach((owner) => {
-          response += `${owner.name} (${owner.names.join(", ")})
-`;
-        });
-        response += "\n";
-      }
-      if (admins.length > 0) {
-        response += "## Administrators\n";
-        admins.forEach((admin) => {
-          response += `${admin.name} (${admin.names.join(", ")}) (${admin.username})
-`;
-        });
-        response += "\n";
-      }
-      if (members.length > 0) {
-        response += "## Members\n";
-        members.forEach((member) => {
-          response += `${member.name} (${member.names.join(", ")}) (${member.username})
-`;
-        });
-      }
+    logger14.info(`Using server ID: ${serverId}`);
+    const worldId = createUniqueUuid2(runtime, serverId);
+    const world = await runtime.getWorld(worldId);
+    if (!world || !world.metadata?.ownership?.ownerId) {
+      logger14.info(
+        `No ownership data found for server ${serverId}, initializing empty role hierarchy`
+      );
       return {
         data: {
-          roles: response
+          roles: []
         },
         values: {
-          roles: response
+          roles: "No role information available for this server."
         },
-        text: response
+        text: "No role information available for this server."
       };
-    } catch (error) {
-      logger12.error("Error in role provider:", error);
+    }
+    const roles = world.metadata.roles || {};
+    if (Object.keys(roles).length === 0) {
+      logger14.info(`No roles found for server ${serverId}`);
       return {
         data: {
           roles: []
         },
         values: {
-          roles: "There was an error retrieving role information."
+          roles: "No role information available for this server."
+        }
+      };
+    }
+    logger14.info(`Found ${Object.keys(roles).length} roles`);
+    const owners = [];
+    const admins = [];
+    const members = [];
+    for (const entityId of Object.keys(roles)) {
+      const userRole = roles[entityId];
+      const user = await runtime.getEntityById(entityId);
+      const name = user?.metadata?.[room.source]?.name;
+      const username = user?.metadata?.[room.source]?.username;
+      const names = user?.names;
+      if (owners.some((owner) => owner.username === username) || admins.some((admin) => admin.username === username) || members.some((member) => member.username === username)) {
+        continue;
+      }
+      if (!name || !username || !names) {
+        logger14.warn(`User ${entityId} has no name or username, skipping`);
+        continue;
+      }
+      switch (userRole) {
+        case "OWNER":
+          owners.push({ name, username, names });
+          break;
+        case "ADMIN":
+          admins.push({ name, username, names });
+          break;
+        default:
+          members.push({ name, username, names });
+          break;
+      }
+    }
+    let response = "# Server Role Hierarchy\n\n";
+    if (owners.length > 0) {
+      response += "## Owners\n";
+      owners.forEach((owner) => {
+        response += `${owner.name} (${owner.names.join(", ")})
+`;
+      });
+      response += "\n";
+    }
+    if (admins.length > 0) {
+      response += "## Administrators\n";
+      admins.forEach((admin) => {
+        response += `${admin.name} (${admin.names.join(", ")}) (${admin.username})
+`;
+      });
+      response += "\n";
+    }
+    if (members.length > 0) {
+      response += "## Members\n";
+      members.forEach((member) => {
+        response += `${member.name} (${member.names.join(", ")}) (${member.username})
+`;
+      });
+    }
+    if (owners.length === 0 && admins.length === 0 && members.length === 0) {
+      return {
+        data: {
+          roles: []
+        },
+        values: {
+          roles: "No role information available for this server."
         },
-        text: "There was an error retrieving role information."
+        text: "No role information available for this server."
       };
     }
+    return {
+      data: {
+        roles: response
+      },
+      values: {
+        roles: response
+      },
+      text: response
+    };
   }
 };
 
@@ -4618,7 +4770,7 @@ import {
   ChannelType as ChannelType7,
   findWorldsForOwner as findWorldsForOwner2,
   getWorldSettings as getWorldSettings2,
-  logger as logger13
+  logger as logger15
 } from "@elizaos/core";
 var formatSettingValue = (setting, isOnboarding) => {
   if (setting.value === null) return "Not set";
@@ -4645,13 +4797,13 @@ function generateStatusMessage(runtime, worldSettings, isOnboarding, state) {
       };
     }).filter(Boolean);
     const requiredUnconfigured = formattedSettings.filter(
-      (s) => s.required && !s.configured
+      (s) => s?.required && !s.configured
     ).length;
     if (isOnboarding) {
       const settingsList = formattedSettings.map((s) => {
-        const label = s.required ? "(Required)" : "(Optional)";
-        return `${s.key}: ${s.value} ${label}
-(${s.name}) ${s.usageDescription}`;
+        const label = s?.required ? "(Required)" : "(Optional)";
+        return `${s?.key}: ${s?.value} ${label}
+(${s?.name}) ${s?.usageDescription}`;
       }).join("\n\n");
       const validKeys = `Valid setting keys: ${Object.keys(worldSettings).join(", ")}`;
       const commonInstructions = `Instructions for ${runtime.character.name}:
@@ -4661,7 +4813,7 @@ function generateStatusMessage(runtime, worldSettings, isOnboarding, state) {
       - Do not call UPDATE_SETTINGS just because the user has started onboarding or you think a setting needs to be configured. Only update when the user clearly provides a specific value for a setting you are currently asking about.
       - Answer setting-related questions using only the name, description, and value from the list.`;
       if (requiredUnconfigured > 0) {
-        return `# PRIORITY TASK: Onboarding with ${state.senderName}
+        return `# PRIORITY TASK: Onboarding with ${state?.senderName}
 
         ${runtime.character.name} needs to help the user configure ${requiredUnconfigured} required settings:
         
@@ -4685,11 +4837,11 @@ function generateStatusMessage(runtime, worldSettings, isOnboarding, state) {
 
 ${requiredUnconfigured > 0 ? `IMPORTANT!: ${requiredUnconfigured} required settings still need configuration. ${runtime.character.name} should get onboarded with the OWNER as soon as possible.
 
-` : "All required settings are configured.\n\n"}${formattedSettings.map((s) => `### ${s.name}
-**Value:** ${s.value}
-**Description:** ${s.description}`).join("\n\n")}`;
+` : "All required settings are configured.\n\n"}${formattedSettings.map((s) => `### ${s?.name}
+**Value:** ${s?.value}
+**Description:** ${s?.description}`).join("\n\n")}`;
   } catch (error) {
-    logger13.error(`Error generating status message: ${error}`);
+    logger15.error(`Error generating status message: ${error}`);
     return "Error generating configuration status.";
   }
 }
@@ -4702,11 +4854,11 @@ var settingsProvider = {
         runtime.getRoom(message.roomId),
         findWorldsForOwner2(runtime, message.entityId)
       ]).catch((error) => {
-        logger13.error(`Error fetching initial data: ${error}`);
+        logger15.error(`Error fetching initial data: ${error}`);
         throw new Error("Failed to retrieve room or user world information");
       });
       if (!room) {
-        logger13.error("No room found for settings provider");
+        logger15.error("No room found for settings provider");
         return {
           data: {
             settings: []
@@ -4718,7 +4870,7 @@ var settingsProvider = {
         };
       }
       if (!room.worldId) {
-        logger13.debug("No world found for settings provider -- settings provider will be skipped");
+        logger15.debug("No world found for settings provider -- settings provider will be skipped");
         return {
           data: {
             settings: []
@@ -4731,42 +4883,42 @@ var settingsProvider = {
       }
       const type = room.type;
       const isOnboarding = type === ChannelType7.DM;
-      let world;
-      let serverId;
-      let worldSettings;
+      let world = null;
+      let serverId = void 0;
+      let worldSettings = null;
       if (isOnboarding) {
-        world = userWorlds.find((world2) => world2.metadata.settings);
+        world = userWorlds?.find((world2) => world2.metadata?.settings);
         if (!world) {
-          logger13.error("No world found for user during onboarding");
+          logger15.error("No world found for user during onboarding");
           throw new Error("No server ownership found for onboarding");
         }
         serverId = world.serverId;
         try {
           worldSettings = await getWorldSettings2(runtime, serverId);
         } catch (error) {
-          logger13.error(`Error fetching world settings: ${error}`);
+          logger15.error(`Error fetching world settings: ${error}`);
           throw new Error(`Failed to retrieve settings for server ${serverId}`);
         }
       } else {
         try {
           world = await runtime.getWorld(room.worldId);
           if (!world) {
-            logger13.error(`No world found for room ${room.worldId}`);
+            logger15.error(`No world found for room ${room.worldId}`);
             throw new Error(`No world found for room ${room.worldId}`);
           }
           serverId = world.serverId;
           if (serverId) {
             worldSettings = await getWorldSettings2(runtime, serverId);
           } else {
-            logger13.error(`No server ID found for world ${room.worldId}`);
+            logger15.error(`No server ID found for world ${room.worldId}`);
           }
         } catch (error) {
-          logger13.error(`Error processing world data: ${error}`);
+          logger15.error(`Error processing world data: ${error}`);
           throw new Error("Failed to process world information");
         }
       }
       if (!serverId) {
-        logger13.info(
+        logger15.info(
           `No server ownership found for user ${message.entityId} after recovery attempt`
         );
         return isOnboarding ? {
@@ -4788,7 +4940,7 @@ var settingsProvider = {
         };
       }
       if (!worldSettings) {
-        logger13.info(`No settings state found for server ${serverId}`);
+        logger15.info(`No settings state found for server ${serverId}`);
         return isOnboarding ? {
           data: {
             settings: []
@@ -4818,7 +4970,7 @@ var settingsProvider = {
         text: output
       };
     } catch (error) {
-      logger13.error(`Critical error in settings provider: ${error}`);
+      logger15.error(`Critical error in settings provider: ${error}`);
       return {
         data: {
           settings: []
@@ -4855,13 +5007,174 @@ var timeProvider = {
   }
 };
 
+// src/providers/world.ts
+import {
+  logger as logger16,
+  addHeader as addHeader9,
+  ChannelType as ChannelType8
+} from "@elizaos/core";
+var worldProvider = {
+  name: "WORLD",
+  description: "World and environment information",
+  dynamic: true,
+  get: async (runtime, message) => {
+    try {
+      logger16.debug("[\u{1F310}] World provider activated for roomId:", message.roomId);
+      const currentRoom = await runtime.getRoom(message.roomId);
+      if (!currentRoom) {
+        logger16.warn(`World provider: Room not found for roomId ${message.roomId}`);
+        return {
+          data: {
+            world: {
+              info: "Unable to retrieve world information - room not found"
+            }
+          },
+          text: "Unable to retrieve world information - room not found"
+        };
+      }
+      logger16.debug(`[\u{1F310}] World provider: Found room "${currentRoom.name}" (${currentRoom.type})`);
+      const worldId = currentRoom.worldId;
+      if (!worldId) {
+        logger16.warn(`World provider: World ID not found for roomId ${message.roomId}`);
+        return {
+          data: {
+            world: {
+              info: "Unable to retrieve world information - world ID not found"
+            }
+          },
+          text: "Unable to retrieve world information - world ID not found"
+        };
+      }
+      const world = await runtime.getWorld(worldId);
+      if (!world) {
+        logger16.warn(`World provider: World not found for worldId ${worldId}`);
+        return {
+          data: {
+            world: {
+              info: "Unable to retrieve world information - world not found"
+            }
+          },
+          text: "Unable to retrieve world information - world not found"
+        };
+      }
+      logger16.debug(`[\u{1F310}] World provider: Found world "${world.name}" (ID: ${world.id})`);
+      const worldRooms = await runtime.getRooms(worldId);
+      logger16.debug(
+        `[\u{1F310}] World provider: Found ${worldRooms.length} rooms in world "${world.name}"`
+      );
+      const participants = await runtime.getParticipantsForRoom(message.roomId);
+      logger16.debug(
+        `[\u{1F310}] World provider: Found ${participants.length} participants in room "${currentRoom.name}"`
+      );
+      const channelsByType = {
+        text: [],
+        voice: [],
+        dm: [],
+        feed: [],
+        thread: [],
+        other: []
+      };
+      for (const room of worldRooms) {
+        if (!room?.id || !room.name) {
+          logger16.warn(`World provider: Room ID or name is missing for room ${room.id}`);
+          continue;
+        }
+        const roomInfo = {
+          id: room.id,
+          name: room.name,
+          isCurrentChannel: room.id === message.roomId
+        };
+        if (room.type === ChannelType8.GROUP || room.type === ChannelType8.WORLD || room.type === ChannelType8.FORUM) {
+          channelsByType.text.push(roomInfo);
+        } else if (room.type === ChannelType8.VOICE_GROUP || room.type === ChannelType8.VOICE_DM) {
+          channelsByType.voice.push(roomInfo);
+        } else if (room.type === ChannelType8.DM || room.type === ChannelType8.SELF) {
+          channelsByType.dm.push(roomInfo);
+        } else if (room.type === ChannelType8.FEED) {
+          channelsByType.feed.push(roomInfo);
+        } else if (room.type === ChannelType8.THREAD) {
+          channelsByType.thread.push(roomInfo);
+        } else {
+          channelsByType.other.push({
+            ...roomInfo,
+            type: room.type
+          });
+        }
+      }
+      const worldInfoText = [
+        `# World: ${world.name}`,
+        `Current Channel: ${currentRoom.name} (${currentRoom.type})`,
+        `Total Channels: ${worldRooms.length}`,
+        `Participants in current channel: ${participants.length}`,
+        "",
+        `Text channels: ${channelsByType.text.length}`,
+        `Voice channels: ${channelsByType.voice.length}`,
+        `DM channels: ${channelsByType.dm.length}`,
+        `Feed channels: ${channelsByType.feed.length}`,
+        `Thread channels: ${channelsByType.thread.length}`,
+        `Other channels: ${channelsByType.other.length}`
+      ].join("\n");
+      const data = {
+        world: {
+          id: world.id,
+          name: world.name,
+          serverId: world.serverId,
+          metadata: world.metadata || {},
+          currentRoom: {
+            id: currentRoom.id,
+            name: currentRoom.name,
+            type: currentRoom.type,
+            channelId: currentRoom.channelId,
+            participantCount: participants.length
+          },
+          channels: channelsByType,
+          channelStats: {
+            total: worldRooms.length,
+            text: channelsByType.text.length,
+            voice: channelsByType.voice.length,
+            dm: channelsByType.dm.length,
+            feed: channelsByType.feed.length,
+            thread: channelsByType.thread.length,
+            other: channelsByType.other.length
+          }
+        }
+      };
+      const values = {
+        worldName: world.name,
+        currentChannelName: currentRoom.name,
+        worldInfo: worldInfoText
+      };
+      const formattedText = addHeader9("# World Information", worldInfoText);
+      logger16.debug("[\u{1F310}] World provider completed successfully");
+      return {
+        data,
+        values,
+        text: formattedText
+      };
+    } catch (error) {
+      logger16.error(
+        `Error in world provider: ${error instanceof Error ? error.message : String(error)}`
+      );
+      return {
+        data: {
+          world: {
+            info: "Error retrieving world information",
+            error: error instanceof Error ? error.message : "Unknown error"
+          }
+        },
+        text: "Error retrieving world information"
+      };
+    }
+  }
+};
+
 // src/services/scenario.ts
 import {
-  ChannelType as ChannelType8,
+  ChannelType as ChannelType9,
   EventType,
   Service,
   createUniqueUuid as createUniqueUuid3,
-  logger as logger14
+  logger as logger17
 } from "@elizaos/core";
 var ScenarioService = class _ScenarioService extends Service {
   /**
@@ -4875,7 +5188,7 @@ var ScenarioService = class _ScenarioService extends Service {
     this.setupEventListeners();
   }
   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.";
+  capabilityDescription = "The agent is currently in a scenario testing environment. It can Create groups, send messages, and talk to other agents in a live interactive testing environment.";
   messageHandlers = /* @__PURE__ */ new Map();
   worlds = /* @__PURE__ */ new Map();
   activeActions = /* @__PURE__ */ new Map();
@@ -4905,7 +5218,7 @@ var ScenarioService = class _ScenarioService extends Service {
         startTime: Date.now(),
         completed: false
       });
-      logger14.debug("Evaluator started", data);
+      logger17.debug("[Bootstrap] Evaluator started", data);
       return Promise.resolve();
     });
     this.runtime.registerEvent(
@@ -4916,7 +5229,7 @@ var ScenarioService = class _ScenarioService extends Service {
           evaluator.completed = true;
           evaluator.error = data.error;
         }
-        logger14.debug("Evaluator completed", data);
+        logger17.debug("[Bootstrap] Evaluator completed", data);
         return Promise.resolve();
       }
     );
@@ -4995,9 +5308,10 @@ var ScenarioService = class _ScenarioService extends Service {
       id: roomId,
       name,
       source: "scenario",
-      type: ChannelType8.GROUP,
+      type: ChannelType9.GROUP,
       channelId: roomId,
-      serverId: worldId
+      serverId: worldId,
+      worldId
     });
     return roomId;
   }
@@ -5039,7 +5353,7 @@ var ScenarioService = class _ScenarioService extends Service {
         source: "scenario",
         name: sender.character.name,
         userName: sender.character.name,
-        channelType: ChannelType8.GROUP
+        channelType: ChannelType9.GROUP
       }
     };
     const participants = await this.runtime.getParticipantsForRoom(roomId);
@@ -5050,7 +5364,7 @@ var ScenarioService = class _ScenarioService extends Service {
         roomId,
         entityId: participantId,
         source: "scenario",
-        type: ChannelType8.GROUP
+        type: ChannelType9.GROUP
       });
     }
   }
@@ -5097,7 +5411,7 @@ var ScenarioService = class _ScenarioService extends Service {
 
 // src/services/task.ts
 import {
-  logger as logger15,
+  logger as logger18,
   Service as Service2,
   ServiceType
 } from "@elizaos/core";
@@ -5125,21 +5439,21 @@ var TaskService = class _TaskService extends Service2 {
     this.runtime.registerTaskWorker({
       name: "REPEATING_TEST_TASK",
       validate: async (_runtime, _message, _state) => {
-        logger15.debug("Validating repeating test task");
+        logger18.debug("[Bootstrap] Validating repeating test task");
         return true;
       },
       execute: async (_runtime, _options) => {
-        logger15.debug("Executing repeating test task");
+        logger18.debug("[Bootstrap] Executing repeating test task");
       }
     });
     this.runtime.registerTaskWorker({
       name: "ONETIME_TEST_TASK",
       validate: async (_runtime, _message, _state) => {
-        logger15.debug("Validating one-time test task");
+        logger18.debug("[Bootstrap] Validating one-time test task");
         return true;
       },
       execute: async (_runtime, _options) => {
-        logger15.debug("Executing one-time test task");
+        logger18.debug("[Bootstrap] Executing one-time test task");
       }
     });
     const tasks = await this.runtime.getTasksByName("REPEATING_TEST_TASK");
@@ -5176,7 +5490,7 @@ var TaskService = class _TaskService extends Service2 {
       try {
         await this.checkTasks();
       } catch (error) {
-        logger15.error("Error checking tasks:", error);
+        logger18.error("[Bootstrap] Error checking tasks:", error);
       }
     }, this.TICK_INTERVAL);
   }
@@ -5205,7 +5519,7 @@ var TaskService = class _TaskService extends Service2 {
             continue;
           }
         } catch (error) {
-          logger15.error(`Error validating task ${task.name}:`, error);
+          logger18.error(`[Bootstrap] Error validating task ${task.name}:`, error);
           continue;
         }
       }
@@ -5227,6 +5541,10 @@ var TaskService = class _TaskService extends Service2 {
       const now = Date.now();
       for (const task of tasks) {
         let taskStartTime;
+        if (!task.tags?.includes("repeat")) {
+          await this.executeTask(task);
+          continue;
+        }
         if (typeof task.updatedAt === "number") {
           taskStartTime = task.updatedAt;
         } else if (task.metadata?.updatedAt && typeof task.metadata.updatedAt === "number") {
@@ -5241,15 +5559,22 @@ var TaskService = class _TaskService extends Service2 {
           await this.executeTask(task);
           continue;
         }
+        if (task.metadata?.updatedAt === task.metadata?.createdAt) {
+          if (task.tags?.includes("immediate")) {
+            logger18.debug("[Bootstrap] Immediately running task", task.name);
+            await this.executeTask(task);
+            continue;
+          }
+        }
         if (now - taskStartTime >= updateIntervalMs) {
-          logger15.debug(
-            `Executing task ${task.name} - interval of ${updateIntervalMs}ms has elapsed`
+          logger18.debug(
+            `[Bootstrap] Executing task ${task.name} - interval of ${updateIntervalMs}ms has elapsed`
           );
           await this.executeTask(task);
         }
       }
     } catch (error) {
-      logger15.error("Error checking tasks:", error);
+      logger18.error("[Bootstrap] Error checking tasks:", error);
     }
   }
   /**
@@ -5259,18 +5584,15 @@ var TaskService = class _TaskService extends Service2 {
    */
   async executeTask(task) {
     try {
-      if (!task) {
-        logger15.debug(`Task ${task.id} not found`);
+      if (!task || !task.id) {
+        logger18.debug(`[Bootstrap] Task not found`);
         return;
       }
       const worker = this.runtime.getTaskWorker(task.name);
       if (!worker) {
-        logger15.debug(`No worker found for task type: ${task.name}`);
+        logger18.debug(`[Bootstrap] No worker found for task type: ${task.name}`);
         return;
       }
-      logger15.debug(`Executing task ${task.name} (${task.id})`);
-      await worker.execute(this.runtime, task.metadata || {}, task);
-      logger15.debug("task.tags are", task.tags);
       if (task.tags?.includes("repeat")) {
         await this.runtime.updateTask(task.id, {
           metadata: {
@@ -5278,13 +5600,20 @@ var TaskService = class _TaskService extends Service2 {
             updatedAt: Date.now()
           }
         });
-        logger15.debug(`Updated repeating task ${task.name} (${task.id}) with new timestamp`);
-      } else {
+        logger18.debug(
+          `[Bootstrap] Updated repeating task ${task.name} (${task.id}) with new timestamp`
+        );
+      }
+      logger18.debug(`[Bootstrap] Executing task ${task.name} (${task.id})`);
+      await worker.execute(this.runtime, task.metadata || {}, task);
+      if (!task.tags?.includes("repeat")) {
         await this.runtime.deleteTask(task.id);
-        logger15.debug(`Deleted non-repeating task ${task.name} (${task.id}) after execution`);
+        logger18.debug(
+          `[Bootstrap] Deleted non-repeating task ${task.name} (${task.id}) after execution`
+        );
       }
     } catch (error) {
-      logger15.error(`Error executing task ${task.id}:`, error);
+      logger18.error(`[Bootstrap] Error executing task ${task.id}:`, error);
     }
   }
   /**
@@ -5328,184 +5657,382 @@ async function fetchMediaData(attachments) {
     })
   );
 }
+async function processAttachments(attachments, runtime) {
+  if (!attachments || attachments.length === 0) {
+    return [];
+  }
+  logger19.debug(`[Bootstrap] Processing ${attachments.length} attachment(s)`);
+  const processedAttachments = [];
+  for (const attachment of attachments) {
+    try {
+      const processedAttachment = { ...attachment };
+      if (attachment.contentType === ContentType.IMAGE && !attachment.description) {
+        logger19.debug(`[Bootstrap] Generating description for image: ${attachment.url}`);
+        try {
+          const response = await runtime.useModel(ModelType13.IMAGE_DESCRIPTION, {
+            prompt: imageDescriptionTemplate,
+            imageUrl: attachment.url
+          });
+          if (typeof response === "string") {
+            const parsedXml = parseKeyValueXml(response);
+            if (parsedXml?.description && parsedXml?.text) {
+              processedAttachment.description = parsedXml.description;
+              processedAttachment.title = parsedXml.title || "Image";
+              processedAttachment.text = parsedXml.text;
+              logger19.debug(
+                `[Bootstrap] Generated description: ${processedAttachment.description?.substring(0, 100)}...`
+              );
+            } else {
+              logger19.warn(`[Bootstrap] Failed to parse XML response for image description`);
+            }
+          } else if (response && typeof response === "object" && "description" in response) {
+            processedAttachment.description = response.description;
+            processedAttachment.title = response.title || "Image";
+            processedAttachment.text = response.description;
+            logger19.debug(
+              `[Bootstrap] Generated description: ${processedAttachment.description?.substring(0, 100)}...`
+            );
+          } else {
+            logger19.warn(`[Bootstrap] Unexpected response format for image description`);
+          }
+        } catch (error) {
+          logger19.error(`[Bootstrap] Error generating image description:`, error);
+        }
+      }
+      processedAttachments.push(processedAttachment);
+    } catch (error) {
+      logger19.error(`[Bootstrap] Failed to process attachment ${attachment.url}:`, error);
+      processedAttachments.push(attachment);
+    }
+  }
+  return processedAttachments;
+}
+function shouldBypassShouldRespond(runtime, room, source) {
+  if (!room) return false;
+  function normalizeEnvList(value) {
+    if (!value || typeof value !== "string") return [];
+    const cleaned = value.trim().replace(/^\[|\]$/g, "");
+    return cleaned.split(",").map((v) => v.trim()).filter(Boolean);
+  }
+  const defaultBypassTypes = [
+    ChannelType10.DM,
+    ChannelType10.VOICE_DM,
+    ChannelType10.SELF,
+    ChannelType10.API
+  ];
+  const defaultBypassSources = ["client_chat"];
+  const bypassTypesSetting = normalizeEnvList(runtime.getSetting("SHOULD_RESPOND_BYPASS_TYPES"));
+  const bypassSourcesSetting = normalizeEnvList(
+    runtime.getSetting("SHOULD_RESPOND_BYPASS_SOURCES")
+  );
+  const bypassTypes = new Set(
+    [...defaultBypassTypes.map((t) => t.toString()), ...bypassTypesSetting].map(
+      (s) => s.trim().toLowerCase()
+    )
+  );
+  const bypassSources = [...defaultBypassSources, ...bypassSourcesSetting].map(
+    (s) => s.trim().toLowerCase()
+  );
+  const roomType = room.type?.toString().toLowerCase();
+  const sourceStr = source?.toLowerCase() || "";
+  return bypassTypes.has(roomType) || bypassSources.some((pattern) => sourceStr.includes(pattern));
+}
 var messageReceivedHandler = async ({
   runtime,
   message,
   callback,
   onComplete
 }) => {
-  const responseId = v4_default();
-  if (!latestResponseIds.has(runtime.agentId)) {
-    latestResponseIds.set(runtime.agentId, /* @__PURE__ */ new Map());
-  }
-  const agentResponses = latestResponseIds.get(runtime.agentId);
-  if (!agentResponses) {
-    throw new Error("Agent responses map not found");
-  }
-  agentResponses.set(message.roomId, responseId);
-  const runId = asUUID(v4_default());
-  const startTime = Date.now();
-  await runtime.emitEvent(EventType2.RUN_STARTED, {
-    runtime,
-    runId,
-    messageId: message.id,
-    roomId: message.roomId,
-    entityId: message.entityId,
-    startTime,
-    status: "started",
-    source: "messageHandler"
-  });
   const timeoutDuration = 60 * 60 * 1e3;
-  let timeoutId;
-  const timeoutPromise = new Promise((_, reject) => {
-    timeoutId = setTimeout(async () => {
-      await runtime.emitEvent(EventType2.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 60 minute timeout",
-        source: "messageHandler"
-      });
-      reject(new Error("Run exceeded 60 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.addEmbeddingToMemory(message),
-        runtime.createMemory(message, "messages")
-      ]);
-      const agentUserState = await runtime.getParticipantUserState(message.roomId, runtime.agentId);
-      if (agentUserState === "MUTED" && !message.content.text?.toLowerCase().includes(runtime.character.name.toLowerCase())) {
-        logger16.debug("Ignoring muted room");
-        return;
-      }
-      let state = await runtime.composeState(message, [
-        "PROVIDERS",
-        "SHOULD_RESPOND",
-        "CHARACTER",
-        "RECENT_MESSAGES",
-        "ENTITIES"
-      ]);
-      const shouldRespondPrompt = composePromptFromState9({
-        state,
-        template: runtime.character.templates?.shouldRespondTemplate || shouldRespondTemplate
-      });
-      logger16.debug(
-        `*** Should Respond Prompt for ${runtime.character.name} ***
-`,
-        shouldRespondPrompt
-      );
-      const response = await runtime.useModel(ModelType13.TEXT_SMALL, {
-        prompt: shouldRespondPrompt
-      });
-      logger16.debug(`*** Should Respond Response for ${runtime.character.name} ***
-`, response);
-      logger16.debug(`*** Raw Response Type: ${typeof response} ***`);
-      let processedResponse = response;
-      if (typeof response === "string" && response.includes("```")) {
-        logger16.debug("*** Response contains code block markers, attempting to clean up ***");
-        processedResponse = response.replace(/```json\n|\n```|```/g, "");
-        logger16.debug("*** Processed Response ***\n", processedResponse);
-      }
-      const responseObject = parseJSONObjectFromText4(processedResponse);
-      logger16.debug("*** Parsed Response Object ***", responseObject);
-      const providers = responseObject?.providers;
-      logger16.debug("*** Providers Value ***", providers);
-      const shouldRespond = responseObject?.action && responseObject.action === "RESPOND";
-      logger16.debug("*** Should Respond ***", shouldRespond);
-      state = await runtime.composeState(message, null, providers);
-      let responseMessages = [];
-      if (shouldRespond) {
-        const prompt = composePromptFromState9({
-          state,
-          template: runtime.character.templates?.messageHandlerTemplate || messageHandlerTemplate
+  let timeoutId = void 0;
+  try {
+    logger19.info(`[Bootstrap] Message received from ${message.entityId} in room ${message.roomId}`);
+    const responseId = v4_default();
+    if (!latestResponseIds.has(runtime.agentId)) {
+      latestResponseIds.set(runtime.agentId, /* @__PURE__ */ new Map());
+    }
+    const agentResponses = latestResponseIds.get(runtime.agentId);
+    if (!agentResponses) {
+      throw new Error("Agent responses map not found");
+    }
+    agentResponses.set(message.roomId, responseId);
+    const runId = asUUID(v4_default());
+    const startTime = Date.now();
+    await runtime.emitEvent(EventType2.RUN_STARTED, {
+      runtime,
+      runId,
+      messageId: message.id,
+      roomId: message.roomId,
+      entityId: message.entityId,
+      startTime,
+      status: "started",
+      source: "messageHandler"
+    });
+    const timeoutPromise = new Promise((_, reject) => {
+      timeoutId = setTimeout(async () => {
+        await runtime.emitEvent(EventType2.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 60 minute timeout",
+          source: "messageHandler"
         });
-        let responseContent = null;
-        let retries = 0;
-        const maxRetries = 3;
-        while (retries < maxRetries && (!responseContent?.thought || !responseContent?.actions)) {
-          const response2 = await runtime.useModel(ModelType13.TEXT_SMALL, {
-            prompt
-          });
-          responseContent = parseJSONObjectFromText4(response2);
-          retries++;
-          if (!responseContent?.thought && !responseContent?.actions) {
-            logger16.warn("*** Missing required fields, retrying... ***");
-          }
+        reject(new Error("Run exceeded 60 minute timeout"));
+      }, timeoutDuration);
+    });
+    const processingPromise = (async () => {
+      try {
+        if (message.entityId === runtime.agentId) {
+          logger19.debug(`[Bootstrap] Skipping message from self (${runtime.agentId})`);
+          throw new Error("Message is from the agent itself");
         }
-        const currentResponseId = agentResponses.get(message.roomId);
-        if (currentResponseId !== responseId) {
-          logger16.info(
-            `Response discarded - newer message being processed for agent: ${runtime.agentId}, room: ${message.roomId}`
-          );
+        logger19.debug(
+          `[Bootstrap] Processing message: ${truncateToCompleteSentence(message.content.text || "", 50)}...`
+        );
+        logger19.debug("[Bootstrap] Saving message to memory and embeddings");
+        await Promise.all([
+          runtime.addEmbeddingToMemory(message),
+          runtime.createMemory(message, "messages")
+        ]);
+        const agentUserState = await runtime.getParticipantUserState(
+          message.roomId,
+          runtime.agentId
+        );
+        if (agentUserState === "MUTED" && !message.content.text?.toLowerCase().includes(runtime.character.name.toLowerCase())) {
+          logger19.debug(`[Bootstrap] Ignoring muted room ${message.roomId}`);
           return;
         }
-        if (responseContent) {
-          responseContent.inReplyTo = createUniqueUuid4(runtime, message.id);
-          responseMessages = [
-            {
+        let state = await runtime.composeState(
+          message,
+          ["ANXIETY", "SHOULD_RESPOND", "ENTITIES", "CHARACTER", "RECENT_MESSAGES", "ACTIONS"],
+          true
+        );
+        const room = await runtime.getRoom(message.roomId);
+        const shouldSkipShouldRespond = shouldBypassShouldRespond(
+          runtime,
+          room ?? void 0,
+          message.content.source
+        );
+        if (message.content.attachments && message.content.attachments.length > 0) {
+          message.content.attachments = await processAttachments(
+            message.content.attachments,
+            runtime
+          );
+        }
+        let shouldRespond = true;
+        if (!shouldSkipShouldRespond) {
+          const shouldRespondPrompt = composePromptFromState9({
+            state,
+            template: runtime.character.templates?.shouldRespondTemplate || shouldRespondTemplate
+          });
+          logger19.debug(
+            `[Bootstrap] Evaluating response for ${runtime.character.name}
+Prompt: ${shouldRespondPrompt}`
+          );
+          const response = await runtime.useModel(ModelType13.TEXT_SMALL, {
+            prompt: shouldRespondPrompt
+          });
+          logger19.debug(
+            `[Bootstrap] Response evaluation for ${runtime.character.name}:
+${response}`
+          );
+          logger19.debug(`[Bootstrap] Response type: ${typeof response}`);
+          const responseObject = parseKeyValueXml(response);
+          logger19.debug("[Bootstrap] Parsed response:", responseObject);
+          shouldRespond = responseObject?.action && responseObject.action === "RESPOND";
+        } else {
+          logger19.debug(
+            `[Bootstrap] Skipping shouldRespond check for ${runtime.character.name} because ${room?.type} ${room?.source}`
+          );
+          shouldRespond = true;
+        }
+        let responseMessages = [];
+        console.log("shouldRespond is", shouldRespond);
+        console.log("shouldSkipShouldRespond", shouldSkipShouldRespond);
+        if (shouldRespond) {
+          state = await runtime.composeState(message, ["ACTIONS"]);
+          if (!state.values.actionNames) {
+            logger19.warn("actionNames data missing from state, even though it was requested");
+          }
+          const prompt = composePromptFromState9({
+            state,
+            template: runtime.character.templates?.messageHandlerTemplate || messageHandlerTemplate
+          });
+          let responseContent = null;
+          let retries = 0;
+          const maxRetries = 3;
+          while (retries < maxRetries && (!responseContent?.thought || !responseContent?.actions)) {
+            let response = await runtime.useModel(ModelType13.TEXT_LARGE, {
+              prompt
+            });
+            logger19.debug("[Bootstrap] *** Raw LLM Response ***\n", response);
+            const parsedXml = parseKeyValueXml(response);
+            logger19.debug("[Bootstrap] *** Parsed XML Content ***\n", parsedXml);
+            if (parsedXml) {
+              responseContent = {
+                ...parsedXml,
+                thought: parsedXml.thought || "",
+                actions: parsedXml.actions || ["IGNORE"],
+                providers: parsedXml.providers || [],
+                text: parsedXml.text || "",
+                simple: parsedXml.simple || false
+              };
+            } else {
+              responseContent = null;
+            }
+            retries++;
+            if (!responseContent?.thought || !responseContent?.actions) {
+              logger19.warn(
+                "[Bootstrap] *** Missing required fields (thought or actions), retrying... ***\n",
+                response,
+                parsedXml,
+                responseContent
+              );
+            }
+          }
+          const currentResponseId = agentResponses.get(message.roomId);
+          if (currentResponseId !== responseId) {
+            logger19.info(
+              `Response discarded - newer message being processed for agent: ${runtime.agentId}, room: ${message.roomId}`
+            );
+            return;
+          }
+          if (responseContent && message.id) {
+            responseContent.inReplyTo = createUniqueUuid4(runtime, message.id);
+            const isSimple = responseContent.actions?.length === 1 && responseContent.actions[0].toUpperCase() === "REPLY" && (!responseContent.providers || responseContent.providers.length === 0);
+            responseContent.simple = isSimple;
+            const responseMesssage = {
               id: asUUID(v4_default()),
               entityId: runtime.agentId,
               agentId: runtime.agentId,
               content: responseContent,
               roomId: message.roomId,
               createdAt: Date.now()
+            };
+            responseMessages = [responseMesssage];
+          }
+          agentResponses.delete(message.roomId);
+          if (agentResponses.size === 0) {
+            latestResponseIds.delete(runtime.agentId);
+          }
+          if (responseContent?.providers?.length && responseContent?.providers?.length > 0) {
+            state = await runtime.composeState(message, responseContent?.providers || []);
+          }
+          if (responseContent && responseContent.simple && responseContent.text) {
+            if (responseContent.providers && responseContent.providers.length > 0) {
+              logger19.debug("[Bootstrap] Simple response used providers", responseContent.providers);
             }
-          ];
-          callback(responseContent);
-        }
-        agentResponses.delete(message.roomId);
-        if (agentResponses.size === 0) {
-          latestResponseIds.delete(runtime.agentId);
+            await callback(responseContent);
+          } else {
+            await runtime.processActions(
+              message,
+              responseMessages,
+              state,
+              async (memory) => {
+                return [];
+              }
+            );
+            if (responseMessages.length) {
+              for (const responseMessage of responseMessages) {
+                if (responseMessage.content.providers && responseMessage.content.providers.length > 0) {
+                  logger19.debug(
+                    "[Bootstrap] Complex response used providers",
+                    responseMessage.content.providers
+                  );
+                }
+              }
+              for (const memory of responseMessages) {
+                await callback(memory.content);
+              }
+            }
+          }
+          await runtime.evaluate(
+            message,
+            state,
+            shouldRespond,
+            async (memory) => {
+              return [];
+            },
+            responseMessages
+          );
+        } else {
+          logger19.debug("[Bootstrap] Agent decided not to respond (shouldRespond is false).");
+          const currentResponseId = agentResponses.get(message.roomId);
+          if (currentResponseId !== responseId) {
+            logger19.info(
+              `Ignore response discarded - newer message being processed for agent: ${runtime.agentId}, room: ${message.roomId}`
+            );
+            return;
+          }
+          if (!message.id) {
+            logger19.error("[Bootstrap] Message ID is missing, cannot create ignore response.");
+            return;
+          }
+          const ignoreContent = {
+            thought: "Agent decided not to respond to this message.",
+            actions: ["IGNORE"],
+            simple: true,
+            // Treat it as simple for callback purposes
+            inReplyTo: createUniqueUuid4(runtime, message.id)
+            // Reference original message
+          };
+          await callback(ignoreContent);
+          const ignoreMemory = {
+            id: asUUID(v4_default()),
+            entityId: runtime.agentId,
+            agentId: runtime.agentId,
+            content: ignoreContent,
+            roomId: message.roomId,
+            createdAt: Date.now()
+          };
+          await runtime.createMemory(ignoreMemory, "messages");
+          logger19.debug("[Bootstrap] Saved ignore response to memory", {
+            memoryId: ignoreMemory.id
+          });
+          agentResponses.delete(message.roomId);
+          if (agentResponses.size === 0) {
+            latestResponseIds.delete(runtime.agentId);
+          }
         }
-        await runtime.processActions(message, responseMessages, state, callback);
+        await runtime.emitEvent(EventType2.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) {
+        console.error("error is", error);
+        await runtime.emitEvent(EventType2.RUN_ENDED, {
+          runtime,
+          runId,
+          messageId: message.id,
+          roomId: message.roomId,
+          entityId: message.entityId,
+          startTime,
+          status: "error",
+          endTime: Date.now(),
+          duration: Date.now() - startTime,
+          error: error.message,
+          source: "messageHandler"
+        });
       }
-      onComplete?.();
-      await runtime.evaluate(message, state, shouldRespond, callback, responseMessages);
-      await runtime.emitEvent(EventType2.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) {
-      onComplete?.();
-      await runtime.emitEvent(EventType2.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;
-    }
-  })();
-  try {
+    })();
     await Promise.race([processingPromise, timeoutPromise]);
   } finally {
     clearTimeout(timeoutId);
+    onComplete?.();
   }
 };
 var reactionReceivedHandler = async ({
@@ -5516,10 +6043,10 @@ var reactionReceivedHandler = async ({
     await runtime.createMemory(message, "messages");
   } catch (error) {
     if (error.code === "23505") {
-      logger16.warn("Duplicate reaction memory, skipping");
+      logger19.warn("[Bootstrap] Duplicate reaction memory, skipping");
       return;
     }
-    logger16.error("Error in reaction handler:", error);
+    logger19.error("[Bootstrap] Error in reaction handler:", error);
   }
 };
 var postGeneratedHandler = async ({
@@ -5530,7 +6057,7 @@ var postGeneratedHandler = async ({
   roomId,
   source
 }) => {
-  logger16.info("Generating new post...");
+  logger19.info("[Bootstrap] Generating new post...");
   await runtime.ensureWorldExists({
     id: worldId,
     name: `${runtime.character.name}'s Feed`,
@@ -5541,7 +6068,7 @@ var postGeneratedHandler = async ({
     id: roomId,
     name: `${runtime.character.name}'s Feed`,
     source,
-    type: ChannelType9.FEED,
+    type: ChannelType10.FEED,
     channelId: `${userId}-home`,
     serverId: userId,
     worldId
@@ -5551,30 +6078,116 @@ var postGeneratedHandler = async ({
     entityId: runtime.agentId,
     agentId: runtime.agentId,
     roomId,
-    content: {}
+    content: {},
+    metadata: {
+      entityName: runtime.character.name,
+      type: "message"
+    }
   };
-  const state = await runtime.composeState(message, null, [
+  let state = await runtime.composeState(message, [
+    "PROVIDERS",
     "CHARACTER",
     "RECENT_MESSAGES",
     "ENTITIES"
   ]);
+  const entity = await runtime.getEntityById(runtime.agentId);
+  if (entity?.metadata?.twitter?.userName) {
+    state.values.twitterUserName = entity?.metadata?.twitter?.userName;
+  }
+  const prompt = composePromptFromState9({
+    state,
+    template: runtime.character.templates?.messageHandlerTemplate || messageHandlerTemplate
+  });
+  let responseContent = null;
+  let retries = 0;
+  const maxRetries = 3;
+  while (retries < maxRetries && (!responseContent?.thought || !responseContent?.actions)) {
+    const response = await runtime.useModel(ModelType13.TEXT_SMALL, {
+      prompt
+    });
+    console.log("prompt is", prompt);
+    console.log("response is", response);
+    const parsedXml = parseKeyValueXml(response);
+    if (parsedXml) {
+      responseContent = {
+        thought: parsedXml.thought || "",
+        actions: parsedXml.actions || ["IGNORE"],
+        providers: parsedXml.providers || [],
+        text: parsedXml.text || "",
+        simple: parsedXml.simple || false
+      };
+    } else {
+      responseContent = null;
+    }
+    retries++;
+    if (!responseContent?.thought || !responseContent?.actions) {
+      logger19.warn(
+        "[Bootstrap] *** Missing required fields, retrying... ***\n",
+        response,
+        parsedXml,
+        responseContent
+      );
+    }
+  }
+  state = await runtime.composeState(message, responseContent?.providers);
   const postPrompt = composePromptFromState9({
     state,
     template: runtime.character.templates?.postCreationTemplate || postCreationTemplate
   });
-  const jsonResponse = await runtime.useModel(ModelType13.OBJECT_LARGE, {
-    prompt: postPrompt,
-    output: "no-schema"
+  const xmlResponseText = await runtime.useModel(ModelType13.TEXT_LARGE, {
+    prompt: postPrompt
   });
+  const parsedXmlResponse = parseKeyValueXml(xmlResponseText);
+  if (!parsedXmlResponse) {
+    logger19.error(
+      "[Bootstrap] Failed to parse XML response for post creation. Raw response:",
+      xmlResponseText
+    );
+    return;
+  }
   function cleanupPostText(text) {
     let cleanedText2 = text.replace(/^['"](.*)['"]$/, "$1");
     cleanedText2 = cleanedText2.replaceAll(/\\n/g, "\n\n");
+    cleanedText2 = cleanedText2.replace(/([^\n])\n([^\n])/g, "$1\n\n$2");
     if (cleanedText2.length > 280) {
       cleanedText2 = truncateToCompleteSentence(cleanedText2, 280);
     }
     return cleanedText2;
   }
-  const cleanedText = cleanupPostText(jsonResponse.post);
+  const cleanedText = cleanupPostText(parsedXmlResponse.post || "");
+  const RM = state.providerData?.find((pd) => pd.providerName === "RECENT_MESSAGES");
+  if (RM) {
+    for (const m of RM.data.recentMessages) {
+      if (cleanedText === m.content.text) {
+        logger19.log("[Bootstrap] Already recently posted that, retrying", cleanedText);
+        postGeneratedHandler({
+          runtime,
+          callback,
+          worldId,
+          userId,
+          roomId,
+          source
+        });
+        return;
+      }
+    }
+  }
+  const oaiRefusalRegex = /((i\s+do\s+not|i'm\s+not)\s+(feel\s+)?comfortable\s+generating\s+that\s+type\s+of\s+content)|(inappropriate|explicit|respectful|offensive|guidelines|aim\s+to\s+(be\s+)?helpful|communicate\s+respectfully)/i;
+  const anthropicRefusalRegex = /(i'?m\s+unable\s+to\s+help\s+with\s+that\s+request|due\s+to\s+safety\s+concerns|that\s+may\s+violate\s+(our\s+)?guidelines|provide\s+helpful\s+and\s+safe\s+responses|let'?s\s+try\s+a\s+different\s+direction|goes\s+against\s+(our\s+)?use\s+case\s+policies|ensure\s+safe\s+and\s+responsible\s+use)/i;
+  const googleRefusalRegex = /(i\s+can'?t\s+help\s+with\s+that|that\s+goes\s+against\s+(our\s+)?(policy|policies)|i'?m\s+still\s+learning|response\s+must\s+follow\s+(usage|safety)\s+policies|i'?ve\s+been\s+designed\s+to\s+avoid\s+that)/i;
+  const generalRefusalRegex = /(response\s+was\s+withheld|content\s+was\s+filtered|this\s+request\s+cannot\s+be\s+completed|violates\s+our\s+safety\s+policy|content\s+is\s+not\s+available)/i;
+  if (oaiRefusalRegex.test(cleanedText) || anthropicRefusalRegex.test(cleanedText) || googleRefusalRegex.test(cleanedText) || generalRefusalRegex.test(cleanedText)) {
+    logger19.log("[Bootstrap] Got prompt moderation refusal, retrying", cleanedText);
+    postGeneratedHandler({
+      runtime,
+      callback,
+      worldId,
+      userId,
+      roomId,
+      source
+    });
+    return;
+  }
   const responseMessages = [
     {
       id: v4_default(),
@@ -5583,8 +6196,8 @@ var postGeneratedHandler = async ({
       content: {
         text: cleanedText,
         source,
-        channelType: ChannelType9.FEED,
-        thought: jsonResponse.thought || "",
+        channelType: ChannelType10.FEED,
+        thought: parsedXmlResponse.thought || "",
         type: "post"
       },
       roomId: message.roomId,
@@ -5592,15 +6205,15 @@ var postGeneratedHandler = async ({
     }
   ];
   for (const message2 of responseMessages) {
-    await callback(message2.content);
+    await callback?.(message2.content);
   }
 };
 var syncSingleUser = async (entityId, runtime, serverId, channelId, type, source) => {
-  const entity = await runtime.getEntityById(entityId);
-  logger16.info(`Syncing user: ${entity.metadata[source].username || entity.id}`);
   try {
+    const entity = await runtime.getEntityById(entityId);
+    logger19.info(`[Bootstrap] Syncing user: ${entity?.metadata?.[source]?.username || entityId}`);
     if (!channelId) {
-      logger16.warn(`Cannot sync user ${entity.id} without a valid channelId`);
+      logger19.warn(`[Bootstrap] Cannot sync user ${entity?.id} without a valid channelId`);
       return;
     }
     const roomId = createUniqueUuid4(runtime, channelId);
@@ -5608,17 +6221,19 @@ var syncSingleUser = async (entityId, runtime, serverId, channelId, type, source
     await runtime.ensureConnection({
       entityId,
       roomId,
-      userName: entity.metadata[source].username || entity.id,
-      name: entity.metadata[source].name || entity.metadata[source].username || `User${entity.id}`,
+      userName: entity?.metadata?.[source].username || entityId,
+      name: entity?.metadata?.[source].name || entity?.metadata?.[source].username || `User${entityId}`,
       source,
       channelId,
       serverId,
       type,
       worldId
     });
-    logger16.success(`Successfully synced user: ${entity.id}`);
+    logger19.success(`[Bootstrap] Successfully synced user: ${entity?.id}`);
   } catch (error) {
-    logger16.error(`Error syncing user: ${error instanceof Error ? error.message : String(error)}`);
+    logger19.error(
+      `[Bootstrap] Error syncing user: ${error instanceof Error ? error.message : String(error)}`
+    );
   }
 };
 var handleServerSync = async ({
@@ -5629,7 +6244,7 @@ var handleServerSync = async ({
   source,
   onComplete
 }) => {
-  logger16.debug(`Handling server sync event for server: ${world.name}`);
+  logger19.debug(`[Bootstrap] Handling server sync event for server: ${world.name}`);
   try {
     await runtime.ensureWorldExists({
       id: world.id,
@@ -5658,14 +6273,22 @@ var handleServerSync = async ({
       for (let i2 = 0; i2 < entities.length; i2 += batchSize) {
         const entityBatch = entities.slice(i2, i2 + batchSize);
         const firstRoomUserIsIn = rooms.length > 0 ? rooms[0] : null;
+        if (!firstRoomUserIsIn) {
+          logger19.warn(`[Bootstrap] No rooms found for syncing users`);
+          continue;
+        }
         await Promise.all(
           entityBatch.map(async (entity) => {
             try {
+              if (!entity?.id) {
+                logger19.warn(`[Bootstrap] No entity ID found for syncing users`);
+                return;
+              }
               await runtime.ensureConnection({
                 entityId: entity.id,
                 roomId: firstRoomUserIsIn.id,
-                userName: entity.metadata[source].username,
-                name: entity.metadata[source].name,
+                userName: entity.metadata?.[source].username,
+                name: entity.metadata?.[source].name,
                 source,
                 channelId: firstRoomUserIsIn.channelId,
                 serverId: world.serverId,
@@ -5673,7 +6296,7 @@ var handleServerSync = async ({
                 worldId: world.id
               });
             } catch (err) {
-              logger16.warn(`Failed to sync user ${entity.metadata.username}: ${err}`);
+              logger19.warn(`[Bootstrap] Failed to sync user ${entity.metadata?.username}: ${err}`);
             }
           })
         );
@@ -5682,17 +6305,58 @@ var handleServerSync = async ({
         }
       }
     }
-    logger16.debug(`Successfully synced standardized world structure for ${world.name}`);
+    logger19.debug(`Successfully synced standardized world structure for ${world.name}`);
     onComplete?.();
   } catch (error) {
-    logger16.error(
+    logger19.error(
       `Error processing standardized server data: ${error instanceof Error ? error.message : String(error)}`
     );
   }
 };
+var controlMessageHandler = async ({
+  runtime,
+  message,
+  source
+}) => {
+  try {
+    logger19.debug(
+      `[controlMessageHandler] Processing control message: ${message.payload.action} for room ${message.roomId}`
+    );
+    const serviceNames = Array.from(runtime.getAllServices().keys());
+    const websocketServiceName = serviceNames.find(
+      (name) => name.toLowerCase().includes("websocket") || name.toLowerCase().includes("socket")
+    );
+    if (websocketServiceName) {
+      const websocketService = runtime.getService(websocketServiceName);
+      if (websocketService && "sendMessage" in websocketService) {
+        await websocketService.sendMessage({
+          type: "controlMessage",
+          payload: {
+            action: message.payload.action,
+            target: message.payload.target,
+            roomId: message.roomId
+          }
+        });
+        logger19.debug(
+          `[controlMessageHandler] Control message ${message.payload.action} sent successfully`
+        );
+      } else {
+        logger19.error("[controlMessageHandler] WebSocket service does not have sendMessage method");
+      }
+    } else {
+      logger19.error("[controlMessageHandler] No WebSocket service found to send control message");
+    }
+  } catch (error) {
+    logger19.error(`[controlMessageHandler] Error processing control message: ${error}`);
+  }
+};
 var events = {
   [EventType2.MESSAGE_RECEIVED]: [
     async (payload) => {
+      if (!payload.callback) {
+        logger19.error("No callback provided for message");
+        return;
+      }
       await messageReceivedHandler({
         runtime: payload.runtime,
         message: payload.message,
@@ -5703,10 +6367,15 @@ var events = {
   ],
   [EventType2.VOICE_MESSAGE_RECEIVED]: [
     async (payload) => {
+      if (!payload.callback) {
+        logger19.error("No callback provided for voice message");
+        return;
+      }
       await messageReceivedHandler({
         runtime: payload.runtime,
         message: payload.message,
-        callback: payload.callback
+        callback: payload.callback,
+        onComplete: payload.onComplete
       });
     }
   ],
@@ -5725,7 +6394,7 @@ var events = {
   ],
   [EventType2.MESSAGE_SENT]: [
     async (payload) => {
-      logger16.debug(`Message sent: ${payload.message.content.text}`);
+      logger19.debug(`[Bootstrap] Message sent: ${payload.message.content.text}`);
     }
   ],
   [EventType2.WORLD_JOINED]: [
@@ -5740,6 +6409,18 @@ var events = {
   ],
   [EventType2.ENTITY_JOINED]: [
     async (payload) => {
+      if (!payload.worldId) {
+        logger19.error("[Bootstrap] No callback provided for entity joined");
+        return;
+      }
+      if (!payload.roomId) {
+        logger19.error("[Bootstrap] No roomId provided for entity joined");
+        return;
+      }
+      if (!payload.metadata?.type) {
+        logger19.error("[Bootstrap] No type provided for entity joined");
+        return;
+      }
       await syncSingleUser(
         payload.entityId,
         payload.runtime,
@@ -5762,34 +6443,39 @@ var events = {
           };
           await payload.runtime.updateEntity(entity);
         }
-        logger16.info(`User ${payload.entityId} left world ${payload.worldId}`);
+        logger19.info(`[Bootstrap] User ${payload.entityId} left world ${payload.worldId}`);
       } catch (error) {
-        logger16.error(`Error handling user left: ${error.message}`);
+        logger19.error(`[Bootstrap] Error handling user left: ${error.message}`);
       }
     }
   ],
   [EventType2.ACTION_STARTED]: [
     async (payload) => {
-      logger16.debug(`Action started: ${payload.actionName} (${payload.actionId})`);
+      logger19.debug(`[Bootstrap] Action started: ${payload.actionName} (${payload.actionId})`);
     }
   ],
   [EventType2.ACTION_COMPLETED]: [
     async (payload) => {
       const status = payload.error ? `failed: ${payload.error.message}` : "completed";
-      logger16.debug(`Action ${status}: ${payload.actionName} (${payload.actionId})`);
+      logger19.debug(`[Bootstrap] Action ${status}: ${payload.actionName} (${payload.actionId})`);
     }
   ],
   [EventType2.EVALUATOR_STARTED]: [
     async (payload) => {
-      logger16.debug(`Evaluator started: ${payload.evaluatorName} (${payload.evaluatorId})`);
+      logger19.debug(
+        `[Bootstrap] Evaluator started: ${payload.evaluatorName} (${payload.evaluatorId})`
+      );
     }
   ],
   [EventType2.EVALUATOR_COMPLETED]: [
     async (payload) => {
       const status = payload.error ? `failed: ${payload.error.message}` : "completed";
-      logger16.debug(`Evaluator ${status}: ${payload.evaluatorName} (${payload.evaluatorId})`);
+      logger19.debug(
+        `[Bootstrap] Evaluator ${status}: ${payload.evaluatorName} (${payload.evaluatorId})`
+      );
     }
-  ]
+  ],
+  CONTROL_MESSAGE: [controlMessageHandler]
 };
 var bootstrapPlugin = {
   name: "bootstrap",
@@ -5805,15 +6491,15 @@ var bootstrapPlugin = {
     sendMessageAction,
     updateEntityAction,
     choiceAction,
-    roles_default,
-    settings_default
+    updateRoleAction,
+    updateSettingsAction
   ],
+  // this is jank, these events are not valid
   events,
   evaluators: [reflectionEvaluator],
   providers: [
     evaluatorsProvider,
     anxietyProvider,
-    knowledgeProvider,
     timeProvider,
     entitiesProvider,
     relationshipsProvider,
@@ -5826,14 +6512,46 @@ var bootstrapPlugin = {
     providersProvider,
     actionsProvider,
     characterProvider,
-    recentMessagesProvider
+    recentMessagesProvider,
+    worldProvider
   ],
   services: [TaskService, ScenarioService]
 };
 var index_default = bootstrapPlugin;
 export {
+  actionsProvider,
+  anxietyProvider,
+  attachmentsProvider,
   bootstrapPlugin,
+  capabilitiesProvider,
+  characterProvider,
+  choiceAction,
+  choiceProvider,
   index_default as default,
-  fetchMediaData
+  entitiesProvider,
+  evaluatorsProvider,
+  factsProvider,
+  fetchMediaData,
+  followRoomAction,
+  ignoreAction,
+  muteRoomAction,
+  noneAction,
+  processAttachments,
+  providersProvider,
+  recentMessagesProvider,
+  reflectionEvaluator,
+  relationshipsProvider,
+  replyAction,
+  roleProvider,
+  sendMessageAction,
+  settingsProvider,
+  shouldBypassShouldRespond,
+  timeProvider,
+  unfollowRoomAction,
+  unmuteRoomAction,
+  updateEntityAction,
+  updateRoleAction,
+  updateSettingsAction,
+  worldProvider
 };
 //# sourceMappingURL=index.js.map