@elizaos/plugin-bootstrap 1.2.0 → 1.2.1

package/dist/index.js

@@ -3768,7 +3768,7 @@ import {
   createUniqueUuid as createUniqueUuid3,
   EventType,
   imageDescriptionTemplate,
-  logger as logger18,
+  logger as logger20,
   messageHandlerTemplate,
   ModelType as ModelType14,
   parseKeyValueXml,
@@ -4036,11 +4036,33 @@ var choiceAction = {
       tags: ["AWAITING_CHOICE"]
     });
     if (!pendingTasks?.length) {
-      throw new Error("No pending tasks with options found");
+      return {
+        text: "No pending tasks with options found",
+        values: {
+          success: false,
+          error: "NO_PENDING_TASKS"
+        },
+        data: {
+          actionName: "CHOOSE_OPTION",
+          error: "No pending tasks with options found"
+        },
+        success: false
+      };
     }
     const tasksWithOptions = pendingTasks.filter((task) => task.metadata?.options);
     if (!tasksWithOptions.length) {
-      throw new Error("No tasks currently have options to select from.");
+      return {
+        text: "No tasks currently have options to select from",
+        values: {
+          success: false,
+          error: "NO_OPTIONS_AVAILABLE"
+        },
+        data: {
+          actionName: "CHOOSE_OPTION",
+          error: "No tasks currently have options to select from"
+        },
+        success: false
+      };
     }
     const formattedTasks = tasksWithOptions.map((task) => {
       const shortId = task.id?.substring(0, 8);
@@ -4081,7 +4103,20 @@ ${task.options?.map((opt) => `- ${opt.name}: ${opt.description}`).join("\n")}`;
           actions: ["SELECT_OPTION_ERROR"],
           source: message.content.source
         });
-        return;
+        return {
+          text: `Could not find task with ID: ${taskId}`,
+          values: {
+            success: false,
+            error: "TASK_NOT_FOUND",
+            taskId
+          },
+          data: {
+            actionName: "CHOOSE_OPTION",
+            error: "Task not found",
+            taskId
+          },
+          success: false
+        };
       }
       const selectedTask = tasksWithOptions.find((task) => task.id === taskInfo.fullId);
       if (!selectedTask) {
@@ -4090,7 +4125,18 @@ ${task.options?.map((opt) => `- ${opt.name}: ${opt.description}`).join("\n")}`;
           actions: ["SELECT_OPTION_ERROR"],
           source: message.content.source
         });
-        return;
+        return {
+          text: "Error locating the selected task",
+          values: {
+            success: false,
+            error: "TASK_LOOKUP_ERROR"
+          },
+          data: {
+            actionName: "CHOOSE_OPTION",
+            error: "Failed to locate task"
+          },
+          success: false
+        };
       }
       if (selectedOption === "ABORT") {
         if (!selectedTask?.id) {
@@ -4099,7 +4145,18 @@ ${task.options?.map((opt) => `- ${opt.name}: ${opt.description}`).join("\n")}`;
             actions: ["SELECT_OPTION_ERROR"],
             source: message.content.source
           });
-          return;
+          return {
+            text: "Error aborting task",
+            values: {
+              success: false,
+              error: "ABORT_ERROR"
+            },
+            data: {
+              actionName: "CHOOSE_OPTION",
+              error: "Could not abort task"
+            },
+            success: false
+          };
         }
         await runtime.deleteTask(selectedTask.id);
         await callback?.({
@@ -4107,7 +4164,22 @@ ${task.options?.map((opt) => `- ${opt.name}: ${opt.description}`).join("\n")}`;
           actions: ["CHOOSE_OPTION_CANCELLED"],
           source: message.content.source
         });
-        return;
+        return {
+          text: `Task "${selectedTask.name}" has been cancelled`,
+          values: {
+            success: true,
+            taskAborted: true,
+            taskId: selectedTask.id,
+            taskName: selectedTask.name
+          },
+          data: {
+            actionName: "CHOOSE_OPTION",
+            selectedOption: "ABORT",
+            taskId: selectedTask.id,
+            taskName: selectedTask.name
+          },
+          success: true
+        };
       }
       try {
         const taskWorker = runtime.getTaskWorker(selectedTask.name);
@@ -4117,7 +4189,23 @@ ${task.options?.map((opt) => `- ${opt.name}: ${opt.description}`).join("\n")}`;
           actions: ["CHOOSE_OPTION"],
           source: message.content.source
         });
-        return;
+        return {
+          text: `Selected option: ${selectedOption} for task: ${selectedTask.name}`,
+          values: {
+            success: true,
+            selectedOption,
+            taskId: selectedTask.id,
+            taskName: selectedTask.name,
+            taskExecuted: true
+          },
+          data: {
+            actionName: "CHOOSE_OPTION",
+            selectedOption,
+            taskId: selectedTask.id,
+            taskName: selectedTask.name
+          },
+          success: true
+        };
       } catch (error) {
         logger.error("Error executing task with option:", error);
         await callback?.({
@@ -4125,7 +4213,21 @@ ${task.options?.map((opt) => `- ${opt.name}: ${opt.description}`).join("\n")}`;
           actions: ["SELECT_OPTION_ERROR"],
           source: message.content.source
         });
-        return;
+        return {
+          text: "Error processing selection",
+          values: {
+            success: false,
+            error: "EXECUTION_ERROR"
+          },
+          data: {
+            actionName: "CHOOSE_OPTION",
+            error: error instanceof Error ? error.message : String(error),
+            taskId: selectedTask.id,
+            selectedOption
+          },
+          success: false,
+          error: error instanceof Error ? error : new Error(String(error))
+        };
       }
     }
     let optionsText = "Please select a valid option from one of these tasks:\n\n";
@@ -4145,6 +4247,20 @@ ${task.options?.map((opt) => `- ${opt.name}: ${opt.description}`).join("\n")}`;
       actions: ["SELECT_OPTION_INVALID"],
       source: message.content.source
     });
+    return {
+      text: "No valid option selected",
+      values: {
+        success: false,
+        error: "NO_SELECTION",
+        availableTasks: tasksWithOptions.length
+      },
+      data: {
+        actionName: "CHOOSE_OPTION",
+        error: "No valid selection made",
+        availableTasks: formattedTasks
+      },
+      success: false
+    };
   },
   examples: [
     [
@@ -4215,7 +4331,19 @@ var followRoomAction = {
   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");
+      return {
+        text: "State is required for follow room action",
+        values: {
+          success: false,
+          error: "STATE_REQUIRED"
+        },
+        data: {
+          actionName: "FOLLOW_ROOM",
+          error: "State is required"
+        },
+        success: false,
+        error: new Error("State is required for followRoomAction")
+      };
     }
     async function _shouldFollow(state2) {
       const shouldFollowPrompt = composePromptFromState2({
@@ -4270,22 +4398,77 @@ var followRoomAction = {
       logger2.warn(`Unclear boolean response: ${response}, defaulting to false`);
       return false;
     }
-    if (await _shouldFollow(state)) {
-      await runtime.setParticipantUserState(message.roomId, runtime.agentId, "FOLLOWED");
-    }
+    const shouldFollow = await _shouldFollow(state);
     const room = state.data.room ?? await runtime.getRoom(message.roomId);
-    await runtime.createMemory(
-      {
-        entityId: message.entityId,
-        agentId: message.agentId,
-        roomId: message.roomId,
-        content: {
-          thought: `I followed the room ${room.name}`,
-          actions: ["FOLLOW_ROOM_START"]
-        }
-      },
-      "messages"
-    );
+    if (shouldFollow) {
+      try {
+        await runtime.setParticipantUserState(message.roomId, runtime.agentId, "FOLLOWED");
+        await runtime.createMemory(
+          {
+            entityId: message.entityId,
+            agentId: message.agentId,
+            roomId: message.roomId,
+            content: {
+              thought: `I followed the room ${room.name}`,
+              actions: ["FOLLOW_ROOM_START"]
+            }
+          },
+          "messages"
+        );
+        return {
+          text: `Now following room: ${room.name}`,
+          values: {
+            success: true,
+            roomFollowed: true,
+            roomId: message.roomId,
+            roomName: room.name,
+            newState: "FOLLOWED"
+          },
+          data: {
+            actionName: "FOLLOW_ROOM",
+            roomId: message.roomId,
+            roomName: room.name,
+            followed: true
+          },
+          success: true
+        };
+      } catch (error) {
+        logger2.error("Error following room:", error);
+        return {
+          text: "Failed to follow room",
+          values: {
+            success: false,
+            error: "FOLLOW_FAILED"
+          },
+          data: {
+            actionName: "FOLLOW_ROOM",
+            error: error instanceof Error ? error.message : String(error),
+            roomId: message.roomId
+          },
+          success: false,
+          error: error instanceof Error ? error : new Error(String(error))
+        };
+      }
+    } else {
+      return {
+        text: `Decided not to follow room: ${room.name}`,
+        values: {
+          success: true,
+          roomFollowed: false,
+          roomId: message.roomId,
+          roomName: room.name,
+          reason: "NOT_APPROPRIATE"
+        },
+        data: {
+          actionName: "FOLLOW_ROOM",
+          roomId: message.roomId,
+          roomName: room.name,
+          followed: false,
+          reason: "Decision criteria not met"
+        },
+        success: true
+      };
+    }
   },
   examples: [
     [
@@ -4574,7 +4757,6 @@ var ignoreAction = {
     if (callback && responses?.[0]?.content) {
       await callback(responses[0].content);
     }
-    return true;
   },
   examples: [
     [
@@ -4815,7 +4997,19 @@ var muteRoomAction = {
   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");
+      return {
+        text: "State is required for mute room action",
+        values: {
+          success: false,
+          error: "STATE_REQUIRED"
+        },
+        data: {
+          actionName: "MUTE_ROOM",
+          error: "State is required"
+        },
+        success: false,
+        error: new Error("State is required for muting a room")
+      };
     }
     async function _shouldMute(state2) {
       const shouldMutePrompt = composePromptFromState3({
@@ -4869,22 +5063,77 @@ var muteRoomAction = {
       logger3.warn(`Unclear boolean response: ${response}, defaulting to false`);
       return false;
     }
-    if (await _shouldMute(state)) {
-      await runtime.setParticipantUserState(message.roomId, runtime.agentId, "MUTED");
-    }
+    const shouldMute = await _shouldMute(state);
     const room = state.data.room ?? await runtime.getRoom(message.roomId);
-    await runtime.createMemory(
-      {
-        entityId: message.entityId,
-        agentId: message.agentId,
-        roomId: message.roomId,
-        content: {
-          thought: `I muted the room ${room.name}`,
-          actions: ["MUTE_ROOM_START"]
-        }
-      },
-      "messages"
-    );
+    if (shouldMute) {
+      try {
+        await runtime.setParticipantUserState(message.roomId, runtime.agentId, "MUTED");
+        await runtime.createMemory(
+          {
+            entityId: message.entityId,
+            agentId: message.agentId,
+            roomId: message.roomId,
+            content: {
+              thought: `I muted the room ${room.name}`,
+              actions: ["MUTE_ROOM_START"]
+            }
+          },
+          "messages"
+        );
+        return {
+          text: `Room muted: ${room.name}`,
+          values: {
+            success: true,
+            roomMuted: true,
+            roomId: message.roomId,
+            roomName: room.name,
+            newState: "MUTED"
+          },
+          data: {
+            actionName: "MUTE_ROOM",
+            roomId: message.roomId,
+            roomName: room.name,
+            muted: true
+          },
+          success: true
+        };
+      } catch (error) {
+        logger3.error("Error muting room:", error);
+        return {
+          text: "Failed to mute room",
+          values: {
+            success: false,
+            error: "MUTE_FAILED"
+          },
+          data: {
+            actionName: "MUTE_ROOM",
+            error: error instanceof Error ? error.message : String(error),
+            roomId: message.roomId
+          },
+          success: false,
+          error: error instanceof Error ? error : new Error(String(error))
+        };
+      }
+    } else {
+      return {
+        text: `Decided not to mute room: ${room.name}`,
+        values: {
+          success: true,
+          roomMuted: false,
+          roomId: message.roomId,
+          roomName: room.name,
+          reason: "NOT_APPROPRIATE"
+        },
+        data: {
+          actionName: "MUTE_ROOM",
+          roomId: message.roomId,
+          roomName: room.name,
+          muted: false,
+          reason: "Decision criteria not met"
+        },
+        success: true
+      };
+    }
   },
   examples: [
     [
@@ -5006,7 +5255,18 @@ var noneAction = {
   },
   description: "Respond but perform no additional action. This is the default if the agent is speaking and not doing anything additional.",
   handler: async (_runtime, _message) => {
-    return true;
+    return {
+      text: "No additional action taken",
+      values: {
+        success: true,
+        actionType: "NONE"
+      },
+      data: {
+        actionName: "NONE",
+        description: "Response without additional action"
+      },
+      success: true
+    };
   },
   examples: [
     [
@@ -5131,14 +5391,23 @@ var noneAction = {
 // src/actions/reply.ts
 import {
   composePromptFromState as composePromptFromState4,
-  ModelType as ModelType5
+  ModelType as ModelType5,
+  logger as logger4
 } from "@elizaos/core";
 var replyTemplate = `# Task: Generate dialog for the character {{agentName}}.
+
 {{providers}}
+
 # Instructions: Write the next message for {{agentName}}.
 "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.
 
+IMPORTANT CODE BLOCK FORMATTING RULES:
+- If {{agentName}} includes code examples, snippets, or multi-line code in the response, ALWAYS wrap the code with \`\`\` fenced code blocks (specify the language if known, e.g., \`\`\`python).
+- ONLY use fenced code blocks for actual code. Do NOT wrap non-code text, instructions, or single words in fenced code blocks.
+- If including inline code (short single words or function names), use single backticks (\`) as appropriate.
+- This ensures the user sees clearly formatted and copyable code when relevant.
+
 Response format should be formatted in a valid JSON block like this:
 \`\`\`json
 {
@@ -5156,22 +5425,65 @@ var replyAction = {
     return true;
   },
   handler: async (runtime, message, state, _options, callback, responses) => {
+    const context = _options?.context;
+    const previousResults = context?.previousResults || [];
+    if (previousResults.length > 0) {
+      logger4.debug(`[REPLY] Found ${previousResults.length} previous action results`);
+    }
     const allProviders = responses?.flatMap((res) => res.content?.providers ?? []) ?? [];
-    state = await runtime.composeState(message, [...allProviders ?? [], "RECENT_MESSAGES"]);
+    state = await runtime.composeState(message, [
+      ...allProviders ?? [],
+      "RECENT_MESSAGES",
+      "ACTION_STATE"
+    ]);
     const prompt = composePromptFromState4({
       state,
       template: replyTemplate
     });
-    const response = await runtime.useModel(ModelType5.OBJECT_LARGE, {
-      prompt
-    });
-    const responseContent = {
-      thought: response.thought,
-      text: response.message || "",
-      actions: ["REPLY"]
-    };
-    await callback(responseContent);
-    return true;
+    try {
+      const response = await runtime.useModel(ModelType5.OBJECT_LARGE, {
+        prompt
+      });
+      const responseContent = {
+        thought: response.thought,
+        text: response.message || "",
+        actions: ["REPLY"]
+      };
+      await callback(responseContent);
+      return {
+        text: `Generated reply: ${responseContent.text}`,
+        values: {
+          success: true,
+          responded: true,
+          lastReply: responseContent.text,
+          lastReplyTime: Date.now(),
+          thoughtProcess: response.thought
+        },
+        data: {
+          actionName: "REPLY",
+          response: responseContent,
+          thought: response.thought,
+          messageGenerated: true
+        },
+        success: true
+      };
+    } catch (error) {
+      logger4.error(`[REPLY] Error generating response: ${error}`);
+      return {
+        text: "Error generating reply",
+        values: {
+          success: false,
+          responded: false,
+          error: true
+        },
+        data: {
+          actionName: "REPLY",
+          error: error instanceof Error ? error.message : String(error)
+        },
+        success: false,
+        error: error instanceof Error ? error : new Error(String(error))
+      };
+    }
   },
   examples: [
     [
@@ -5242,7 +5554,7 @@ var import_dedent = __toESM(require_dedent(), 1);
 import {
   ChannelType,
   composePrompt as composePrompt2,
-  logger as logger4,
+  logger as logger5,
   ModelType as ModelType6,
   Role
 } from "@elizaos/core";
@@ -5276,8 +5588,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");
+      logger5.error("State is required for role assignment");
+      return {
+        text: "State is required for role assignment",
+        values: {
+          success: false,
+          error: "STATE_REQUIRED"
+        },
+        data: {
+          actionName: "UPDATE_ROLE",
+          error: "State is required"
+        },
+        success: false,
+        error: new Error("State is required for role assignment")
+      };
     }
     const { roomId } = message;
     const serverId = message.content.serverId;
@@ -5287,11 +5611,22 @@ var updateRoleAction = {
       world = await runtime.getWorld(worldId);
     }
     if (!world) {
-      logger4.error("World not found");
+      logger5.error("World not found");
       await callback?.({
         text: "I couldn't find the world. This action only works in a world."
       });
-      return;
+      return {
+        text: "World not found",
+        values: {
+          success: false,
+          error: "WORLD_NOT_FOUND"
+        },
+        data: {
+          actionName: "UPDATE_ROLE",
+          error: "World not found"
+        },
+        success: false
+      };
     }
     if (!world.metadata?.roles) {
       world.metadata = world.metadata || {};
@@ -5363,13 +5698,31 @@ var updateRoleAction = {
         actions: ["UPDATE_ROLE"],
         source: "discord"
       });
-      return;
+      return {
+        text: "No valid role assignments found",
+        values: {
+          success: false,
+          error: "NO_ASSIGNMENTS"
+        },
+        data: {
+          actionName: "UPDATE_ROLE",
+          error: "No valid role assignments found in the request"
+        },
+        success: false
+      };
     }
     let worldUpdated = false;
+    const successfulUpdates = [];
+    const failedUpdates = [];
     for (const assignment of result) {
       let targetEntity = entities.find((e2) => e2.id === assignment.entityId);
       if (!targetEntity) {
-        logger4.error("Could not find an ID ot assign to");
+        logger5.error("Could not find an ID to assign to");
+        failedUpdates.push({
+          entityId: assignment.entityId,
+          reason: "Entity not found"
+        });
+        continue;
       }
       const currentRole = world.metadata.roles[assignment.entityId];
       if (!canModifyRole(requesterRole, currentRole, assignment.newRole)) {
@@ -5378,10 +5731,19 @@ var updateRoleAction = {
           actions: ["UPDATE_ROLE"],
           source: "discord"
         });
+        failedUpdates.push({
+          entityId: assignment.entityId,
+          reason: "Insufficient permissions"
+        });
         continue;
       }
       world.metadata.roles[assignment.entityId] = assignment.newRole;
       worldUpdated = true;
+      successfulUpdates.push({
+        entityId: assignment.entityId,
+        entityName: targetEntity?.names[0] || "Unknown",
+        newRole: assignment.newRole
+      });
       await callback?.({
         text: `Updated ${targetEntity?.names[0]}'s role to ${assignment.newRole}.`,
         actions: ["UPDATE_ROLE"],
@@ -5389,9 +5751,45 @@ var updateRoleAction = {
       });
     }
     if (worldUpdated) {
-      await runtime.updateWorld(world);
-      logger4.info(`Updated roles in world metadata for server ${serverId}`);
+      try {
+        await runtime.updateWorld(world);
+        logger5.info(`Updated roles in world metadata for server ${serverId}`);
+      } catch (error) {
+        logger5.error("Failed to save world updates:", error);
+        return {
+          text: "Failed to save role updates",
+          values: {
+            success: false,
+            error: "SAVE_FAILED"
+          },
+          data: {
+            actionName: "UPDATE_ROLE",
+            error: error instanceof Error ? error.message : String(error),
+            attemptedUpdates: successfulUpdates
+          },
+          success: false,
+          error: error instanceof Error ? error : new Error(String(error))
+        };
+      }
     }
+    return {
+      text: `Role updates completed: ${successfulUpdates.length} successful, ${failedUpdates.length} failed`,
+      values: {
+        success: true,
+        successfulUpdates: successfulUpdates.length,
+        failedUpdates: failedUpdates.length,
+        updates: successfulUpdates,
+        failures: failedUpdates
+      },
+      data: {
+        actionName: "UPDATE_ROLE",
+        successfulUpdates,
+        failedUpdates,
+        worldId: world.id,
+        serverId
+      },
+      success: true
+    };
   },
   examples: [
     [
@@ -5449,7 +5847,7 @@ var updateRoleAction = {
 import {
   composePromptFromState as composePromptFromState5,
   findEntityByName,
-  logger as logger5,
+  logger as logger6,
   ModelType as ModelType7,
   parseJSONObjectFromText as parseJSONObjectFromText2
 } from "@elizaos/core";
@@ -5513,16 +5911,52 @@ 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");
+        logger6.error("State is required for sendMessage action");
+        return {
+          text: "State is required for sendMessage action",
+          values: {
+            success: false,
+            error: "STATE_REQUIRED"
+          },
+          data: {
+            actionName: "SEND_MESSAGE",
+            error: "State is required"
+          },
+          success: false,
+          error: 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");
+        logger6.error("Callback is required for sendMessage action");
+        return {
+          text: "Callback is required for sendMessage action",
+          values: {
+            success: false,
+            error: "CALLBACK_REQUIRED"
+          },
+          data: {
+            actionName: "SEND_MESSAGE",
+            error: "Callback is required"
+          },
+          success: false,
+          error: 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");
+        logger6.error("Responses are required for sendMessage action");
+        return {
+          text: "Responses are required for sendMessage action",
+          values: {
+            success: false,
+            error: "RESPONSES_REQUIRED"
+          },
+          data: {
+            actionName: "SEND_MESSAGE",
+            error: "Responses are required"
+          },
+          success: false,
+          error: new Error("Responses are required for sendMessage action")
+        };
       }
       for (const response of responses) {
         await callback(response.content);
@@ -5545,7 +5979,18 @@ var sendMessageAction = {
           actions: ["SEND_MESSAGE_ERROR"],
           source: message.content.source
         });
-        return;
+        return {
+          text: "Could not determine message target",
+          values: {
+            success: false,
+            error: "TARGET_UNCLEAR"
+          },
+          data: {
+            actionName: "SEND_MESSAGE",
+            error: "Could not parse target information from message"
+          },
+          success: false
+        };
       }
       const source = targetData.source.toLowerCase();
       if (targetData.targetType === "user") {
@@ -5556,7 +6001,21 @@ var sendMessageAction = {
             actions: ["SEND_MESSAGE_ERROR"],
             source: message.content.source
           });
-          return;
+          return {
+            text: "Target user not found",
+            values: {
+              success: false,
+              error: "USER_NOT_FOUND",
+              targetType: "user"
+            },
+            data: {
+              actionName: "SEND_MESSAGE",
+              error: "Could not find target user",
+              targetType: "user",
+              source
+            },
+            success: false
+          };
         }
         const userComponent = await runtime.getComponent(
           targetEntity.id,
@@ -5570,7 +6029,23 @@ var sendMessageAction = {
             actions: ["SEND_MESSAGE_ERROR"],
             source: message.content.source
           });
-          return;
+          return {
+            text: `No ${source} information found for user`,
+            values: {
+              success: false,
+              error: "COMPONENT_NOT_FOUND",
+              targetType: "user",
+              source
+            },
+            data: {
+              actionName: "SEND_MESSAGE",
+              error: `No ${source} component found for target user`,
+              targetType: "user",
+              targetEntityId: targetEntity.id,
+              source
+            },
+            success: false
+          };
         }
         const sendDirectMessage = runtime.getService(source)?.sendDirectMessage;
         if (!sendDirectMessage) {
@@ -5579,7 +6054,22 @@ var sendMessageAction = {
             actions: ["SEND_MESSAGE_ERROR"],
             source: message.content.source
           });
-          return;
+          return {
+            text: "Message service not available",
+            values: {
+              success: false,
+              error: "SERVICE_NOT_FOUND",
+              targetType: "user",
+              source
+            },
+            data: {
+              actionName: "SEND_MESSAGE",
+              error: `No sendDirectMessage service found for ${source}`,
+              targetType: "user",
+              source
+            },
+            success: false
+          };
         }
         try {
           await sendDirectMessage(runtime, targetEntity.id, source, message.content.text, worldId);
@@ -5588,13 +6078,51 @@ var sendMessageAction = {
             actions: ["SEND_MESSAGE"],
             source: message.content.source
           });
+          return {
+            text: `Message sent to ${targetEntity.names[0]}`,
+            values: {
+              success: true,
+              targetType: "user",
+              targetId: targetEntity.id,
+              targetName: targetEntity.names[0],
+              source,
+              messageSent: true
+            },
+            data: {
+              actionName: "SEND_MESSAGE",
+              targetType: "user",
+              targetId: targetEntity.id,
+              targetName: targetEntity.names[0],
+              source,
+              messageContent: message.content.text
+            },
+            success: true
+          };
         } catch (error) {
-          logger5.error(`Failed to send direct message: ${error.message}`);
+          logger6.error(`Failed to send direct message: ${error.message}`);
           await callback({
             text: "I encountered an error trying to send the message. Please try again.",
             actions: ["SEND_MESSAGE_ERROR"],
             source: message.content.source
           });
+          return {
+            text: "Failed to send direct message",
+            values: {
+              success: false,
+              error: "SEND_FAILED",
+              targetType: "user",
+              source
+            },
+            data: {
+              actionName: "SEND_MESSAGE",
+              error: error.message,
+              targetType: "user",
+              targetId: targetEntity.id,
+              source
+            },
+            success: false,
+            error: error instanceof Error ? error : new Error(String(error))
+          };
         }
       } else if (targetData.targetType === "room") {
         const rooms = await runtime.getRooms(worldId);
@@ -5607,7 +6135,23 @@ var sendMessageAction = {
             actions: ["SEND_MESSAGE_ERROR"],
             source: message.content.source
           });
-          return;
+          return {
+            text: "Target room not found",
+            values: {
+              success: false,
+              error: "ROOM_NOT_FOUND",
+              targetType: "room",
+              roomName: targetData.identifiers.roomName
+            },
+            data: {
+              actionName: "SEND_MESSAGE",
+              error: "Could not find target room",
+              targetType: "room",
+              roomName: targetData.identifiers.roomName,
+              source
+            },
+            success: false
+          };
         }
         const sendRoomMessage = runtime.getService(source)?.sendRoomMessage;
         if (!sendRoomMessage) {
@@ -5616,7 +6160,22 @@ var sendMessageAction = {
             actions: ["SEND_MESSAGE_ERROR"],
             source: message.content.source
           });
-          return;
+          return {
+            text: "Room message service not available",
+            values: {
+              success: false,
+              error: "SERVICE_NOT_FOUND",
+              targetType: "room",
+              source
+            },
+            data: {
+              actionName: "SEND_MESSAGE",
+              error: `No sendRoomMessage service found for ${source}`,
+              targetType: "room",
+              source
+            },
+            success: false
+          };
         }
         try {
           await sendRoomMessage(runtime, targetRoom.id, source, message.content.text, worldId);
@@ -5625,22 +6184,86 @@ var sendMessageAction = {
             actions: ["SEND_MESSAGE"],
             source: message.content.source
           });
+          return {
+            text: `Message sent to ${targetRoom.name}`,
+            values: {
+              success: true,
+              targetType: "room",
+              targetId: targetRoom.id,
+              targetName: targetRoom.name,
+              source,
+              messageSent: true
+            },
+            data: {
+              actionName: "SEND_MESSAGE",
+              targetType: "room",
+              targetId: targetRoom.id,
+              targetName: targetRoom.name,
+              source,
+              messageContent: message.content.text
+            },
+            success: true
+          };
         } catch (error) {
-          logger5.error(`Failed to send room message: ${error.message}`);
+          logger6.error(`Failed to send room message: ${error.message}`);
           await callback({
             text: "I encountered an error trying to send the message to the room. Please try again.",
             actions: ["SEND_MESSAGE_ERROR"],
             source: message.content.source
           });
+          return {
+            text: "Failed to send room message",
+            values: {
+              success: false,
+              error: "SEND_FAILED",
+              targetType: "room",
+              source
+            },
+            data: {
+              actionName: "SEND_MESSAGE",
+              error: error.message,
+              targetType: "room",
+              targetId: targetRoom.id,
+              targetName: targetRoom.name,
+              source
+            },
+            success: false,
+            error: error instanceof Error ? error : new Error(String(error))
+          };
         }
       }
+      return {
+        text: "Unknown target type",
+        values: {
+          success: false,
+          error: "UNKNOWN_TARGET_TYPE"
+        },
+        data: {
+          actionName: "SEND_MESSAGE",
+          error: "Unknown target type: " + targetData.targetType
+        },
+        success: false
+      };
     } catch (error) {
-      logger5.error(`Error in sendMessage handler: ${error}`);
+      logger6.error(`Error in sendMessage handler: ${error}`);
       await callback?.({
         text: "There was an error processing your message request.",
         actions: ["SEND_MESSAGE_ERROR"],
         source: message.content.source
       });
+      return {
+        text: "Error processing message request",
+        values: {
+          success: false,
+          error: "HANDLER_ERROR"
+        },
+        data: {
+          actionName: "SEND_MESSAGE",
+          error: error instanceof Error ? error.message : String(error)
+        },
+        success: false,
+        error: error instanceof Error ? error : new Error(String(error))
+      };
     }
   },
   examples: [
@@ -5700,7 +6323,7 @@ import {
   composePromptFromState as composePromptFromState6,
   createUniqueUuid,
   findWorldsForOwner,
-  logger as logger6,
+  logger as logger7,
   ModelType as ModelType8,
   parseJSONObjectFromText as parseJSONObjectFromText3
 } from "@elizaos/core";
@@ -5805,7 +6428,7 @@ async function getWorldSettings(runtime, serverId) {
     }
     return world.metadata.settings;
   } catch (error) {
-    logger6.error(`Error getting settings state: ${error}`);
+    logger7.error(`Error getting settings state: ${error}`);
     return null;
   }
 }
@@ -5814,7 +6437,7 @@ async function updateWorldSettings(runtime, serverId, worldSettings) {
     const worldId = createUniqueUuid(runtime, serverId);
     const world = await runtime.getWorld(worldId);
     if (!world) {
-      logger6.error(`No world found for server ${serverId}`);
+      logger7.error(`No world found for server ${serverId}`);
       return false;
     }
     if (!world.metadata) {
@@ -5824,7 +6447,7 @@ async function updateWorldSettings(runtime, serverId, worldSettings) {
     await runtime.updateWorld(world);
     return true;
   } catch (error) {
-    logger6.error(`Error updating settings state: ${error}`);
+    logger7.error(`Error updating settings state: ${error}`);
     return false;
   }
 }
@@ -5842,12 +6465,13 @@ function categorizeSettings(worldSettings) {
   const optionalUnconfigured = [];
   for (const [key, setting] of Object.entries(worldSettings)) {
     if (key.startsWith("_")) continue;
-    if (setting.value !== null) {
-      configured.push([key, setting]);
-    } else if (setting.required) {
-      requiredUnconfigured.push([key, setting]);
+    const typedSetting = setting;
+    if (typedSetting.value !== null) {
+      configured.push([key, typedSetting]);
+    } else if (typedSetting.required) {
+      requiredUnconfigured.push([key, typedSetting]);
     } else {
-      optionalUnconfigured.push([key, setting]);
+      optionalUnconfigured.push([key, typedSetting]);
     }
   }
   return { configured, requiredUnconfigured, optionalUnconfigured };
@@ -5964,7 +6588,7 @@ async function processSettingUpdates(runtime, serverId, worldSettings, updates)
     }
     return { updatedAny, messages };
   } catch (error) {
-    logger6.error("Error processing setting updates:", error);
+    logger7.error("Error processing setting updates:", error);
     return {
       updatedAny: false,
       messages: ["Error occurred while updating settings"]
@@ -5988,21 +6612,48 @@ async function handleOnboardingComplete(runtime, worldSettings, _state, callback
       actions: ["ONBOARDING_COMPLETE"],
       source: "discord"
     });
+    return {
+      text: "Onboarding completed successfully",
+      values: {
+        success: true,
+        onboardingComplete: true,
+        allRequiredConfigured: true
+      },
+      data: {
+        actionName: "UPDATE_SETTINGS",
+        action: "ONBOARDING_COMPLETE",
+        settingsStatus: formatSettingsList(worldSettings)
+      },
+      success: true
+    };
   } catch (error) {
-    logger6.error(`Error handling settings completion: ${error}`);
+    logger7.error(`Error handling settings completion: ${error}`);
     await callback({
       text: "Great! All required settings have been configured. Your server is now fully set up and ready to use.",
       actions: ["ONBOARDING_COMPLETE"],
       source: "discord"
     });
+    return {
+      text: "Onboarding completed with fallback message",
+      values: {
+        success: true,
+        onboardingComplete: true,
+        fallbackUsed: true
+      },
+      data: {
+        actionName: "UPDATE_SETTINGS",
+        action: "ONBOARDING_COMPLETE",
+        error: error instanceof Error ? error.message : String(error)
+      },
+      success: true
+    };
   }
 }
 async function generateSuccessResponse(runtime, worldSettings, state, messages, callback) {
   try {
     const { requiredUnconfigured } = categorizeSettings(worldSettings);
     if (requiredUnconfigured.length === 0) {
-      await handleOnboardingComplete(runtime, worldSettings, state, callback);
-      return;
+      return await handleOnboardingComplete(runtime, worldSettings, state, callback);
     }
     const requiredUnconfiguredString = requiredUnconfigured.map(([key, setting]) => `${key}: ${setting.name}`).join("\n");
     const prompt = composePrompt3({
@@ -6022,21 +6673,49 @@ async function generateSuccessResponse(runtime, worldSettings, state, messages,
       actions: ["SETTING_UPDATED"],
       source: "discord"
     });
+    return {
+      text: "Settings updated successfully",
+      values: {
+        success: true,
+        settingsUpdated: true,
+        remainingRequired: requiredUnconfigured.length
+      },
+      data: {
+        actionName: "UPDATE_SETTINGS",
+        action: "SETTING_UPDATED",
+        updatedMessages: messages,
+        remainingRequired: requiredUnconfigured.length
+      },
+      success: true
+    };
   } catch (error) {
-    logger6.error(`Error generating success response: ${error}`);
+    logger7.error(`Error generating success response: ${error}`);
     await callback({
       text: "Settings updated successfully. Please continue with the remaining configuration.",
       actions: ["SETTING_UPDATED"],
       source: "discord"
     });
+    return {
+      text: "Settings updated with fallback message",
+      values: {
+        success: true,
+        settingsUpdated: true,
+        fallbackUsed: true
+      },
+      data: {
+        actionName: "UPDATE_SETTINGS",
+        action: "SETTING_UPDATED",
+        error: error instanceof Error ? error.message : String(error)
+      },
+      success: true
+    };
   }
 }
 async function generateFailureResponse(runtime, worldSettings, state, callback) {
   try {
     const { requiredUnconfigured } = categorizeSettings(worldSettings);
     if (requiredUnconfigured.length === 0) {
-      await handleOnboardingComplete(runtime, worldSettings, state, callback);
-      return;
+      return await handleOnboardingComplete(runtime, worldSettings, state, callback);
     }
     const requiredUnconfiguredString = requiredUnconfigured.map(([key, setting]) => `${key}: ${setting.name}`).join("\n");
     const prompt = composePrompt3({
@@ -6055,13 +6734,41 @@ async function generateFailureResponse(runtime, worldSettings, state, callback)
       actions: ["SETTING_UPDATE_FAILED"],
       source: "discord"
     });
+    return {
+      text: "No settings were updated",
+      values: {
+        success: false,
+        settingsUpdated: false,
+        remainingRequired: requiredUnconfigured.length
+      },
+      data: {
+        actionName: "UPDATE_SETTINGS",
+        action: "SETTING_UPDATE_FAILED",
+        remainingRequired: requiredUnconfigured.length
+      },
+      success: false
+    };
   } catch (error) {
-    logger6.error(`Error generating failure response: ${error}`);
+    logger7.error(`Error generating failure response: ${error}`);
     await callback({
       text: "I couldn't understand your settings update. Please try again with a clearer format.",
       actions: ["SETTING_UPDATE_FAILED"],
       source: "discord"
     });
+    return {
+      text: "Failed to parse settings with fallback message",
+      values: {
+        success: false,
+        settingsUpdated: false,
+        fallbackUsed: true
+      },
+      data: {
+        actionName: "UPDATE_SETTINGS",
+        action: "SETTING_UPDATE_FAILED",
+        error: error instanceof Error ? error.message : String(error)
+      },
+      success: false
+    };
   }
 }
 async function generateErrorResponse(runtime, state, callback) {
@@ -6079,13 +6786,40 @@ async function generateErrorResponse(runtime, state, callback) {
       actions: ["SETTING_UPDATE_ERROR"],
       source: "discord"
     });
+    return {
+      text: "Error processing settings",
+      values: {
+        success: false,
+        error: "PROCESSING_ERROR"
+      },
+      data: {
+        actionName: "UPDATE_SETTINGS",
+        action: "SETTING_UPDATE_ERROR"
+      },
+      success: false
+    };
   } catch (error) {
-    logger6.error(`Error generating error response: ${error}`);
+    logger7.error(`Error generating error response: ${error}`);
     await callback({
       text: "I'm sorry, but I encountered an error while processing your request. Please try again or contact support if the issue persists.",
       actions: ["SETTING_UPDATE_ERROR"],
       source: "discord"
     });
+    return {
+      text: "Error with fallback message",
+      values: {
+        success: false,
+        error: "PROCESSING_ERROR",
+        fallbackUsed: true
+      },
+      data: {
+        actionName: "UPDATE_SETTINGS",
+        action: "SETTING_UPDATE_ERROR",
+        error: error instanceof Error ? error.message : String(error)
+      },
+      success: false,
+      error: error instanceof Error ? error : new Error(String(error))
+    };
   }
 }
 var updateSettingsAction = {
@@ -6095,10 +6829,10 @@ var updateSettingsAction = {
   validate: async (runtime, message, _state) => {
     try {
       if (message.content.channelType !== ChannelType2.DM) {
-        logger6.debug(`Skipping settings in non-DM channel (type: ${message.content.channelType})`);
+        logger7.debug(`Skipping settings in non-DM channel (type: ${message.content.channelType})`);
         return false;
       }
-      logger6.debug(`Looking for server where user ${message.entityId} is owner`);
+      logger7.debug(`Looking for server where user ${message.entityId} is owner`);
       const worlds = await findWorldsForOwner(runtime, message.entityId);
       if (!worlds) {
         return false;
@@ -6106,53 +6840,130 @@ var updateSettingsAction = {
       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}`);
+        logger7.error(`No settings state found for server ${world?.serverId}`);
         return false;
       }
-      logger6.debug(`Found valid settings state for server ${world.serverId}`);
+      logger7.debug(`Found valid settings state for server ${world.serverId}`);
       return true;
     } catch (error) {
-      logger6.error(`Error validating settings action: ${error}`);
+      logger7.error(`Error validating settings action: ${error}`);
       return false;
     }
   },
   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");
+        logger7.error("State is required for settings handler");
+        if (callback) {
+          await generateErrorResponse(runtime, state, callback);
+        }
+        return {
+          text: "State is required for settings handler",
+          values: {
+            success: false,
+            error: "STATE_REQUIRED"
+          },
+          data: {
+            actionName: "UPDATE_SETTINGS",
+            error: "State is required"
+          },
+          success: false,
+          error: 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");
+        logger7.error("Message is required for settings handler");
+        await generateErrorResponse(runtime, state, callback);
+        return {
+          text: "Message is required for settings handler",
+          values: {
+            success: false,
+            error: "MESSAGE_REQUIRED"
+          },
+          data: {
+            actionName: "UPDATE_SETTINGS",
+            error: "Message is required"
+          },
+          success: false,
+          error: 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");
+        logger7.error("Callback is required for settings handler");
+        return {
+          text: "Callback is required for settings handler",
+          values: {
+            success: false,
+            error: "CALLBACK_REQUIRED"
+          },
+          data: {
+            actionName: "UPDATE_SETTINGS",
+            error: "Callback is required"
+          },
+          success: false,
+          error: new Error("Callback is required for settings handler")
+        };
       }
-      logger6.info(`Handler looking for server for user ${message.entityId}`);
+      logger7.info(`Handler looking for server for user ${message.entityId}`);
       const worlds = await findWorldsForOwner(runtime, message.entityId);
       const serverOwnership = worlds?.find((world) => world.metadata?.settings);
       if (!serverOwnership) {
-        logger6.error(`No server found for user ${message.entityId} in handler`);
+        logger7.error(`No server found for user ${message.entityId} in handler`);
         await generateErrorResponse(runtime, state, callback);
-        return;
+        return {
+          text: "No server found for user",
+          values: {
+            success: false,
+            error: "NO_SERVER_FOUND"
+          },
+          data: {
+            actionName: "UPDATE_SETTINGS",
+            error: "No server found where user is owner",
+            entityId: message.entityId
+          },
+          success: false
+        };
       }
       const serverId = serverOwnership?.serverId;
-      logger6.info(`Using server ID: ${serverId}`);
+      logger7.info(`Using server ID: ${serverId}`);
       if (!serverId) {
-        logger6.error(`No server ID found for user ${message.entityId} in handler`);
-        return;
+        logger7.error(`No server ID found for user ${message.entityId} in handler`);
+        await generateErrorResponse(runtime, state, callback);
+        return {
+          text: "No server ID found",
+          values: {
+            success: false,
+            error: "NO_SERVER_ID"
+          },
+          data: {
+            actionName: "UPDATE_SETTINGS",
+            error: "No server ID found",
+            entityId: message.entityId
+          },
+          success: false
+        };
       }
       const worldSettings = await getWorldSettings(runtime, serverId);
       if (!worldSettings) {
-        logger6.error(`No settings state found for server ${serverId} in handler`);
+        logger7.error(`No settings state found for server ${serverId} in handler`);
         await generateErrorResponse(runtime, state, callback);
-        return;
+        return {
+          text: "No settings state found",
+          values: {
+            success: false,
+            error: "NO_SETTINGS_STATE"
+          },
+          data: {
+            actionName: "UPDATE_SETTINGS",
+            error: "No settings state found for server",
+            serverId
+          },
+          success: false
+        };
       }
-      logger6.info(`Extracting settings from message: ${message.content.text}`);
+      logger7.info(`Extracting settings from message: ${message.content.text}`);
       const extractedSettings = await extractSettingValues(runtime, message, state, worldSettings);
-      logger6.info(`Extracted ${extractedSettings.length} settings`);
+      logger7.info(`Extracted ${extractedSettings.length} settings`);
       const updateResults = await processSettingUpdates(
         runtime,
         serverId,
@@ -6160,12 +6971,24 @@ var updateSettingsAction = {
         extractedSettings
       );
       if (updateResults.updatedAny) {
-        logger6.info(`Successfully updated settings: ${updateResults.messages.join(", ")}`);
+        logger7.info(`Successfully updated settings: ${updateResults.messages.join(", ")}`);
         const updatedWorldSettings = await getWorldSettings(runtime, serverId);
         if (!updatedWorldSettings) {
-          logger6.error("Failed to retrieve updated settings state");
+          logger7.error("Failed to retrieve updated settings state");
           await generateErrorResponse(runtime, state, callback);
-          return;
+          return {
+            text: "Failed to retrieve updated settings state",
+            values: {
+              success: false,
+              error: "RETRIEVE_FAILED"
+            },
+            data: {
+              actionName: "UPDATE_SETTINGS",
+              error: "Failed to retrieve updated settings state",
+              serverId
+            },
+            success: false
+          };
         }
         await generateSuccessResponse(
           runtime,
@@ -6174,15 +6997,67 @@ var updateSettingsAction = {
           updateResults.messages,
           callback
         );
+        const { requiredUnconfigured } = categorizeSettings(updatedWorldSettings);
+        const allConfigured = requiredUnconfigured.length === 0;
+        return {
+          text: `Settings updated successfully`,
+          values: {
+            success: true,
+            settingsUpdated: extractedSettings.length,
+            updatedSettings: extractedSettings.map((s) => s.key),
+            remainingRequired: requiredUnconfigured.length,
+            allConfigured,
+            serverId
+          },
+          data: {
+            actionName: "UPDATE_SETTINGS",
+            updatedSettings: extractedSettings,
+            messages: updateResults.messages,
+            remainingRequired: requiredUnconfigured.map(([key, _]) => key),
+            allConfigured,
+            serverId
+          },
+          success: true
+        };
       } else {
-        logger6.info("No settings were updated");
+        logger7.info("No settings were updated");
         await generateFailureResponse(runtime, worldSettings, state, callback);
+        const { requiredUnconfigured } = categorizeSettings(worldSettings);
+        return {
+          text: "No settings were updated",
+          values: {
+            success: false,
+            error: "NO_UPDATES",
+            remainingRequired: requiredUnconfigured.length,
+            serverId
+          },
+          data: {
+            actionName: "UPDATE_SETTINGS",
+            error: "No valid settings found in message",
+            remainingRequired: requiredUnconfigured.map(([key, _]) => key),
+            serverId
+          },
+          success: false
+        };
       }
     } catch (error) {
-      logger6.error(`Error in settings handler: ${error}`);
+      logger7.error(`Error in settings handler: ${error}`);
       if (state && callback) {
         await generateErrorResponse(runtime, state, callback);
       }
+      return {
+        text: "Error in settings handler",
+        values: {
+          success: false,
+          error: "HANDLER_ERROR"
+        },
+        data: {
+          actionName: "UPDATE_SETTINGS",
+          error: error instanceof Error ? error.message : String(error)
+        },
+        success: false,
+        error: error instanceof Error ? error : new Error(String(error))
+      };
     }
   },
   examples: [
@@ -6401,21 +7276,70 @@ var unfollowRoomAction = {
       return parsedResponse;
     }
     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(
-        {
-          entityId: message.entityId,
-          agentId: message.agentId,
-          roomId: message.roomId,
-          content: {
-            thought: `I unfollowed the room ${room.name}`,
-            actions: ["UNFOLLOW_ROOM_START"]
-          }
-        },
-        "messages"
-      );
+      try {
+        await runtime.setParticipantUserState(message.roomId, runtime.agentId, null);
+        const room = state.data.room ?? await runtime.getRoom(message.roomId);
+        await runtime.createMemory(
+          {
+            entityId: message.entityId,
+            agentId: message.agentId,
+            roomId: message.roomId,
+            content: {
+              thought: `I unfollowed the room ${room.name}`,
+              actions: ["UNFOLLOW_ROOM_START"]
+            }
+          },
+          "messages"
+        );
+        return {
+          text: `Stopped following room: ${room.name}`,
+          values: {
+            success: true,
+            roomUnfollowed: true,
+            roomId: message.roomId,
+            roomName: room.name,
+            newState: null
+          },
+          data: {
+            actionName: "UNFOLLOW_ROOM",
+            roomId: message.roomId,
+            roomName: room.name,
+            unfollowed: true
+          },
+          success: true
+        };
+      } catch (error) {
+        return {
+          text: "Failed to unfollow room",
+          values: {
+            success: false,
+            error: "UNFOLLOW_FAILED"
+          },
+          data: {
+            actionName: "UNFOLLOW_ROOM",
+            error: error instanceof Error ? error.message : String(error),
+            roomId: message.roomId
+          },
+          success: false,
+          error: error instanceof Error ? error : new Error(String(error))
+        };
+      }
     } else {
+      if (!state) {
+        return {
+          text: "State is required for unfollow room action",
+          values: {
+            success: false,
+            error: "STATE_REQUIRED"
+          },
+          data: {
+            actionName: "UNFOLLOW_ROOM",
+            error: "State is required"
+          },
+          success: false,
+          error: new Error("State is required for unfollow room action")
+        };
+      }
       await runtime.createMemory(
         {
           entityId: message.entityId,
@@ -6432,6 +7356,22 @@ var unfollowRoomAction = {
         },
         "messages"
       );
+      return {
+        text: "Did not unfollow room - criteria not met",
+        values: {
+          success: true,
+          roomUnfollowed: false,
+          roomId: message.roomId,
+          reason: "CRITERIA_NOT_MET"
+        },
+        data: {
+          actionName: "UNFOLLOW_ROOM",
+          roomId: message.roomId,
+          unfollowed: false,
+          reason: "Decision criteria not met"
+        },
+        success: true
+      };
     }
   },
   examples: [
@@ -6685,7 +7625,7 @@ var unfollowRoomAction = {
 import {
   booleanFooter as booleanFooter4,
   composePromptFromState as composePromptFromState8,
-  logger as logger7,
+  logger as logger8,
   ModelType as ModelType10
 } from "@elizaos/core";
 var shouldUnmuteTemplate = `# Task: Decide if {{agentName}} should unmute this previously muted room and start considering it for responses again.
@@ -6760,29 +7700,110 @@ var unmuteRoomAction = {
         );
         return false;
       }
-      logger7.warn(`Unclear boolean response: ${response}, defaulting to false`);
+      logger8.warn(`Unclear boolean response: ${response}, defaulting to false`);
       return false;
     }
-    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;
+    if (!state) {
+      return {
+        text: "State is required for unmute room action",
+        values: {
+          success: false,
+          error: "STATE_REQUIRED"
+        },
+        data: {
+          actionName: "UNMUTE_ROOM",
+          error: "State is required"
+        },
+        success: false,
+        error: new Error("State is required for unmute room action")
+      };
     }
-    await runtime.createMemory(
-      {
-        entityId: message.entityId,
-        agentId: message.agentId,
-        roomId: message.roomId,
-        content: {
-          thought: `I unmuted the room ${room.name}`,
-          actions: ["UNMUTE_ROOM_START"]
+    const shouldUnmute = await _shouldUnmute(state);
+    if (shouldUnmute) {
+      try {
+        await runtime.setParticipantUserState(message.roomId, runtime.agentId, null);
+        const room = await runtime.getRoom(message.roomId);
+        if (!room) {
+          logger8.warn(`Room not found: ${message.roomId}`);
+          return {
+            text: `Room not found: ${message.roomId}`,
+            values: {
+              success: false,
+              error: "ROOM_NOT_FOUND",
+              roomId: message.roomId
+            },
+            data: {
+              actionName: "UNMUTE_ROOM",
+              error: "Room not found",
+              roomId: message.roomId
+            },
+            success: false
+          };
         }
-      },
-      "messages"
-    );
+        await runtime.createMemory(
+          {
+            entityId: message.entityId,
+            agentId: message.agentId,
+            roomId: message.roomId,
+            content: {
+              thought: `I unmuted the room ${room.name}`,
+              actions: ["UNMUTE_ROOM_START"]
+            }
+          },
+          "messages"
+        );
+        return {
+          text: `Room unmuted: ${room.name}`,
+          values: {
+            success: true,
+            roomUnmuted: true,
+            roomId: message.roomId,
+            roomName: room.name,
+            newState: null
+          },
+          data: {
+            actionName: "UNMUTE_ROOM",
+            roomId: message.roomId,
+            roomName: room.name,
+            unmuted: true
+          },
+          success: true
+        };
+      } catch (error) {
+        logger8.error("Error unmuting room:", error);
+        return {
+          text: "Failed to unmute room",
+          values: {
+            success: false,
+            error: "UNMUTE_FAILED"
+          },
+          data: {
+            actionName: "UNMUTE_ROOM",
+            error: error instanceof Error ? error.message : String(error),
+            roomId: message.roomId
+          },
+          success: false,
+          error: error instanceof Error ? error : new Error(String(error))
+        };
+      }
+    } else {
+      return {
+        text: "Decided not to unmute room",
+        values: {
+          success: true,
+          roomUnmuted: false,
+          roomId: message.roomId,
+          reason: "CRITERIA_NOT_MET"
+        },
+        data: {
+          actionName: "UNMUTE_ROOM",
+          roomId: message.roomId,
+          unmuted: false,
+          reason: "Decision criteria not met"
+        },
+        success: true
+      };
+    }
   },
   examples: [
     [
@@ -6879,7 +7900,7 @@ var unmuteRoomAction = {
 import {
   composePromptFromState as composePromptFromState9,
   findEntityByName as findEntityByName2,
-  logger as logger8,
+  logger as logger9,
   ModelType as ModelType11
 } from "@elizaos/core";
 var componentTemplate = `# Task: Extract Source and Update Component Data
@@ -6947,20 +7968,68 @@ 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");
+        logger9.error("State is required for the updateEntity action");
+        return {
+          text: "State is required for updateEntity action",
+          values: {
+            success: false,
+            error: "STATE_REQUIRED"
+          },
+          data: {
+            actionName: "UPDATE_CONTACT",
+            error: "State is required"
+          },
+          success: false,
+          error: 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");
+        logger9.error("Callback is required for the updateEntity action");
+        return {
+          text: "Callback is required for updateEntity action",
+          values: {
+            success: false,
+            error: "CALLBACK_REQUIRED"
+          },
+          data: {
+            actionName: "UPDATE_CONTACT",
+            error: "Callback is required"
+          },
+          success: false,
+          error: 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");
+        logger9.error("Responses are required for the updateEntity action");
+        return {
+          text: "Responses are required for updateEntity action",
+          values: {
+            success: false,
+            error: "RESPONSES_REQUIRED"
+          },
+          data: {
+            actionName: "UPDATE_CONTACT",
+            error: "Responses are required"
+          },
+          success: false,
+          error: 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");
+        logger9.error("Message is required for the updateEntity action");
+        return {
+          text: "Message is required for updateEntity action",
+          values: {
+            success: false,
+            error: "MESSAGE_REQUIRED"
+          },
+          data: {
+            actionName: "UPDATE_CONTACT",
+            error: "Message is required"
+          },
+          success: false,
+          error: new Error("Message is required for the updateEntity action")
+        };
       }
       for (const response of responses) {
         await callback(response.content);
@@ -6976,7 +8045,18 @@ var updateEntityAction = {
           actions: ["UPDATE_ENTITY_ERROR"],
           source: message.content.source
         });
-        return;
+        return {
+          text: "Entity not found",
+          values: {
+            success: false,
+            error: "ENTITY_NOT_FOUND"
+          },
+          data: {
+            actionName: "UPDATE_CONTACT",
+            error: "Could not find entity to update"
+          },
+          success: false
+        };
       }
       let existingComponent = null;
       const prompt = composePromptFromState9({
@@ -6998,13 +8078,25 @@ var updateEntityAction = {
           throw new Error("Invalid response format - missing source or data");
         }
       } catch (error) {
-        logger8.error(`Failed to parse component data: ${error.message}`);
+        logger9.error(`Failed to parse component data: ${error.message}`);
         await callback({
           text: "I couldn't properly understand the component information. Please try again with more specific information.",
           actions: ["UPDATE_ENTITY_ERROR"],
           source: message.content.source
         });
-        return;
+        return {
+          text: "Failed to parse component data",
+          values: {
+            success: false,
+            error: "PARSE_ERROR"
+          },
+          data: {
+            actionName: "UPDATE_CONTACT",
+            error: error.message
+          },
+          success: false,
+          error
+        };
       }
       const componentType = parsedResult.source.toLowerCase();
       const componentData = parsedResult.data;
@@ -7031,9 +8123,30 @@ var updateEntityAction = {
           actions: ["UPDATE_ENTITY"],
           source: message.content.source
         });
+        return {
+          text: `Updated ${componentType} information`,
+          values: {
+            success: true,
+            entityId: entity.id,
+            entityName: entity.names[0],
+            componentType,
+            componentUpdated: true,
+            isNewComponent: false
+          },
+          data: {
+            actionName: "UPDATE_CONTACT",
+            entityId: entity.id,
+            entityName: entity.names[0],
+            componentType,
+            componentData,
+            existingComponentId: existingComponent.id
+          },
+          success: true
+        };
       } else {
+        const newComponentId = v4_default();
         await runtime.createComponent({
-          id: v4_default(),
+          id: newComponentId,
           entityId: entity.id,
           worldId,
           type: componentType,
@@ -7048,14 +8161,47 @@ var updateEntityAction = {
           actions: ["UPDATE_ENTITY"],
           source: message.content.source
         });
+        return {
+          text: `Added new ${componentType} information`,
+          values: {
+            success: true,
+            entityId: entity.id,
+            entityName: entity.names[0],
+            componentType,
+            componentCreated: true,
+            isNewComponent: true
+          },
+          data: {
+            actionName: "UPDATE_CONTACT",
+            entityId: entity.id,
+            entityName: entity.names[0],
+            componentType,
+            componentData,
+            newComponentId
+          },
+          success: true
+        };
       }
     } catch (error) {
-      logger8.error(`Error in updateEntity handler: ${error}`);
+      logger9.error(`Error in updateEntity handler: ${error}`);
       await callback?.({
         text: "There was an error processing the entity information.",
         actions: ["UPDATE_ENTITY_ERROR"],
         source: message.content.source
       });
+      return {
+        text: "Error processing entity information",
+        values: {
+          success: false,
+          error: "HANDLER_ERROR"
+        },
+        data: {
+          actionName: "UPDATE_CONTACT",
+          error: error instanceof Error ? error.message : String(error)
+        },
+        success: false,
+        error: error instanceof Error ? error : new Error(String(error))
+      };
     }
   },
   examples: [
@@ -7109,7 +8255,7 @@ var updateEntityAction = {
 
 // src/evaluators/reflection.ts
 import { z } from "zod";
-import { getEntityDetails, logger as logger9 } from "@elizaos/core";
+import { getEntityDetails, logger as logger10 } from "@elizaos/core";
 import { composePrompt as composePrompt4 } from "@elizaos/core";
 import {
   ModelType as ModelType12
@@ -7210,7 +8356,7 @@ function resolveEntity(entityId, entities) {
 async function handler(runtime, message, state) {
   const { agentId, roomId } = message;
   if (!agentId || !roomId) {
-    logger9.warn("Missing agentId or roomId in message", message);
+    logger10.warn("Missing agentId or roomId in message", message);
     return;
   }
   const [existingRelationships, entities, knownFacts] = await Promise.all([
@@ -7242,15 +8388,15 @@ async function handler(runtime, message, state) {
       // Remove schema validation to avoid zod issues
     });
     if (!reflection) {
-      logger9.warn("Getting reflection failed - empty response", prompt);
+      logger10.warn("Getting reflection failed - empty response", prompt);
       return;
     }
     if (!reflection.facts || !Array.isArray(reflection.facts)) {
-      logger9.warn("Getting reflection failed - invalid facts structure", reflection);
+      logger10.warn("Getting reflection failed - invalid facts structure", reflection);
       return;
     }
     if (!reflection.relationships || !Array.isArray(reflection.relationships)) {
-      logger9.warn("Getting reflection failed - invalid relationships structure", reflection);
+      logger10.warn("Getting reflection failed - invalid relationships structure", reflection);
       return;
     }
     const newFacts = reflection.facts.filter(
@@ -7313,7 +8459,7 @@ async function handler(runtime, message, state) {
     );
     return reflection;
   } catch (error) {
-    logger9.error("Error in reflection handler:", error);
+    logger10.error("Error in reflection handler:", error);
     return;
   }
 }
@@ -7530,24 +8676,17 @@ var actionsProvider = {
     const resolvedActions = await Promise.all(actionPromises);
     const actionsData = resolvedActions.filter(Boolean);
     const actionNames = `Possible response actions: ${formatActionNames(actionsData)}`;
-    const actionsWithDescriptions = actionsData.length > 0 ? addHeader(
-      "# Available Actions",
-      actionsData.map(
-        (action) => `- **${action.name}**: ${action.description || "No description available"}`
-      ).join("\n")
-    ) : "";
-    const actions = actionsData.length > 0 ? addHeader("# Available Actions", formatActions(actionsData)) : "";
+    const actionsWithDescriptions = actionsData.length > 0 ? addHeader("# Available Actions", formatActions(actionsData)) : "";
     const actionExamples = actionsData.length > 0 ? addHeader("# Action Examples", composeActionExamples(actionsData, 10)) : "";
     const data = {
       actionsData
     };
     const values = {
-      actions,
       actionNames,
       actionExamples,
       actionsWithDescriptions
     };
-    const text = [actionNames, actionsWithDescriptions, actionExamples, actions].filter(Boolean).join("\n\n");
+    const text = [actionNames, actionsWithDescriptions, actionExamples].filter(Boolean).join("\n\n");
     return {
       data,
       values,
@@ -7556,8 +8695,156 @@ var actionsProvider = {
   }
 };
 
+// src/providers/actionState.ts
+import {
+  addHeader as addHeader2,
+  logger as logger11
+} from "@elizaos/core";
+var actionStateProvider = {
+  name: "ACTION_STATE",
+  description: "Previous action results, working memory, and action plan from the current execution run",
+  position: 150,
+  get: async (runtime, message, state) => {
+    const actionResults = state.data?.actionResults || [];
+    const actionPlan = state.data?.actionPlan || null;
+    const workingMemory = state.data?.workingMemory || {};
+    let planText = "";
+    if (actionPlan && actionPlan.totalSteps > 1) {
+      const completedSteps = actionPlan.steps.filter((s) => s.status === "completed").length;
+      const failedSteps = actionPlan.steps.filter((s) => s.status === "failed").length;
+      planText = addHeader2(
+        "# Action Execution Plan",
+        [
+          `**Plan:** ${actionPlan.thought}`,
+          `**Progress:** Step ${actionPlan.currentStep} of ${actionPlan.totalSteps}`,
+          `**Status:** ${completedSteps} completed, ${failedSteps} failed`,
+          "",
+          "## Steps:",
+          ...actionPlan.steps.map((step, index) => {
+            const icon = step.status === "completed" ? "\u2713" : step.status === "failed" ? "\u2717" : index < actionPlan.currentStep - 1 ? "\u25CB" : index === actionPlan.currentStep - 1 ? "\u2192" : "\u25CB";
+            const status = step.status === "pending" && index === actionPlan.currentStep - 1 ? "in progress" : step.status;
+            let stepText = `${icon} **Step ${index + 1}:** ${step.action} (${status})`;
+            if (step.error) {
+              stepText += `
+   Error: ${step.error}`;
+            }
+            if (step.result?.text) {
+              stepText += `
+   Result: ${step.result.text}`;
+            }
+            return stepText;
+          }),
+          ""
+        ].join("\n")
+      );
+    }
+    let resultsText = "";
+    if (actionResults.length > 0) {
+      const formattedResults = actionResults.map((result, index) => {
+        const actionName = result.data?.actionName || "Unknown Action";
+        const success = result.success;
+        const status = success ? "Success" : "Failed";
+        let resultText = `**${index + 1}. ${actionName}** - ${status}`;
+        if (result.text) {
+          resultText += `
+   Output: ${result.text}`;
+        }
+        if (result.error) {
+          resultText += `
+   Error: ${result.error}`;
+        }
+        if (result.values && Object.keys(result.values).length > 0) {
+          const values = Object.entries(result.values).map(([key, value]) => `   - ${key}: ${JSON.stringify(value)}`).join("\n");
+          resultText += `
+   Values:
+${values}`;
+        }
+        return resultText;
+      }).join("\n\n");
+      resultsText = addHeader2("# Previous Action Results", formattedResults);
+    }
+    let memoryText = "";
+    if (Object.keys(workingMemory).length > 0) {
+      const memoryEntries = Object.entries(workingMemory).sort((a2, b) => (b[1].timestamp || 0) - (a2[1].timestamp || 0)).slice(0, 10).map(([key, value]) => {
+        if (value.actionName && value.result) {
+          return `**${value.actionName}**: ${value.result.text || JSON.stringify(value.result.data)}`;
+        }
+        return `**${key}**: ${JSON.stringify(value)}`;
+      }).join("\n");
+      memoryText = addHeader2("# Working Memory", memoryEntries);
+    }
+    let recentActionMemories = [];
+    try {
+      const recentMessages = await runtime.getMemories({
+        tableName: "messages",
+        roomId: message.roomId,
+        count: 20,
+        unique: false
+      });
+      recentActionMemories = recentMessages.filter(
+        (msg) => msg.content?.type === "action_result" && msg.metadata?.type === "action_result"
+      );
+    } catch (error) {
+      logger11?.error("Failed to retrieve action memories:", error);
+    }
+    let actionMemoriesText = "";
+    if (recentActionMemories.length > 0) {
+      const groupedByRun = /* @__PURE__ */ new Map();
+      for (const mem of recentActionMemories) {
+        const runId = String(mem.content?.runId || "unknown");
+        if (!groupedByRun.has(runId)) {
+          groupedByRun.set(runId, []);
+        }
+        const memories = groupedByRun.get(runId);
+        if (memories) {
+          memories.push(mem);
+        }
+      }
+      const formattedMemories = Array.from(groupedByRun.entries()).map(([runId, memories]) => {
+        const sortedMemories = memories.sort(
+          (a2, b) => (a2.createdAt || 0) - (b.createdAt || 0)
+        );
+        const runText = sortedMemories.map((mem) => {
+          const actionName = mem.content?.actionName || "Unknown";
+          const status = mem.content?.actionStatus || "unknown";
+          const planStep = mem.content?.planStep || "";
+          const text = mem.content?.text || "";
+          let memText = `  - ${actionName} (${status})`;
+          if (planStep) memText += ` [${planStep}]`;
+          if (text && text !== `Executed action: ${actionName}`) {
+            memText += `: ${text}`;
+          }
+          return memText;
+        }).join("\n");
+        const thought = sortedMemories[0]?.content?.planThought || "";
+        return `**Run ${runId.slice(0, 8)}**${thought ? ` - ${thought}` : ""}
+${runText}`;
+      }).join("\n\n");
+      actionMemoriesText = addHeader2("# Recent Action History", formattedMemories);
+    }
+    const allText = [planText, resultsText, memoryText, actionMemoriesText].filter(Boolean).join("\n\n");
+    return {
+      data: {
+        actionResults,
+        actionPlan,
+        workingMemory,
+        recentActionMemories
+      },
+      values: {
+        hasActionResults: actionResults.length > 0,
+        hasActionPlan: !!actionPlan,
+        currentActionStep: actionPlan?.currentStep || 0,
+        totalActionSteps: actionPlan?.totalSteps || 0,
+        completedActions: actionResults.filter((r) => r.success).length,
+        failedActions: actionResults.filter((r) => !r.success).length
+      },
+      text: allText || "No action state available"
+    };
+  }
+};
+
 // src/providers/anxiety.ts
-import { addHeader as addHeader2, ChannelType as ChannelType3 } from "@elizaos/core";
+import { addHeader as addHeader3, ChannelType as ChannelType3 } from "@elizaos/core";
 var anxietyProvider = {
   name: "ANXIETY",
   description: "Social directions for the AI to follow based on the channel type",
@@ -7625,7 +8912,7 @@ var anxietyProvider = {
     const randomAnxietyExamples = anxietyExamples.sort(() => Math.random() - 0.5).slice(0, 3);
     const anxietyText = randomAnxietyExamples.join("\n");
     const anxietyHeader = "# You are roleplaying as a character, but as an AI model, you are too verbose and eager.";
-    const anxiety = addHeader2(anxietyHeader, anxietyText);
+    const anxiety = addHeader3(anxietyHeader, anxietyText);
     return {
       data: {
         anxiety: randomAnxietyExamples
@@ -7639,7 +8926,7 @@ var anxietyProvider = {
 };
 
 // src/providers/attachments.ts
-import { addHeader as addHeader3 } from "@elizaos/core";
+import { addHeader as addHeader4 } from "@elizaos/core";
 var attachmentsProvider = {
   name: "ATTACHMENTS",
   description: "List of attachments sent during the current conversation, including names, descriptions, and summaries",
@@ -7691,7 +8978,7 @@ var attachmentsProvider = {
     Text: ${attachment.text}
     `
     ).join("\n");
-    const text = formattedAttachments && formattedAttachments.length > 0 ? addHeader3("# Attachments", formattedAttachments) : "";
+    const text = formattedAttachments && formattedAttachments.length > 0 ? addHeader4("# Attachments", formattedAttachments) : "";
     const values = {
       attachments: text
     };
@@ -7707,7 +8994,7 @@ var attachmentsProvider = {
 };
 
 // src/providers/capabilities.ts
-import { logger as logger10 } from "@elizaos/core";
+import { logger as logger12 } from "@elizaos/core";
 var capabilitiesProvider = {
   name: "CAPABILITIES",
   get: async (runtime, _message) => {
@@ -7741,7 +9028,7 @@ var capabilitiesProvider = {
 ${formattedCapabilities}`
       };
     } catch (error) {
-      logger10.error("Error in capabilities provider:", error);
+      logger12.error("Error in capabilities provider:", error);
       return {
         text: "Error retrieving capabilities from services."
       };
@@ -7750,7 +9037,7 @@ ${formattedCapabilities}`
 };
 
 // src/providers/character.ts
-import { addHeader as addHeader4, ChannelType as ChannelType4 } from "@elizaos/core";
+import { addHeader as addHeader5, ChannelType as ChannelType4 } from "@elizaos/core";
 var characterProvider = {
   name: "CHARACTER",
   description: "Character information",
@@ -7758,7 +9045,7 @@ var characterProvider = {
     const character = runtime.character;
     const agentName = character.name;
     const bioText = Array.isArray(character.bio) ? character.bio.sort(() => 0.5 - Math.random()).slice(0, 10).join(" ") : character.bio || "";
-    const bio = addHeader4(`# About ${character.name}`, bioText);
+    const bio = addHeader5(`# 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 || "";
@@ -7777,7 +9064,7 @@ var characterProvider = {
       const messageString = `${post}`;
       return messageString;
     }).slice(0, 50).join("\n");
-    const characterPostExamples = formattedCharacterPostExamples && formattedCharacterPostExamples.replaceAll("\n", "").length > 0 ? addHeader4(`# Example Posts for ${character.name}`, formattedCharacterPostExamples) : "";
+    const characterPostExamples = formattedCharacterPostExamples && formattedCharacterPostExamples.replaceAll("\n", "").length > 0 ? addHeader5(`# Example Posts for ${character.name}`, formattedCharacterPostExamples) : "";
     const formattedCharacterMessageExamples = !character.messageExamples ? "" : character.messageExamples.sort(() => 0.5 - Math.random()).slice(0, 5).map((example) => {
       const exampleNames = Array.from(
         { length: 5 },
@@ -7792,13 +9079,13 @@ var characterProvider = {
         return messageString;
       }).join("\n");
     }).join("\n\n");
-    const characterMessageExamples = formattedCharacterMessageExamples && formattedCharacterMessageExamples.replaceAll("\n", "").length > 0 ? addHeader4(
+    const characterMessageExamples = formattedCharacterMessageExamples && formattedCharacterMessageExamples.replaceAll("\n", "").length > 0 ? addHeader5(
       `# Example Conversations for ${character.name}`,
       formattedCharacterMessageExamples
     ) : "";
     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 && character?.style?.all?.length > 0 || character?.style?.post?.length && 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 ? addHeader5(
       `# Post Directions for ${character.name}`,
       (() => {
         const all = character?.style?.all || [];
@@ -7806,7 +9093,7 @@ var characterProvider = {
         return [...all, ...post].join("\n");
       })()
     ) : "";
-    const messageDirections = character?.style?.all?.length && character?.style?.all?.length > 0 || character?.style?.chat?.length && 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 ? addHeader5(
       `# Message Directions for ${character.name}`,
       (() => {
         const all = character?.style?.all || [];
@@ -7852,7 +9139,7 @@ var characterProvider = {
 };
 
 // src/providers/choice.ts
-import { logger as logger11 } from "@elizaos/core";
+import { logger as logger13 } from "@elizaos/core";
 var choiceProvider = {
   name: "CHOICE",
   get: async (runtime, message, _state) => {
@@ -7920,7 +9207,7 @@ var choiceProvider = {
         text: output
       };
     } catch (error) {
-      logger11.error("Error in options provider:", error);
+      logger13.error("Error in options provider:", error);
       return {
         data: {
           tasks: []
@@ -7935,7 +9222,7 @@ var choiceProvider = {
 };
 
 // src/providers/entities.ts
-import { addHeader as addHeader5, formatEntities, getEntityDetails as getEntityDetails2 } from "@elizaos/core";
+import { addHeader as addHeader6, formatEntities, getEntityDetails as getEntityDetails2 } from "@elizaos/core";
 var entitiesProvider = {
   name: "ENTITIES",
   description: "People in the current conversation",
@@ -7945,7 +9232,7 @@ var entitiesProvider = {
     const entitiesData = await getEntityDetails2({ runtime, roomId });
     const formattedEntities = formatEntities({ entities: entitiesData ?? [] });
     const senderName = entitiesData?.find((entity) => entity.id === entityId)?.names[0];
-    const entities = formattedEntities && formattedEntities.length > 0 ? addHeader5("# People in the Room", formattedEntities) : "";
+    const entities = formattedEntities && formattedEntities.length > 0 ? addHeader6("# People in the Room", formattedEntities) : "";
     const data = {
       entitiesData,
       senderName
@@ -7962,7 +9249,7 @@ var entitiesProvider = {
 };
 
 // src/providers/evaluators.ts
-import { addHeader as addHeader6 } from "@elizaos/core";
+import { addHeader as addHeader7 } from "@elizaos/core";
 
 // ../../node_modules/unique-names-generator/dist/index.m.js
 var a = (a2) => {
@@ -8063,9 +9350,9 @@ var evaluatorsProvider = {
     });
     const resolvedEvaluators = await Promise.all(evaluatorPromises);
     const evaluatorsData = resolvedEvaluators.filter(Boolean);
-    const evaluators = evaluatorsData.length > 0 ? addHeader6("# Available Evaluators", formatEvaluators(evaluatorsData)) : "";
+    const evaluators = evaluatorsData.length > 0 ? addHeader7("# Available Evaluators", formatEvaluators(evaluatorsData)) : "";
     const evaluatorNames = evaluatorsData.length > 0 ? formatEvaluatorNames(evaluatorsData) : "";
-    const evaluatorExamples = evaluatorsData.length > 0 ? addHeader6("# Evaluator Examples", formatEvaluatorExamples(evaluatorsData)) : "";
+    const evaluatorExamples = evaluatorsData.length > 0 ? addHeader7("# Evaluator Examples", formatEvaluatorExamples(evaluatorsData)) : "";
     const values = {
       evaluatorsData,
       evaluators,
@@ -8082,7 +9369,7 @@ var evaluatorsProvider = {
 
 // src/providers/facts.ts
 import { ModelType as ModelType13 } from "@elizaos/core";
-import { logger as logger12 } from "@elizaos/core";
+import { logger as logger14 } from "@elizaos/core";
 function formatFacts2(facts) {
   return facts.reverse().map((fact) => fact.content.text).join("\n");
 }
@@ -8146,7 +9433,7 @@ var factsProvider = {
         text
       };
     } catch (error) {
-      logger12.error("Error in factsProvider:", error);
+      logger14.error("Error in factsProvider:", error);
       return {
         values: {
           facts: ""
@@ -8161,7 +9448,7 @@ var factsProvider = {
 };
 
 // src/providers/providers.ts
-import { addHeader as addHeader7 } from "@elizaos/core";
+import { addHeader as addHeader8 } from "@elizaos/core";
 var providersProvider = {
   name: "PROVIDERS",
   description: "List of all data providers the agent can use to get additional information",
@@ -8173,11 +9460,11 @@ var providersProvider = {
     const headerText = "# Providers\n\nThese providers are available for the agent to select and use:";
     if (providerDescriptions.length === 0) {
       return {
-        text: addHeader7(headerText, "No dynamic providers are currently available.")
+        text: addHeader8(headerText, "No dynamic providers are currently available.")
       };
     }
     const providersText = providerDescriptions.join("\n");
-    const text = addHeader7(headerText, providersText);
+    const text = addHeader8(headerText, providersText);
     const data = {
       dynamicProviders: dynamicProviders.map((provider) => ({
         name: provider.name,
@@ -8193,12 +9480,12 @@ var providersProvider = {
 
 // src/providers/recentMessages.ts
 import {
-  addHeader as addHeader8,
+  addHeader as addHeader9,
   ChannelType as ChannelType5,
   formatMessages,
   formatPosts,
   getEntityDetails as getEntityDetails3,
-  logger as logger13
+  logger as logger15
 } from "@elizaos/core";
 var getRecentInteractions = async (runtime, sourceEntityId, targetEntityId, excludeRoomId) => {
   const rooms = await runtime.getRoomsForParticipants([sourceEntityId, targetEntityId]);
@@ -8228,32 +9515,78 @@ var recentMessagesProvider = {
         }),
         message.entityId !== runtime.agentId ? getRecentInteractions(runtime, message.entityId, runtime.agentId, roomId) : Promise.resolve([])
       ]);
+      const actionResultMessages = recentMessagesData.filter(
+        (msg) => msg.content?.type === "action_result" && msg.metadata?.type === "action_result"
+      );
+      const dialogueMessages = recentMessagesData.filter(
+        (msg) => !(msg.content?.type === "action_result" && msg.metadata?.type === "action_result")
+      );
       const isPostFormat = room?.type ? room.type === ChannelType5.FEED || room.type === ChannelType5.THREAD : false;
       const [formattedRecentMessages, formattedRecentPosts] = await Promise.all([
         formatMessages({
-          messages: recentMessagesData,
+          messages: dialogueMessages,
           entities: entitiesData
         }),
         formatPosts({
-          messages: recentMessagesData,
+          messages: dialogueMessages,
           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) {
+      let actionResultsText = "";
+      if (actionResultMessages.length > 0) {
+        const groupedByRun = /* @__PURE__ */ new Map();
+        for (const mem of actionResultMessages) {
+          const runId = String(mem.content?.runId || "unknown");
+          if (!groupedByRun.has(runId)) {
+            groupedByRun.set(runId, []);
+          }
+          const memories = groupedByRun.get(runId);
+          if (memories) {
+            memories.push(mem);
+          }
+        }
+        const formattedActionResults = Array.from(groupedByRun.entries()).slice(-3).map(([runId, memories]) => {
+          const sortedMemories = memories.sort(
+            (a2, b) => (a2.createdAt || 0) - (b.createdAt || 0)
+          );
+          const thought = sortedMemories[0]?.content?.planThought || "";
+          const runText = sortedMemories.map((mem) => {
+            const actionName = mem.content?.actionName || "Unknown";
+            const status = mem.content?.actionStatus || "unknown";
+            const planStep = mem.content?.planStep || "";
+            const text2 = mem.content?.text || "";
+            const error = mem.content?.error || "";
+            let memText = `  - ${actionName} (${status})`;
+            if (planStep) memText += ` [${planStep}]`;
+            if (error) {
+              memText += `: Error - ${error}`;
+            } else if (text2 && text2 !== `Executed action: ${actionName}`) {
+              memText += `: ${text2}`;
+            }
+            return memText;
+          }).join("\n");
+          return `**Action Run ${runId.slice(0, 8)}**${thought ? ` - "${thought}"` : ""}
+${runText}`;
+        }).join("\n\n");
+        actionResultsText = formattedActionResults ? addHeader9("# Recent Action Executions", formattedActionResults) : "";
+      }
+      const recentPosts = formattedRecentPosts && formattedRecentPosts.length > 0 ? addHeader9("# Posts in Thread", formattedRecentPosts) : "";
+      const recentMessages = formattedRecentMessages && formattedRecentMessages.length > 0 ? addHeader9("# Conversation Messages", formattedRecentMessages) : "";
+      if (!recentPosts && !recentMessages && dialogueMessages.length === 0 && !message.content.text) {
         return {
           data: {
-            recentMessages: [],
-            recentInteractions: []
+            recentMessages: dialogueMessages,
+            recentInteractions: [],
+            actionResults: actionResultMessages
           },
           values: {
             recentPosts: "",
             recentMessages: "",
             recentMessageInteractions: "",
             recentPostInteractions: "",
-            recentInteractions: ""
+            recentInteractions: "",
+            recentActionResults: actionResultsText
           },
           text: "No recent messages available"
         };
@@ -8262,8 +9595,8 @@ var recentMessagesProvider = {
       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(
+      const receivedMessageHeader = hasReceivedMessage ? addHeader9("# Received Message", `${senderName}: ${receivedMessageContent}`) : "";
+      const focusHeader = hasReceivedMessage ? addHeader9(
         "# 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.`
       ) : "";
@@ -8327,18 +9660,22 @@ var recentMessagesProvider = {
         getRecentPostInteractions(recentInteractionsData, entitiesData)
       ]);
       const data = {
-        recentMessages: recentMessagesData,
-        recentInteractions: recentInteractionsData
+        recentMessages: dialogueMessages,
+        recentInteractions: recentInteractionsData,
+        actionResults: actionResultMessages
       };
       const values = {
         recentPosts,
         recentMessages,
         recentMessageInteractions,
         recentPostInteractions,
-        recentInteractions: isPostFormat ? recentPostInteractions : recentMessageInteractions
+        recentInteractions: isPostFormat ? recentPostInteractions : recentMessageInteractions,
+        recentActionResults: actionResultsText
       };
       const text = [
         isPostFormat ? recentPosts : recentMessages,
+        actionResultsText,
+        // Include action results in the text output
         // 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 : ""
@@ -8349,18 +9686,20 @@ var recentMessagesProvider = {
         text
       };
     } catch (error) {
-      logger13.error("Error in recentMessagesProvider:", error);
+      logger15.error("Error in recentMessagesProvider:", error);
       return {
         data: {
           recentMessages: [],
-          recentInteractions: []
+          recentInteractions: [],
+          actionResults: []
         },
         values: {
           recentPosts: "",
           recentMessages: "",
           recentMessageInteractions: "",
           recentPostInteractions: "",
-          recentInteractions: ""
+          recentInteractions: "",
+          recentActionResults: ""
         },
         text: "Error retrieving recent messages."
         // Or 'No recent messages available' as the test expects
@@ -8456,7 +9795,7 @@ ${formattedRelationships}`
 import {
   ChannelType as ChannelType6,
   createUniqueUuid as createUniqueUuid2,
-  logger as logger14
+  logger as logger16
 } from "@elizaos/core";
 var roleProvider = {
   name: "ROLES",
@@ -8481,11 +9820,11 @@ var roleProvider = {
     if (!serverId) {
       throw new Error("No server ID found");
     }
-    logger14.info(`Using server ID: ${serverId}`);
+    logger16.info(`Using server ID: ${serverId}`);
     const worldId = createUniqueUuid2(runtime, serverId);
     const world = await runtime.getWorld(worldId);
     if (!world || !world.metadata?.ownership?.ownerId) {
-      logger14.info(
+      logger16.info(
         `No ownership data found for server ${serverId}, initializing empty role hierarchy`
       );
       return {
@@ -8500,7 +9839,7 @@ var roleProvider = {
     }
     const roles = world.metadata.roles || {};
     if (Object.keys(roles).length === 0) {
-      logger14.info(`No roles found for server ${serverId}`);
+      logger16.info(`No roles found for server ${serverId}`);
       return {
         data: {
           roles: []
@@ -8511,7 +9850,7 @@ var roleProvider = {
         text: "No role information available for this server."
       };
     }
-    logger14.info(`Found ${Object.keys(roles).length} roles`);
+    logger16.info(`Found ${Object.keys(roles).length} roles`);
     const owners = [];
     const admins = [];
     const members = [];
@@ -8525,7 +9864,7 @@ var roleProvider = {
         continue;
       }
       if (!name || !username || !names) {
-        logger14.warn(`User ${entityId} has no name or username, skipping`);
+        logger16.warn(`User ${entityId} has no name or username, skipping`);
         continue;
       }
       switch (userRole) {
@@ -8592,7 +9931,7 @@ import {
   ChannelType as ChannelType7,
   findWorldsForOwner as findWorldsForOwner2,
   getWorldSettings as getWorldSettings2,
-  logger as logger15
+  logger as logger17
 } from "@elizaos/core";
 var formatSettingValue = (setting, isOnboarding) => {
   if (setting.value === null) return "Not set";
@@ -8663,7 +10002,7 @@ ${requiredUnconfigured > 0 ? `IMPORTANT!: ${requiredUnconfigured} required setti
 **Value:** ${s?.value}
 **Description:** ${s?.description}`).join("\n\n")}`;
   } catch (error) {
-    logger15.error(`Error generating status message: ${error}`);
+    logger17.error(`Error generating status message: ${error}`);
     return "Error generating configuration status.";
   }
 }
@@ -8676,11 +10015,11 @@ var settingsProvider = {
         runtime.getRoom(message.roomId),
         findWorldsForOwner2(runtime, message.entityId)
       ]).catch((error) => {
-        logger15.error(`Error fetching initial data: ${error}`);
+        logger17.error(`Error fetching initial data: ${error}`);
         throw new Error("Failed to retrieve room or user world information");
       });
       if (!room) {
-        logger15.error("No room found for settings provider");
+        logger17.error("No room found for settings provider");
         return {
           data: {
             settings: []
@@ -8692,7 +10031,7 @@ var settingsProvider = {
         };
       }
       if (!room.worldId) {
-        logger15.debug("No world found for settings provider -- settings provider will be skipped");
+        logger17.debug("No world found for settings provider -- settings provider will be skipped");
         return {
           data: {
             settings: []
@@ -8717,39 +10056,39 @@ var settingsProvider = {
           }
           world.metadata.settings = {};
           await runtime.updateWorld(world);
-          logger15.info(`Initialized settings for user's world ${world.id}`);
+          logger17.info(`Initialized settings for user's world ${world.id}`);
         }
         if (!world) {
-          logger15.error("No world found for user during onboarding");
+          logger17.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) {
-          logger15.error(`Error fetching world settings: ${error}`);
+          logger17.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) {
-            logger15.error(`No world found for room ${room.worldId}`);
+            logger17.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 {
-            logger15.error(`No server ID found for world ${room.worldId}`);
+            logger17.error(`No server ID found for world ${room.worldId}`);
           }
         } catch (error) {
-          logger15.error(`Error processing world data: ${error}`);
+          logger17.error(`Error processing world data: ${error}`);
           throw new Error("Failed to process world information");
         }
       }
       if (!serverId) {
-        logger15.info(
+        logger17.info(
           `No server ownership found for user ${message.entityId} after recovery attempt`
         );
         return isOnboarding ? {
@@ -8771,7 +10110,7 @@ var settingsProvider = {
         };
       }
       if (!worldSettings) {
-        logger15.info(`No settings state found for server ${serverId}`);
+        logger17.info(`No settings state found for server ${serverId}`);
         return isOnboarding ? {
           data: {
             settings: []
@@ -8801,7 +10140,7 @@ var settingsProvider = {
         text: output
       };
     } catch (error) {
-      logger15.error(`Critical error in settings provider: ${error}`);
+      logger17.error(`Critical error in settings provider: ${error}`);
       return {
         data: {
           settings: []
@@ -8840,8 +10179,8 @@ var timeProvider = {
 
 // src/providers/world.ts
 import {
-  logger as logger16,
-  addHeader as addHeader9,
+  logger as logger18,
+  addHeader as addHeader10,
   ChannelType as ChannelType8
 } from "@elizaos/core";
 var worldProvider = {
@@ -8850,10 +10189,10 @@ var worldProvider = {
   dynamic: true,
   get: async (runtime, message) => {
     try {
-      logger16.debug("[\u{1F310}] World provider activated for roomId:", message.roomId);
+      logger18.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}`);
+        logger18.warn(`World provider: Room not found for roomId ${message.roomId}`);
         return {
           data: {
             world: {
@@ -8863,10 +10202,10 @@ var worldProvider = {
           text: "Unable to retrieve world information - room not found"
         };
       }
-      logger16.debug(`[\u{1F310}] World provider: Found room "${currentRoom.name}" (${currentRoom.type})`);
+      logger18.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}`);
+        logger18.warn(`World provider: World ID not found for roomId ${message.roomId}`);
         return {
           data: {
             world: {
@@ -8878,7 +10217,7 @@ var worldProvider = {
       }
       const world = await runtime.getWorld(worldId);
       if (!world) {
-        logger16.warn(`World provider: World not found for worldId ${worldId}`);
+        logger18.warn(`World provider: World not found for worldId ${worldId}`);
         return {
           data: {
             world: {
@@ -8888,13 +10227,13 @@ var worldProvider = {
           text: "Unable to retrieve world information - world not found"
         };
       }
-      logger16.debug(`[\u{1F310}] World provider: Found world "${world.name}" (ID: ${world.id})`);
+      logger18.debug(`[\u{1F310}] World provider: Found world "${world.name}" (ID: ${world.id})`);
       const worldRooms = await runtime.getRooms(worldId);
-      logger16.debug(
+      logger18.debug(
         `[\u{1F310}] World provider: Found ${worldRooms.length} rooms in world "${world.name}"`
       );
       const participants = await runtime.getParticipantsForRoom(message.roomId);
-      logger16.debug(
+      logger18.debug(
         `[\u{1F310}] World provider: Found ${participants.length} participants in room "${currentRoom.name}"`
       );
       const channelsByType = {
@@ -8907,7 +10246,7 @@ var worldProvider = {
       };
       for (const room of worldRooms) {
         if (!room?.id || !room.name) {
-          logger16.warn(`World provider: Room ID or name is missing for room ${room.id}`);
+          logger18.warn(`World provider: Room ID or name is missing for room ${room.id}`);
           continue;
         }
         const roomInfo = {
@@ -8975,15 +10314,15 @@ var worldProvider = {
         currentChannelName: currentRoom.name,
         worldInfo: worldInfoText
       };
-      const formattedText = addHeader9("# World Information", worldInfoText);
-      logger16.debug("[\u{1F310}] World provider completed successfully");
+      const formattedText = addHeader10("# World Information", worldInfoText);
+      logger18.debug("[\u{1F310}] World provider completed successfully");
       return {
         data,
         values,
         text: formattedText
       };
     } catch (error) {
-      logger16.error(
+      logger18.error(
         `Error in world provider: ${error instanceof Error ? error.message : String(error)}`
       );
       return {
@@ -9001,7 +10340,7 @@ var worldProvider = {
 
 // src/services/task.ts
 import {
-  logger as logger17,
+  logger as logger19,
   Service,
   ServiceType
 } from "@elizaos/core";
@@ -9029,21 +10368,21 @@ var TaskService = class _TaskService extends Service {
     this.runtime.registerTaskWorker({
       name: "REPEATING_TEST_TASK",
       validate: async (_runtime, _message, _state) => {
-        logger17.debug("[Bootstrap] Validating repeating test task");
+        logger19.debug("[Bootstrap] Validating repeating test task");
         return true;
       },
       execute: async (_runtime, _options) => {
-        logger17.debug("[Bootstrap] Executing repeating test task");
+        logger19.debug("[Bootstrap] Executing repeating test task");
       }
     });
     this.runtime.registerTaskWorker({
       name: "ONETIME_TEST_TASK",
       validate: async (_runtime, _message, _state) => {
-        logger17.debug("[Bootstrap] Validating one-time test task");
+        logger19.debug("[Bootstrap] Validating one-time test task");
         return true;
       },
       execute: async (_runtime, _options) => {
-        logger17.debug("[Bootstrap] Executing one-time test task");
+        logger19.debug("[Bootstrap] Executing one-time test task");
       }
     });
     const tasks = await this.runtime.getTasksByName("REPEATING_TEST_TASK");
@@ -9080,7 +10419,7 @@ var TaskService = class _TaskService extends Service {
       try {
         await this.checkTasks();
       } catch (error) {
-        logger17.error("[Bootstrap] Error checking tasks:", error);
+        logger19.error("[Bootstrap] Error checking tasks:", error);
       }
     }, this.TICK_INTERVAL);
   }
@@ -9109,7 +10448,7 @@ var TaskService = class _TaskService extends Service {
             continue;
           }
         } catch (error) {
-          logger17.error(`[Bootstrap] Error validating task ${task.name}:`, error);
+          logger19.error(`[Bootstrap] Error validating task ${task.name}:`, error);
           continue;
         }
       }
@@ -9151,20 +10490,20 @@ var TaskService = class _TaskService extends Service {
         }
         if (task.metadata?.updatedAt === task.metadata?.createdAt) {
           if (task.tags?.includes("immediate")) {
-            logger17.debug("[Bootstrap] Immediately running task", task.name);
+            logger19.debug("[Bootstrap] Immediately running task", task.name);
             await this.executeTask(task);
             continue;
           }
         }
         if (now - taskStartTime >= updateIntervalMs) {
-          logger17.debug(
+          logger19.debug(
             `[Bootstrap] Executing task ${task.name} - interval of ${updateIntervalMs}ms has elapsed`
           );
           await this.executeTask(task);
         }
       }
     } catch (error) {
-      logger17.error("[Bootstrap] Error checking tasks:", error);
+      logger19.error("[Bootstrap] Error checking tasks:", error);
     }
   }
   /**
@@ -9175,12 +10514,12 @@ var TaskService = class _TaskService extends Service {
   async executeTask(task) {
     try {
       if (!task || !task.id) {
-        logger17.debug(`[Bootstrap] Task not found`);
+        logger19.debug(`[Bootstrap] Task not found`);
         return;
       }
       const worker = this.runtime.getTaskWorker(task.name);
       if (!worker) {
-        logger17.debug(`[Bootstrap] No worker found for task type: ${task.name}`);
+        logger19.debug(`[Bootstrap] No worker found for task type: ${task.name}`);
         return;
       }
       if (task.tags?.includes("repeat")) {
@@ -9190,20 +10529,20 @@ var TaskService = class _TaskService extends Service {
             updatedAt: Date.now()
           }
         });
-        logger17.debug(
+        logger19.debug(
           `[Bootstrap] Updated repeating task ${task.name} (${task.id}) with new timestamp`
         );
       }
-      logger17.debug(`[Bootstrap] Executing task ${task.name} (${task.id})`);
+      logger19.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);
-        logger17.debug(
+        logger19.debug(
           `[Bootstrap] Deleted non-repeating task ${task.name} (${task.id}) after execution`
         );
       }
     } catch (error) {
-      logger17.error(`[Bootstrap] Error executing task ${task.id}:`, error);
+      logger19.error(`[Bootstrap] Error executing task ${task.id}:`, error);
     }
   }
   /**
@@ -10416,7 +11755,7 @@ async function processAttachments(attachments, runtime) {
   if (!attachments || attachments.length === 0) {
     return [];
   }
-  logger18.debug(`[Bootstrap] Processing ${attachments.length} attachment(s)`);
+  logger20.debug(`[Bootstrap] Processing ${attachments.length} attachment(s)`);
   const processedAttachments = [];
   for (const attachment of attachments) {
     try {
@@ -10424,7 +11763,7 @@ async function processAttachments(attachments, runtime) {
       const isRemote = /^(http|https):\/\//.test(attachment.url);
       const url = isRemote ? attachment.url : getLocalServerUrl(attachment.url);
       if (attachment.contentType === ContentType2.IMAGE && !attachment.description) {
-        logger18.debug(`[Bootstrap] Generating description for image: ${attachment.url}`);
+        logger20.debug(`[Bootstrap] Generating description for image: ${attachment.url}`);
         let imageUrl = url;
         if (!isRemote) {
           const res = await lib_default(url);
@@ -10444,24 +11783,24 @@ async function processAttachments(attachments, runtime) {
               processedAttachment.description = parsedXml.description;
               processedAttachment.title = parsedXml.title || "Image";
               processedAttachment.text = parsedXml.text;
-              logger18.debug(
+              logger20.debug(
                 `[Bootstrap] Generated description: ${processedAttachment.description?.substring(0, 100)}...`
               );
             } else {
-              logger18.warn(`[Bootstrap] Failed to parse XML response for image description`);
+              logger20.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;
-            logger18.debug(
+            logger20.debug(
               `[Bootstrap] Generated description: ${processedAttachment.description?.substring(0, 100)}...`
             );
           } else {
-            logger18.warn(`[Bootstrap] Unexpected response format for image description`);
+            logger20.warn(`[Bootstrap] Unexpected response format for image description`);
           }
         } catch (error) {
-          logger18.error(`[Bootstrap] Error generating image description:`, error);
+          logger20.error(`[Bootstrap] Error generating image description:`, error);
         }
       } else if (attachment.contentType === ContentType2.DOCUMENT && !attachment.text) {
         const res = await lib_default(url);
@@ -10469,20 +11808,20 @@ async function processAttachments(attachments, runtime) {
         const contentType = res.headers.get("content-type") || "";
         const isPlainText = contentType.startsWith("text/plain");
         if (isPlainText) {
-          logger18.debug(`[Bootstrap] Processing plain text document: ${attachment.url}`);
+          logger20.debug(`[Bootstrap] Processing plain text document: ${attachment.url}`);
           const textContent = await res.text();
           processedAttachment.text = textContent;
           processedAttachment.title = processedAttachment.title || "Text File";
-          logger18.debug(
+          logger20.debug(
             `[Bootstrap] Extracted text content (first 100 chars): ${processedAttachment.text?.substring(0, 100)}...`
           );
         } else {
-          logger18.warn(`[Bootstrap] Skipping non-plain-text document: ${contentType}`);
+          logger20.warn(`[Bootstrap] Skipping non-plain-text document: ${contentType}`);
         }
       }
       processedAttachments.push(processedAttachment);
     } catch (error) {
-      logger18.error(`[Bootstrap] Failed to process attachment ${attachment.url}:`, error);
+      logger20.error(`[Bootstrap] Failed to process attachment ${attachment.url}:`, error);
       processedAttachments.push(attachment);
     }
   }
@@ -10527,7 +11866,7 @@ var messageReceivedHandler = async ({
   const timeoutDuration = 60 * 60 * 1e3;
   let timeoutId = void 0;
   try {
-    logger18.info(`[Bootstrap] Message received from ${message.entityId} in room ${message.roomId}`);
+    logger20.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());
@@ -10570,13 +11909,13 @@ var messageReceivedHandler = async ({
     const processingPromise = (async () => {
       try {
         if (message.entityId === runtime.agentId) {
-          logger18.debug(`[Bootstrap] Skipping message from self (${runtime.agentId})`);
+          logger20.debug(`[Bootstrap] Skipping message from self (${runtime.agentId})`);
           throw new Error("Message is from the agent itself");
         }
-        logger18.debug(
+        logger20.debug(
           `[Bootstrap] Processing message: ${truncateToCompleteSentence(message.content.text || "", 50)}...`
         );
-        logger18.debug("[Bootstrap] Saving message to memory and embeddings");
+        logger20.debug("[Bootstrap] Saving message to memory and embeddings");
         await Promise.all([
           runtime.addEmbeddingToMemory(message),
           runtime.createMemory(message, "messages")
@@ -10586,7 +11925,7 @@ var messageReceivedHandler = async ({
           runtime.agentId
         );
         if (agentUserState === "MUTED" && !message.content.text?.toLowerCase().includes(runtime.character.name.toLowerCase())) {
-          logger18.debug(`[Bootstrap] Ignoring muted room ${message.roomId}`);
+          logger20.debug(`[Bootstrap] Ignoring muted room ${message.roomId}`);
           return;
         }
         let state = await runtime.composeState(
@@ -10618,24 +11957,24 @@ var messageReceivedHandler = async ({
             state,
             template: runtime.character.templates?.shouldRespondTemplate || shouldRespondTemplate
           });
-          logger18.debug(
+          logger20.debug(
             `[Bootstrap] Evaluating response for ${runtime.character.name}
 Prompt: ${shouldRespondPrompt}`
           );
           const response = await runtime.useModel(ModelType14.TEXT_SMALL, {
             prompt: shouldRespondPrompt
           });
-          logger18.debug(
+          logger20.debug(
             `[Bootstrap] Response evaluation for ${runtime.character.name}:
 ${response}`
           );
-          logger18.debug(`[Bootstrap] Response type: ${typeof response}`);
+          logger20.debug(`[Bootstrap] Response type: ${typeof response}`);
           const responseObject = parseKeyValueXml(response);
-          logger18.debug("[Bootstrap] Parsed response:", responseObject);
+          logger20.debug("[Bootstrap] Parsed response:", responseObject);
           const nonResponseActions = ["IGNORE", "NONE"];
           shouldRespond = responseObject?.action && !nonResponseActions.includes(responseObject.action.toUpperCase());
         } else {
-          logger18.debug(
+          logger20.debug(
             `[Bootstrap] Skipping shouldRespond check for ${runtime.character.name} because ${room?.type} ${room?.source}`
           );
           shouldRespond = true;
@@ -10646,7 +11985,7 @@ ${response}`
         if (shouldRespond) {
           state = await runtime.composeState(message, ["ACTIONS"]);
           if (!state.values.actionNames) {
-            logger18.warn("actionNames data missing from state, even though it was requested");
+            logger20.warn("actionNames data missing from state, even though it was requested");
           }
           const prompt = composePromptFromState10({
             state,
@@ -10659,9 +11998,9 @@ ${response}`
             let response = await runtime.useModel(ModelType14.TEXT_LARGE, {
               prompt
             });
-            logger18.debug("[Bootstrap] *** Raw LLM Response ***\n", response);
+            logger20.debug("[Bootstrap] *** Raw LLM Response ***\n", response);
             const parsedXml = parseKeyValueXml(response);
-            logger18.debug("[Bootstrap] *** Parsed XML Content ***\n", parsedXml);
+            logger20.debug("[Bootstrap] *** Parsed XML Content ***\n", parsedXml);
             if (parsedXml) {
               responseContent = {
                 ...parsedXml,
@@ -10676,7 +12015,7 @@ ${response}`
             }
             retries++;
             if (!responseContent?.thought || !responseContent?.actions) {
-              logger18.warn(
+              logger20.warn(
                 "[Bootstrap] *** Missing required fields (thought or actions), retrying... ***\n",
                 response,
                 parsedXml,
@@ -10686,14 +12025,34 @@ ${response}`
           }
           const currentResponseId = agentResponses.get(message.roomId);
           if (currentResponseId !== responseId) {
-            logger18.info(
+            logger20.info(
               `Response discarded - newer message being processed for agent: ${runtime.agentId}, room: ${message.roomId}`
             );
             return;
           }
           if (responseContent && message.id) {
             responseContent.inReplyTo = createUniqueUuid3(runtime, message.id);
-            const isSimple = responseContent.actions?.length === 1 && responseContent.actions[0].toUpperCase() === "REPLY" && (!responseContent.providers || responseContent.providers.length === 0);
+            if (responseContent.actions && responseContent.actions.length > 1) {
+              const isIgnoreAction = (action) => {
+                return typeof action === "string" && action.toUpperCase() === "IGNORE";
+              };
+              const hasIgnoreAction = responseContent.actions.some(isIgnoreAction);
+              if (hasIgnoreAction) {
+                if (!responseContent.text || responseContent.text.trim() === "") {
+                  responseContent.actions = ["IGNORE"];
+                } else {
+                  const filteredActions = responseContent.actions.filter(
+                    (action) => !isIgnoreAction(action)
+                  );
+                  if (filteredActions.length === 0) {
+                    responseContent.actions = ["REPLY"];
+                  } else {
+                    responseContent.actions = filteredActions;
+                  }
+                }
+              }
+            }
+            const isSimple = responseContent.actions?.length === 1 && typeof responseContent.actions[0] === "string" && responseContent.actions[0].toUpperCase() === "REPLY" && (!responseContent.providers || responseContent.providers.length === 0);
             responseContent.simple = isSimple;
             const responseMessage = {
               id: asUUID(v4_default()),
@@ -10714,7 +12073,7 @@ ${response}`
           }
           if (responseContent && responseContent.simple && responseContent.text) {
             if (responseContent.providers && responseContent.providers.length > 0) {
-              logger18.debug("[Bootstrap] Simple response used providers", responseContent.providers);
+              logger20.debug("[Bootstrap] Simple response used providers", responseContent.providers);
             }
             await callback(responseContent);
           } else {
@@ -10722,16 +12081,16 @@ ${response}`
           }
           await runtime.evaluate(message, state, shouldRespond, callback, responseMessages);
         } else {
-          logger18.debug("[Bootstrap] Agent decided not to respond (shouldRespond is false).");
+          logger20.debug("[Bootstrap] Agent decided not to respond (shouldRespond is false).");
           const currentResponseId = agentResponses.get(message.roomId);
           if (currentResponseId !== responseId) {
-            logger18.info(
+            logger20.info(
               `Ignore response discarded - newer message being processed for agent: ${runtime.agentId}, room: ${message.roomId}`
             );
             return;
           }
           if (!message.id) {
-            logger18.error("[Bootstrap] Message ID is missing, cannot create ignore response.");
+            logger20.error("[Bootstrap] Message ID is missing, cannot create ignore response.");
             return;
           }
           const ignoreContent = {
@@ -10752,7 +12111,7 @@ ${response}`
             createdAt: Date.now()
           };
           await runtime.createMemory(ignoreMemory, "messages");
-          logger18.debug("[Bootstrap] Saved ignore response to memory", {
+          logger20.debug("[Bootstrap] Saved ignore response to memory", {
             memoryId: ignoreMemory.id
           });
           agentResponses.delete(message.roomId);
@@ -10803,10 +12162,10 @@ var reactionReceivedHandler = async ({
     await runtime.createMemory(message, "messages");
   } catch (error) {
     if (error.code === "23505") {
-      logger18.warn("[Bootstrap] Duplicate reaction memory, skipping");
+      logger20.warn("[Bootstrap] Duplicate reaction memory, skipping");
       return;
     }
-    logger18.error("[Bootstrap] Error in reaction handler:", error);
+    logger20.error("[Bootstrap] Error in reaction handler:", error);
   }
 };
 var messageDeletedHandler = async ({
@@ -10815,14 +12174,14 @@ var messageDeletedHandler = async ({
 }) => {
   try {
     if (!message.id) {
-      logger18.error("[Bootstrap] Cannot delete memory: message ID is missing");
+      logger20.error("[Bootstrap] Cannot delete memory: message ID is missing");
       return;
     }
-    logger18.info("[Bootstrap] Deleting memory for message", message.id, "from room", message.roomId);
+    logger20.info("[Bootstrap] Deleting memory for message", message.id, "from room", message.roomId);
     await runtime.deleteMemory(message.id);
-    logger18.debug("[Bootstrap] Successfully deleted memory for message", message.id);
+    logger20.debug("[Bootstrap] Successfully deleted memory for message", message.id);
   } catch (error) {
-    logger18.error("[Bootstrap] Error in message deleted handler:", error);
+    logger20.error("[Bootstrap] Error in message deleted handler:", error);
   }
 };
 var channelClearedHandler = async ({
@@ -10832,7 +12191,7 @@ var channelClearedHandler = async ({
   memoryCount
 }) => {
   try {
-    logger18.info(
+    logger20.info(
       `[Bootstrap] Clearing ${memoryCount} message memories from channel ${channelId} -> room ${roomId}`
     );
     const memories = await runtime.getMemoriesByRoomIds({
@@ -10846,15 +12205,15 @@ var channelClearedHandler = async ({
           await runtime.deleteMemory(memory.id);
           deletedCount++;
         } catch (error) {
-          logger18.warn(`[Bootstrap] Failed to delete message memory ${memory.id}:`, error);
+          logger20.warn(`[Bootstrap] Failed to delete message memory ${memory.id}:`, error);
         }
       }
     }
-    logger18.info(
+    logger20.info(
       `[Bootstrap] Successfully cleared ${deletedCount}/${memories.length} message memories from channel ${channelId}`
     );
   } catch (error) {
-    logger18.error("[Bootstrap] Error in channel cleared handler:", error);
+    logger20.error("[Bootstrap] Error in channel cleared handler:", error);
   }
 };
 var postGeneratedHandler = async ({
@@ -10865,7 +12224,7 @@ var postGeneratedHandler = async ({
   roomId,
   source
 }) => {
-  logger18.info("[Bootstrap] Generating new post...");
+  logger20.info("[Bootstrap] Generating new post...");
   await runtime.ensureWorldExists({
     id: worldId,
     name: `${runtime.character.name}'s Feed`,
@@ -10929,7 +12288,7 @@ var postGeneratedHandler = async ({
     }
     retries++;
     if (!responseContent?.thought || !responseContent?.actions) {
-      logger18.warn(
+      logger20.warn(
         "[Bootstrap] *** Missing required fields, retrying... ***\n",
         response,
         parsedXml,
@@ -10947,7 +12306,7 @@ var postGeneratedHandler = async ({
   });
   const parsedXmlResponse = parseKeyValueXml(xmlResponseText);
   if (!parsedXmlResponse) {
-    logger18.error(
+    logger20.error(
       "[Bootstrap] Failed to parse XML response for post creation. Raw response:",
       xmlResponseText
     );
@@ -10964,7 +12323,7 @@ var postGeneratedHandler = async ({
   if (RM) {
     for (const m of RM.data.recentMessages) {
       if (cleanedText === m.content.text) {
-        logger18.log("[Bootstrap] Already recently posted that, retrying", cleanedText);
+        logger20.log("[Bootstrap] Already recently posted that, retrying", cleanedText);
         postGeneratedHandler({
           runtime,
           callback,
@@ -10982,7 +12341,7 @@ var postGeneratedHandler = async ({
   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)) {
-    logger18.log("[Bootstrap] Got prompt moderation refusal, retrying", cleanedText);
+    logger20.log("[Bootstrap] Got prompt moderation refusal, retrying", cleanedText);
     postGeneratedHandler({
       runtime,
       callback,
@@ -11016,9 +12375,9 @@ var postGeneratedHandler = async ({
 var syncSingleUser = async (entityId, runtime, serverId, channelId, type, source) => {
   try {
     const entity = await runtime.getEntityById(entityId);
-    logger18.info(`[Bootstrap] Syncing user: ${entity?.metadata?.username || entityId}`);
+    logger20.info(`[Bootstrap] Syncing user: ${entity?.metadata?.username || entityId}`);
     if (!channelId) {
-      logger18.warn(`[Bootstrap] Cannot sync user ${entity?.id} without a valid channelId`);
+      logger20.warn(`[Bootstrap] Cannot sync user ${entity?.id} without a valid channelId`);
       return;
     }
     const roomId = createUniqueUuid3(runtime, channelId);
@@ -11033,7 +12392,7 @@ var syncSingleUser = async (entityId, runtime, serverId, channelId, type, source
       settings: {}
       // Initialize empty settings for onboarding
     } : void 0;
-    logger18.info(
+    logger20.info(
       `[Bootstrap] syncSingleUser - type: ${type}, isDM: ${type === ChannelType9.DM}, worldMetadata: ${JSON.stringify(worldMetadata)}`
     );
     await runtime.ensureConnection({
@@ -11049,15 +12408,15 @@ var syncSingleUser = async (entityId, runtime, serverId, channelId, type, source
     });
     try {
       const createdWorld = await runtime.getWorld(worldId);
-      logger18.info(
+      logger20.info(
         `[Bootstrap] Created world check - ID: ${worldId}, metadata: ${JSON.stringify(createdWorld?.metadata)}`
       );
     } catch (error) {
-      logger18.error(`[Bootstrap] Failed to verify created world: ${error}`);
+      logger20.error(`[Bootstrap] Failed to verify created world: ${error}`);
     }
-    logger18.success(`[Bootstrap] Successfully synced user: ${entity?.id}`);
+    logger20.success(`[Bootstrap] Successfully synced user: ${entity?.id}`);
   } catch (error) {
-    logger18.error(
+    logger20.error(
       `[Bootstrap] Error syncing user: ${error instanceof Error ? error.message : String(error)}`
     );
   }
@@ -11070,13 +12429,13 @@ var handleServerSync = async ({
   source,
   onComplete
 }) => {
-  logger18.debug(`[Bootstrap] Handling server sync event for server: ${world.name}`);
+  logger20.debug(`[Bootstrap] Handling server sync event for server: ${world.name}`);
   try {
     await runtime.ensureConnections(entities, rooms, source, world);
-    logger18.debug(`Successfully synced standardized world structure for ${world.name}`);
+    logger20.debug(`Successfully synced standardized world structure for ${world.name}`);
     onComplete?.();
   } catch (error) {
-    logger18.error(
+    logger20.error(
       `Error processing standardized server data: ${error instanceof Error ? error.message : String(error)}`
     );
   }
@@ -11086,7 +12445,7 @@ var controlMessageHandler = async ({
   message
 }) => {
   try {
-    logger18.debug(
+    logger20.debug(
       `[controlMessageHandler] Processing control message: ${message.payload.action} for room ${message.roomId}`
     );
     const serviceNames = Array.from(runtime.getAllServices().keys());
@@ -11104,24 +12463,24 @@ var controlMessageHandler = async ({
             roomId: message.roomId
           }
         });
-        logger18.debug(
+        logger20.debug(
           `[controlMessageHandler] Control message ${message.payload.action} sent successfully`
         );
       } else {
-        logger18.error("[controlMessageHandler] WebSocket service does not have sendMessage method");
+        logger20.error("[controlMessageHandler] WebSocket service does not have sendMessage method");
       }
     } else {
-      logger18.error("[controlMessageHandler] No WebSocket service found to send control message");
+      logger20.error("[controlMessageHandler] No WebSocket service found to send control message");
     }
   } catch (error) {
-    logger18.error(`[controlMessageHandler] Error processing control message: ${error}`);
+    logger20.error(`[controlMessageHandler] Error processing control message: ${error}`);
   }
 };
 var events = {
   [EventType.MESSAGE_RECEIVED]: [
     async (payload) => {
       if (!payload.callback) {
-        logger18.error("No callback provided for message");
+        logger20.error("No callback provided for message");
         return;
       }
       await messageReceivedHandler({
@@ -11135,7 +12494,7 @@ var events = {
   [EventType.VOICE_MESSAGE_RECEIVED]: [
     async (payload) => {
       if (!payload.callback) {
-        logger18.error("No callback provided for voice message");
+        logger20.error("No callback provided for voice message");
         return;
       }
       await messageReceivedHandler({
@@ -11161,7 +12520,7 @@ var events = {
   ],
   [EventType.MESSAGE_SENT]: [
     async (payload) => {
-      logger18.debug(`[Bootstrap] Message sent: ${payload.message.content.text}`);
+      logger20.debug(`[Bootstrap] Message sent: ${payload.message.content.text}`);
     }
   ],
   [EventType.MESSAGE_DELETED]: [
@@ -11194,17 +12553,17 @@ var events = {
   ],
   [EventType.ENTITY_JOINED]: [
     async (payload) => {
-      logger18.debug(`[Bootstrap] ENTITY_JOINED event received for entity ${payload.entityId}`);
+      logger20.debug(`[Bootstrap] ENTITY_JOINED event received for entity ${payload.entityId}`);
       if (!payload.worldId) {
-        logger18.error("[Bootstrap] No worldId provided for entity joined");
+        logger20.error("[Bootstrap] No worldId provided for entity joined");
         return;
       }
       if (!payload.roomId) {
-        logger18.error("[Bootstrap] No roomId provided for entity joined");
+        logger20.error("[Bootstrap] No roomId provided for entity joined");
         return;
       }
       if (!payload.metadata?.type) {
-        logger18.error("[Bootstrap] No type provided for entity joined");
+        logger20.error("[Bootstrap] No type provided for entity joined");
         return;
       }
       await syncSingleUser(
@@ -11229,26 +12588,26 @@ var events = {
           };
           await payload.runtime.updateEntity(entity);
         }
-        logger18.info(`[Bootstrap] User ${payload.entityId} left world ${payload.worldId}`);
+        logger20.info(`[Bootstrap] User ${payload.entityId} left world ${payload.worldId}`);
       } catch (error) {
-        logger18.error(`[Bootstrap] Error handling user left: ${error.message}`);
+        logger20.error(`[Bootstrap] Error handling user left: ${error.message}`);
       }
     }
   ],
   [EventType.ACTION_STARTED]: [
     async (payload) => {
-      logger18.debug(`[Bootstrap] Action started: ${payload.actionName} (${payload.actionId})`);
+      logger20.debug(`[Bootstrap] Action started: ${payload.actionName} (${payload.actionId})`);
     }
   ],
   [EventType.ACTION_COMPLETED]: [
     async (payload) => {
       const status = payload.error ? `failed: ${payload.error.message}` : "completed";
-      logger18.debug(`[Bootstrap] Action ${status}: ${payload.actionName} (${payload.actionId})`);
+      logger20.debug(`[Bootstrap] Action ${status}: ${payload.actionName} (${payload.actionId})`);
     }
   ],
   [EventType.EVALUATOR_STARTED]: [
     async (payload) => {
-      logger18.debug(
+      logger20.debug(
         `[Bootstrap] Evaluator started: ${payload.evaluatorName} (${payload.evaluatorId})`
       );
     }
@@ -11256,7 +12615,7 @@ var events = {
   [EventType.EVALUATOR_COMPLETED]: [
     async (payload) => {
       const status = payload.error ? `failed: ${payload.error.message}` : "completed";
-      logger18.debug(
+      logger20.debug(
         `[Bootstrap] Evaluator ${status}: ${payload.evaluatorName} (${payload.evaluatorId})`
       );
     }
@@ -11298,6 +12657,7 @@ var bootstrapPlugin = {
     attachmentsProvider,
     providersProvider,
     actionsProvider,
+    actionStateProvider,
     characterProvider,
     recentMessagesProvider,
     worldProvider
@@ -11306,6 +12666,7 @@ var bootstrapPlugin = {
 };
 var index_default = bootstrapPlugin;
 export {
+  actionStateProvider,
   actionsProvider,
   anxietyProvider,
   attachmentsProvider,