@elizaos/plugin-bootstrap 1.0.0-beta.48 → 1.0.0-beta.50

package/dist/index.js

@@ -76,7 +76,7 @@ import {
   composePromptFromState as composePromptFromState9,
   createUniqueUuid as createUniqueUuid4,
   EventType as EventType2,
-  logger as logger17,
+  logger as logger19,
   messageHandlerTemplate,
   ModelType as ModelType13,
   postCreationTemplate,
@@ -174,6 +174,10 @@ var choiceAction = {
   similes: ["SELECT_OPTION", "SELECT", "PICK", "CHOOSE"],
   description: "Selects an option for a pending task that has multiple options",
   validate: async (runtime, message, state) => {
+    if (!state) {
+      logger.error("State is required for validating the action");
+      throw new Error("State is required for validating the action");
+    }
     const pendingTasks = await runtime.getTasks({
       roomId: message.roomId,
       tags: ["AWAITING_CHOICE"]
@@ -186,121 +190,120 @@ var choiceAction = {
     return pendingTasks && pendingTasks.length > 0 && pendingTasks.some((task) => task.metadata?.options);
   },
   handler: async (runtime, message, state, _options, callback, responses) => {
-    try {
-      const pendingTasks = await runtime.getTasks({
-        roomId: message.roomId,
-        tags: ["AWAITING_CHOICE"]
-      });
-      if (!pendingTasks?.length) {
-        throw new Error("No pending tasks with options found");
+    const pendingTasks = await runtime.getTasks({
+      roomId: message.roomId,
+      tags: ["AWAITING_CHOICE"]
+    });
+    if (!pendingTasks?.length) {
+      throw new Error("No pending tasks with options found");
+    }
+    const tasksWithOptions = pendingTasks.filter((task) => task.metadata?.options);
+    if (!tasksWithOptions.length) {
+      throw new Error("No tasks currently have options to select from.");
+    }
+    const formattedTasks = tasksWithOptions.map((task) => {
+      const shortId = task.id?.substring(0, 8);
+      return {
+        taskId: shortId,
+        fullId: task.id,
+        name: task.name,
+        options: task.metadata?.options?.map((opt) => ({
+          name: typeof opt === "string" ? opt : opt.name,
+          description: typeof opt === "string" ? opt : opt.description || opt.name
+        }))
+      };
+    });
+    const tasksString = formattedTasks.map((task) => {
+      return `Task ID: ${task.taskId} - ${task.name}
+Available options:
+${task.options?.map((opt) => `- ${opt.name}: ${opt.description}`).join("\n")}`;
+    }).join("\n");
+    const prompt = composePrompt({
+      state: {
+        tasks: tasksString,
+        recentMessages: message.content.text || ""
+      },
+      template: optionExtractionTemplate
+    });
+    const result = await runtime.useModel(ModelType.TEXT_SMALL, {
+      prompt,
+      stopSequences: []
+    });
+    const parsed = parseJSONObjectFromText(result);
+    const { taskId, selectedOption } = parsed;
+    if (taskId && selectedOption) {
+      const taskMap = new Map(formattedTasks.map((task) => [task.taskId, task]));
+      const taskInfo = taskMap.get(taskId);
+      if (!taskInfo) {
+        await callback?.({
+          text: `Could not find a task matching ID: ${taskId}. Please try again.`,
+          actions: ["SELECT_OPTION_ERROR"],
+          source: message.content.source
+        });
+        return;
       }
-      const tasksWithOptions = pendingTasks.filter((task) => task.metadata?.options);
-      if (!tasksWithOptions.length) {
-        throw new Error("No tasks currently have options to select from.");
+      const selectedTask = tasksWithOptions.find((task) => task.id === taskInfo.fullId);
+      if (!selectedTask) {
+        await callback?.({
+          text: "Error locating the selected task. Please try again.",
+          actions: ["SELECT_OPTION_ERROR"],
+          source: message.content.source
+        });
+        return;
       }
-      const formattedTasks = tasksWithOptions.map((task) => {
-        const shortId = task.id.substring(0, 8);
-        return {
-          taskId: shortId,
-          fullId: task.id,
-          name: task.name,
-          options: task.metadata.options.map((opt) => ({
-            name: typeof opt === "string" ? opt : opt.name,
-            description: typeof opt === "string" ? opt : opt.description || opt.name
-          }))
-        };
-      });
-      const tasksString = formattedTasks.map((task) => {
-        return `Task ID: ${task.taskId} - ${task.name}
-Available options:
-${task.options.map((opt) => `- ${opt.name}: ${opt.description}`).join("\n")}`;
-      }).join("\n");
-      const prompt = composePrompt({
-        state: {
-          tasks: tasksString,
-          recentMessages: message.content.text
-        },
-        template: optionExtractionTemplate
-      });
-      const result = await runtime.useModel(ModelType.TEXT_SMALL, {
-        prompt,
-        stopSequences: []
-      });
-      const parsed = parseJSONObjectFromText(result);
-      const { taskId, selectedOption } = parsed;
-      if (taskId && selectedOption) {
-        const taskMap = new Map(formattedTasks.map((task) => [task.taskId, task]));
-        const taskInfo = taskMap.get(taskId);
-        if (!taskInfo) {
-          await callback({
-            text: `Could not find a task matching ID: ${taskId}. Please try again.`,
-            actions: ["SELECT_OPTION_ERROR"],
-            source: message.content.source
-          });
-          return;
-        }
-        const selectedTask = tasksWithOptions.find((task) => task.id === taskInfo.fullId);
-        if (!selectedTask) {
-          await callback({
+      if (selectedOption === "ABORT") {
+        if (!selectedTask?.id) {
+          await callback?.({
             text: "Error locating the selected task. Please try again.",
             actions: ["SELECT_OPTION_ERROR"],
             source: message.content.source
           });
           return;
         }
-        if (selectedOption === "ABORT") {
-          await runtime.deleteTask(selectedTask.id);
-          await callback({
-            text: `Task "${selectedTask.name}" has been cancelled.`,
-            actions: ["CHOOSE_OPTION_CANCELLED"],
-            source: message.content.source
-          });
-          return;
-        }
-        try {
-          const taskWorker = runtime.getTaskWorker(selectedTask.name);
-          await taskWorker.execute(runtime, { option: selectedOption }, selectedTask);
-          await callback({
-            text: `Selected option: ${selectedOption} for task: ${selectedTask.name}`,
-            actions: ["CHOOSE_OPTION"],
-            source: message.content.source
-          });
-          return;
-        } catch (error) {
-          logger.error("Error executing task with option:", error);
-          await callback({
-            text: "There was an error processing your selection.",
-            actions: ["SELECT_OPTION_ERROR"],
-            source: message.content.source
-          });
-          return;
-        }
+        await runtime.deleteTask(selectedTask.id);
+        await callback?.({
+          text: `Task "${selectedTask.name}" has been cancelled.`,
+          actions: ["CHOOSE_OPTION_CANCELLED"],
+          source: message.content.source
+        });
+        return;
+      }
+      try {
+        const taskWorker = runtime.getTaskWorker(selectedTask.name);
+        await taskWorker?.execute(runtime, { option: selectedOption }, selectedTask);
+        await callback?.({
+          text: `Selected option: ${selectedOption} for task: ${selectedTask.name}`,
+          actions: ["CHOOSE_OPTION"],
+          source: message.content.source
+        });
+        return;
+      } catch (error) {
+        logger.error("Error executing task with option:", error);
+        await callback?.({
+          text: "There was an error processing your selection.",
+          actions: ["SELECT_OPTION_ERROR"],
+          source: message.content.source
+        });
+        return;
       }
-      let optionsText = "Please select a valid option from one of these tasks:\n\n";
-      tasksWithOptions.forEach((task) => {
-        const shortId = task.id.substring(0, 8);
-        optionsText += `**${task.name}** (ID: ${shortId}):
-`;
-        const options = task.metadata.options.map(
-          (opt) => typeof opt === "string" ? opt : opt.name
-        );
-        options.push("ABORT");
-        optionsText += options.map((opt) => `- ${opt}`).join("\n");
-        optionsText += "\n\n";
-      });
-      await callback({
-        text: optionsText,
-        actions: ["SELECT_OPTION_INVALID"],
-        source: message.content.source
-      });
-    } catch (error) {
-      logger.error("Error in select option handler:", error);
-      await callback({
-        text: "There was an error processing the option selection.",
-        actions: ["SELECT_OPTION_ERROR"],
-        source: message.content.source
-      });
     }
+    let optionsText = "Please select a valid option from one of these tasks:\n\n";
+    tasksWithOptions.forEach((task) => {
+      const shortId = task.id?.substring(0, 8);
+      optionsText += `**${task.name}** (ID: ${shortId}):
+`;
+      const options = task.metadata?.options?.map(
+        (opt) => typeof opt === "string" ? opt : opt.name
+      );
+      options?.push("ABORT");
+      optionsText += options?.map((opt) => `- ${opt}`).join("\n");
+      optionsText += "\n\n";
+    });
+    await callback?.({
+      text: optionsText,
+      actions: ["SELECT_OPTION_INVALID"],
+      source: message.content.source
+    });
   },
   examples: [
     [
@@ -369,6 +372,10 @@ var followRoomAction = {
     return roomState !== "FOLLOWED" && roomState !== "MUTED";
   },
   handler: async (runtime, message, state, _options, _callback, _responses) => {
+    if (!state) {
+      logger2.error("State is required for followRoomAction");
+      throw new Error("State is required for followRoomAction");
+    }
     async function _shouldFollow(state2) {
       const shouldFollowPrompt = composePromptFromState({
         state: state2,
@@ -965,6 +972,10 @@ var muteRoomAction = {
     return roomState !== "MUTED";
   },
   handler: async (runtime, message, state, _options, _callback, _responses) => {
+    if (!state) {
+      logger3.error("State is required for muting a room");
+      throw new Error("State is required for muting a room");
+    }
     async function _shouldMute(state2) {
       const shouldMutePrompt = composePromptFromState2({
         state: state2,
@@ -1438,17 +1449,20 @@ var updateRoleAction = {
     );
   },
   handler: async (runtime, message, state, _options, callback) => {
+    if (!state) {
+      logger4.error("State is required for role assignment");
+      throw new Error("State is required for role assignment");
+    }
     const { roomId } = message;
-    const channelType = message.content.channelType;
     const serverId = message.content.serverId;
     const worldId = runtime.getSetting("WORLD_ID");
-    let world;
+    let world = null;
     if (worldId) {
       world = await runtime.getWorld(worldId);
     }
     if (!world) {
       logger4.error("World not found");
-      await callback({
+      await callback?.({
         text: "I couldn't find the world. This action only works in a world."
       });
       return;
@@ -1518,7 +1532,7 @@ var updateRoleAction = {
       }
     );
     if (!result?.length) {
-      await callback({
+      await callback?.({
         text: "No valid role assignments found in the request.",
         actions: ["UPDATE_ROLE"],
         source: "discord"
@@ -1533,8 +1547,8 @@ var updateRoleAction = {
       }
       const currentRole = world.metadata.roles[assignment.entityId];
       if (!canModifyRole(requesterRole, currentRole, assignment.newRole)) {
-        await callback({
-          text: `You don't have permission to change ${targetEntity.names[0]}'s role to ${assignment.newRole}.`,
+        await callback?.({
+          text: `You don't have permission to change ${targetEntity?.names[0]}'s role to ${assignment.newRole}.`,
           actions: ["UPDATE_ROLE"],
           source: "discord"
         });
@@ -1542,8 +1556,8 @@ var updateRoleAction = {
       }
       world.metadata.roles[assignment.entityId] = assignment.newRole;
       worldUpdated = true;
-      await callback({
-        text: `Updated ${targetEntity.names[0]}'s role to ${assignment.newRole}.`,
+      await callback?.({
+        text: `Updated ${targetEntity?.names[0]}'s role to ${assignment.newRole}.`,
         actions: ["UPDATE_ROLE"],
         source: "discord"
       });
@@ -1672,6 +1686,18 @@ var sendMessageAction = {
   },
   handler: async (runtime, message, state, _options, callback, responses) => {
     try {
+      if (!state) {
+        logger5.error("State is required for sendMessage action");
+        throw new Error("State is required for sendMessage action");
+      }
+      if (!callback) {
+        logger5.error("Callback is required for sendMessage action");
+        throw new Error("Callback is required for sendMessage action");
+      }
+      if (!responses) {
+        logger5.error("Responses are required for sendMessage action");
+        throw new Error("Responses are required for sendMessage action");
+      }
       for (const response of responses) {
         await callback(response.content);
       }
@@ -1747,7 +1773,7 @@ var sendMessageAction = {
       } else if (targetData.targetType === "room") {
         const rooms = await runtime.getRooms(worldId);
         const targetRoom = rooms.find((r) => {
-          return r.name.toLowerCase() === targetData.identifiers.roomName?.toLowerCase();
+          return r.name?.toLowerCase() === targetData.identifiers.roomName?.toLowerCase();
         });
         if (!targetRoom) {
           await callback({
@@ -1784,7 +1810,7 @@ var sendMessageAction = {
       }
     } catch (error) {
       logger5.error(`Error in sendMessage handler: ${error}`);
-      await callback({
+      await callback?.({
         text: "There was an error processing your message request.",
         actions: ["SEND_MESSAGE_ERROR"],
         source: message.content.source
@@ -2020,7 +2046,7 @@ async function extractSettingValues(runtime, _message, state, worldSettings) {
     If a setting is mentioned but no clear value is provided, do not include it.
     `;
   try {
-    let extractValidSettings = function(obj, worldSettings2) {
+    let extractValidSettings2 = function(obj, worldSettings2) {
       const extracted = [];
       function traverse(node) {
         if (Array.isArray(node)) {
@@ -2040,6 +2066,7 @@ async function extractSettingValues(runtime, _message, state, worldSettings) {
       traverse(obj);
       return extracted;
     };
+    var extractValidSettings = extractValidSettings2;
     const result = await runtime.useModel(
       ModelType7.OBJECT_LARGE,
       {
@@ -2061,7 +2088,7 @@ async function extractSettingValues(runtime, _message, state, worldSettings) {
     if (!result) {
       return [];
     }
-    const extractedSettings = extractValidSettings(result, worldSettings);
+    const extractedSettings = extractValidSettings2(result, worldSettings);
     return extractedSettings;
   } catch (error) {
     console.error("Error extracting settings:", error);
@@ -2250,10 +2277,10 @@ var updateSettingsAction = {
       if (!worlds) {
         return false;
       }
-      const world = worlds.find((world2) => world2.metadata.settings);
-      const worldSettings = world.metadata.settings;
+      const world = worlds.find((world2) => world2.metadata?.settings);
+      const worldSettings = world?.metadata?.settings;
       if (!worldSettings) {
-        logger6.error(`No settings state found for server ${world.serverId}`);
+        logger6.error(`No settings state found for server ${world?.serverId}`);
         return false;
       }
       logger6.debug(`Found valid settings state for server ${world.serverId}`);
@@ -2265,16 +2292,32 @@ var updateSettingsAction = {
   },
   handler: async (runtime, message, state, _options, callback) => {
     try {
+      if (!state) {
+        logger6.error("State is required for settings handler");
+        throw new Error("State is required for settings handler");
+      }
+      if (!message) {
+        logger6.error("Message is required for settings handler");
+        throw new Error("Message is required for settings handler");
+      }
+      if (!callback) {
+        logger6.error("Callback is required for settings handler");
+        throw new Error("Callback is required for settings handler");
+      }
       logger6.info(`Handler looking for server for user ${message.entityId}`);
       const worlds = await findWorldsForOwner(runtime, message.entityId);
-      const serverOwnership = worlds.find((world) => world.metadata.settings);
+      const serverOwnership = worlds?.find((world) => world.metadata?.settings);
       if (!serverOwnership) {
         logger6.error(`No server found for user ${message.entityId} in handler`);
         await generateErrorResponse(runtime, state, callback);
         return;
       }
-      const serverId = serverOwnership.serverId;
+      const serverId = serverOwnership?.serverId;
       logger6.info(`Using server ID: ${serverId}`);
+      if (!serverId) {
+        logger6.error(`No server ID found for user ${message.entityId} in handler`);
+        return;
+      }
       const worldSettings = await getWorldSettings(runtime, serverId);
       if (!worldSettings) {
         logger6.error(`No settings state found for server ${serverId} in handler`);
@@ -2311,7 +2354,9 @@ var updateSettingsAction = {
       }
     } catch (error) {
       logger6.error(`Error in settings handler: ${error}`);
-      await generateErrorResponse(runtime, state, callback);
+      if (state && callback) {
+        await generateErrorResponse(runtime, state, callback);
+      }
     }
   },
   examples: [
@@ -2529,7 +2574,7 @@ var unfollowRoomAction = {
       const parsedResponse = parseBooleanFromText(response.trim());
       return parsedResponse;
     }
-    if (await _shouldUnfollow(state)) {
+    if (state && await _shouldUnfollow(state)) {
       await runtime.setParticipantUserState(message.roomId, runtime.agentId, null);
       const room = state.data.room ?? await runtime.getRoom(message.roomId);
       await runtime.createMemory(
@@ -2892,10 +2937,14 @@ var unmuteRoomAction = {
       logger7.warn(`Unclear boolean response: ${response}, defaulting to false`);
       return false;
     }
-    if (await _shouldUnmute(state)) {
+    if (state && await _shouldUnmute(state)) {
       await runtime.setParticipantUserState(message.roomId, runtime.agentId, null);
     }
     const room = await runtime.getRoom(message.roomId);
+    if (!room) {
+      logger7.warn(`Room not found: ${message.roomId}`);
+      return false;
+    }
     await runtime.createMemory(
       {
         entityId: message.entityId,
@@ -3071,6 +3120,22 @@ var updateEntityAction = {
   },
   handler: async (runtime, message, state, _options, callback, responses) => {
     try {
+      if (!state) {
+        logger8.error("State is required for the updateEntity action");
+        throw new Error("State is required for the updateEntity action");
+      }
+      if (!callback) {
+        logger8.error("State is required for the updateEntity action");
+        throw new Error("Callback is required for the updateEntity action");
+      }
+      if (!responses) {
+        logger8.error("Responses are required for the updateEntity action");
+        throw new Error("Responses are required for the updateEntity action");
+      }
+      if (!message) {
+        logger8.error("Message is required for the updateEntity action");
+        throw new Error("Message is required for the updateEntity action");
+      }
       for (const response of responses) {
         await callback(response.content);
       }
@@ -3133,7 +3198,8 @@ var updateEntityAction = {
           data: componentData,
           agentId,
           roomId: message.roomId,
-          sourceEntityId
+          sourceEntityId,
+          createdAt: existingComponent.createdAt
         });
         await callback({
           text: `I've updated the ${componentType} information for ${entity.names[0]}.`,
@@ -3149,7 +3215,8 @@ var updateEntityAction = {
           data: componentData,
           agentId,
           roomId: message.roomId,
-          sourceEntityId
+          sourceEntityId,
+          createdAt: Date.now()
         });
         await callback({
           text: `I've added new ${componentType} information for ${entity.names[0]}.`,
@@ -3159,7 +3226,7 @@ var updateEntityAction = {
       }
     } catch (error) {
       logger8.error(`Error in updateEntity handler: ${error}`);
-      await callback({
+      await callback?.({
         text: "There was an error processing the entity information.",
         actions: ["UPDATE_ENTITY_ERROR"],
         source: message.content.source
@@ -3300,23 +3367,27 @@ function resolveEntity(entityId, entities) {
   }
   let entity;
   entity = entities.find((a2) => a2.id === entityId);
-  if (entity) {
+  if (entity?.id) {
     return entity.id;
   }
-  entity = entities.find((a2) => a2.id.includes(entityId));
-  if (entity) {
+  entity = entities.find((a2) => a2.id?.includes(entityId));
+  if (entity?.id) {
     return entity.id;
   }
   entity = entities.find(
     (a2) => a2.names.some((n2) => n2.toLowerCase().includes(entityId.toLowerCase()))
   );
-  if (entity) {
+  if (entity?.id) {
     return entity.id;
   }
   throw new Error(`Could not resolve entityId "${entityId}" to a valid UUID`);
 }
 async function handler(runtime, message, state) {
   const { agentId, roomId } = message;
+  if (!agentId || !roomId) {
+    logger9.warn("Missing agentId or roomId in message", message);
+    return;
+  }
   const [existingRelationships, entities, knownFacts] = await Promise.all([
     runtime.getRelationships({
       entityId: message.entityId
@@ -3331,7 +3402,7 @@ async function handler(runtime, message, state) {
   ]);
   const prompt = composePrompt4({
     state: {
-      ...state.values,
+      ...state?.values || {},
       knownFacts: formatFacts(knownFacts),
       roomType: message.content.channelType,
       entitiesInRoom: JSON.stringify(entities),
@@ -3411,7 +3482,10 @@ async function handler(runtime, message, state) {
         });
       }
     }
-    await runtime.setCache(`${message.roomId}-reflection-last-processed`, message.id);
+    await runtime.setCache(
+      `${message.roomId}-reflection-last-processed`,
+      message?.id || ""
+    );
     return reflection;
   } catch (error) {
     logger9.error("Error in reflection handler:", error);
@@ -3866,7 +3940,7 @@ var characterProvider = {
         () => Math.random().toString(36).substring(2, 8)
       );
       return example.map((message2) => {
-        let messageString = `${message2.name}: ${message2.content.text}${message2.content.action || message2.content.actions ? ` (actions: ${message2.content.action || message2.content.actions.join(", ")})` : ""}`;
+        let messageString = `${message2.name}: ${message2.content.text}${message2.content.action || message2.content.actions ? ` (actions: ${message2.content.action || message2.content.actions?.join(", ")})` : ""}`;
         exampleNames.forEach((name, index) => {
           const placeholder = `{{name${index + 1}}}`;
           messageString = messageString.replaceAll(placeholder, name);
@@ -3880,7 +3954,7 @@ var characterProvider = {
     ) : "";
     const room = state.data.room ?? await runtime.getRoom(message.roomId);
     const isPostFormat = room?.type === ChannelType4.FEED || room?.type === ChannelType4.THREAD;
-    const postDirections = character?.style?.all?.length > 0 || character?.style?.post?.length > 0 ? addHeader4(
+    const postDirections = character?.style?.all?.length && character?.style?.all?.length > 0 || character?.style?.post?.length && character?.style?.post?.length > 0 ? addHeader4(
       `# Post Directions for ${character.name}`,
       (() => {
         const all = character?.style?.all || [];
@@ -3888,7 +3962,7 @@ var characterProvider = {
         return [...all, ...post].join("\n");
       })()
     ) : "";
-    const messageDirections = character?.style?.all?.length > 0 || character?.style?.chat?.length > 0 ? addHeader4(
+    const messageDirections = character?.style?.all?.length && character?.style?.all?.length > 0 || character?.style?.chat?.length && character?.style?.chat?.length > 0 ? addHeader4(
       `# Message Directions for ${character.name}`,
       (() => {
         const all = character?.style?.all || [];
@@ -3980,7 +4054,7 @@ var choiceProvider = {
           const options = task.metadata.options;
           options.forEach((option) => {
             if (typeof option === "string") {
-              const description = task.metadata?.options.find((o) => o.name === option)?.description || "";
+              const description = task.metadata?.options?.find((o) => o.name === option)?.description || "";
               output += `   - \`${option}\` ${description ? `- ${description}` : ""}
 `;
             } else {
@@ -4115,7 +4189,7 @@ function formatEvaluatorExamples(evaluators) {
           const placeholder = `{{name${index + 1}}}`;
           messageString = messageString.replaceAll(placeholder, name);
         });
-        return messageString + (message.content.action || message.content.actions ? ` (${message.content.action || message.content.actions.join(", ")})` : "");
+        return messageString + (message.content.action || message.content.actions ? ` (${message.content.action || message.content.actions?.join(", ")})` : "");
       }).join("\n");
       return `Prompt:
 ${formattedPrompt}
@@ -4164,6 +4238,7 @@ var evaluatorsProvider = {
 
 // src/providers/facts.ts
 import { ModelType as ModelType12 } from "@elizaos/core";
+import { logger as logger12 } from "@elizaos/core";
 function formatFacts2(facts) {
   return facts.reverse().map((fact) => fact.content.text).join("\n");
 }
@@ -4172,59 +4247,72 @@ var factsProvider = {
   description: "Key facts that the agent knows",
   dynamic: true,
   get: async (runtime, message, _state) => {
-    const recentMessages = await runtime.getMemories({
-      tableName: "messages",
-      roomId: message.roomId,
-      count: 10,
-      unique: false
-    });
-    const last5Messages = recentMessages.slice(-5).map((message2) => message2.content.text).join("\n");
-    const embedding = await runtime.useModel(ModelType12.TEXT_EMBEDDING, {
-      text: last5Messages
-    });
-    const [relevantFacts, recentFactsData] = await Promise.all([
-      runtime.searchMemories({
-        tableName: "facts",
-        embedding,
-        roomId: message.roomId,
-        worldId: message.worldId,
-        count: 6,
-        query: message.content.text
-      }),
-      runtime.searchMemories({
-        embedding,
-        query: message.content.text,
-        tableName: "facts",
+    try {
+      const recentMessages = await runtime.getMemories({
+        tableName: "messages",
         roomId: message.roomId,
-        entityId: message.entityId,
-        count: 6
-      })
-    ]);
-    const allFacts = [...relevantFacts, ...recentFactsData].filter(
-      (fact, index, self) => index === self.findIndex((t) => t.id === fact.id)
-    );
-    if (allFacts.length === 0) {
+        count: 10,
+        unique: false
+      });
+      const last5Messages = recentMessages.slice(-5).map((message2) => message2.content.text).join("\n");
+      const embedding = await runtime.useModel(ModelType12.TEXT_EMBEDDING, {
+        text: last5Messages
+      });
+      const [relevantFacts, recentFactsData] = await Promise.all([
+        runtime.searchMemories({
+          tableName: "facts",
+          embedding,
+          roomId: message.roomId,
+          worldId: message.worldId,
+          count: 6,
+          query: message.content.text
+        }),
+        runtime.searchMemories({
+          embedding,
+          query: message.content.text,
+          tableName: "facts",
+          roomId: message.roomId,
+          entityId: message.entityId,
+          count: 6
+        })
+      ]);
+      const allFacts = [...relevantFacts, ...recentFactsData].filter(
+        (fact, index, self) => index === self.findIndex((t) => t.id === fact.id)
+      );
+      if (allFacts.length === 0) {
+        return {
+          values: {
+            facts: ""
+          },
+          data: {
+            facts: allFacts
+          },
+          text: "No facts available."
+        };
+      }
+      const formattedFacts = formatFacts2(allFacts);
+      const text = "Key facts that {{agentName}} knows:\n{{formattedFacts}}".replace("{{agentName}}", runtime.character.name).replace("{{formattedFacts}}", formattedFacts);
       return {
         values: {
-          facts: ""
+          facts: formattedFacts
         },
         data: {
           facts: allFacts
         },
-        text: ""
+        text
+      };
+    } catch (error) {
+      logger12.error("Error in factsProvider:", error);
+      return {
+        values: {
+          facts: ""
+        },
+        data: {
+          facts: []
+        },
+        text: "Error retrieving facts."
       };
     }
-    const formattedFacts = formatFacts2(allFacts);
-    const text = "Key facts that {{agentName}} knows:\n{{formattedFacts}}".replace("{{agentName}}", runtime.character.name).replace("{{formattedFacts}}", formattedFacts);
-    return {
-      values: {
-        facts: formattedFacts
-      },
-      data: {
-        facts: allFacts
-      },
-      text
-    };
   }
 };
 
@@ -4294,7 +4382,8 @@ import {
   ChannelType as ChannelType5,
   formatMessages,
   formatPosts,
-  getEntityDetails as getEntityDetails3
+  getEntityDetails as getEntityDetails3,
+  logger as logger13
 } from "@elizaos/core";
 var getRecentInteractions = async (runtime, sourceEntityId, targetEntityId, excludeRoomId) => {
   const rooms = await runtime.getRoomsForParticipants([sourceEntityId, targetEntityId]);
@@ -4310,120 +4399,158 @@ var recentMessagesProvider = {
   description: "Recent messages, interactions and other memories",
   position: 100,
   get: async (runtime, message) => {
-    const { roomId } = message;
-    const conversationLength = runtime.getConversationLength();
-    const [entitiesData, room, recentMessagesData, recentInteractionsData] = await Promise.all([
-      getEntityDetails3({ runtime, roomId }),
-      runtime.getRoom(roomId),
-      runtime.getMemories({
-        tableName: "messages",
-        roomId,
-        count: conversationLength,
-        unique: false
-      }),
-      message.entityId !== runtime.agentId ? getRecentInteractions(runtime, message.entityId, runtime.agentId, roomId) : Promise.resolve([])
-    ]);
-    const isPostFormat = room?.type === ChannelType5.FEED || room?.type === ChannelType5.THREAD;
-    const [formattedRecentMessages, formattedRecentPosts] = await Promise.all([
-      formatMessages({
-        messages: recentMessagesData,
-        entities: entitiesData
-      }),
-      formatPosts({
-        messages: recentMessagesData,
-        entities: entitiesData,
-        conversationHeader: false
-      })
-    ]);
-    const recentPosts = formattedRecentPosts && formattedRecentPosts.length > 0 ? addHeader9("# Posts in Thread", formattedRecentPosts) : "";
-    const metaData = message.metadata;
-    const senderName = metaData?.entityName || "unknown";
-    const receivedMessageContent = message.content.text;
-    const receivedMessageHeader = addHeader9(
-      "# Received Message",
-      `${senderName}: ${receivedMessageContent}`
-    );
-    const focusHeader = addHeader9(
-      "# \u26A1 Focus your response",
-      `You are replying to the above message from **${senderName}**. Keep your answer relevant to that message. Do not repeat earlier replies unless the sender asks again.`
-    );
-    const recentMessages = formattedRecentMessages && formattedRecentMessages.length > 0 ? addHeader9("# Conversation Messages", formattedRecentMessages) : "";
-    const interactionEntityMap = /* @__PURE__ */ new Map();
-    if (recentInteractionsData.length > 0) {
-      const uniqueEntityIds = [
-        ...new Set(
-          recentInteractionsData.map((message2) => message2.entityId).filter((id) => id !== runtime.agentId)
-        )
-      ];
-      const uniqueEntityIdSet = new Set(uniqueEntityIds);
-      const entitiesDataIdSet = /* @__PURE__ */ new Set();
-      entitiesData.forEach((entity) => {
-        if (uniqueEntityIdSet.has(entity.id)) {
-          interactionEntityMap.set(entity.id, entity);
-          entitiesDataIdSet.add(entity.id);
-        }
-      });
-      const remainingEntityIds = uniqueEntityIds.filter((id) => !entitiesDataIdSet.has(id));
-      if (remainingEntityIds.length > 0) {
-        const entities = await Promise.all(
-          remainingEntityIds.map((entityId) => runtime.getEntityById(entityId))
-        );
-        entities.forEach((entity, index) => {
-          if (entity) {
-            interactionEntityMap.set(remainingEntityIds[index], entity);
+    try {
+      const { roomId } = message;
+      const conversationLength = runtime.getConversationLength();
+      const [entitiesData, room, recentMessagesData, recentInteractionsData] = await Promise.all([
+        getEntityDetails3({ runtime, roomId }),
+        runtime.getRoom(roomId),
+        runtime.getMemories({
+          tableName: "messages",
+          roomId,
+          count: conversationLength,
+          unique: false
+        }),
+        message.entityId !== runtime.agentId ? getRecentInteractions(runtime, message.entityId, runtime.agentId, roomId) : Promise.resolve([])
+      ]);
+      const isPostFormat = room?.type ? room.type === ChannelType5.FEED || room.type === ChannelType5.THREAD : false;
+      const [formattedRecentMessages, formattedRecentPosts] = await Promise.all([
+        formatMessages({
+          messages: recentMessagesData,
+          entities: entitiesData
+        }),
+        formatPosts({
+          messages: recentMessagesData,
+          entities: entitiesData,
+          conversationHeader: false
+        })
+      ]);
+      const recentPosts = formattedRecentPosts && formattedRecentPosts.length > 0 ? addHeader9("# Posts in Thread", formattedRecentPosts) : "";
+      const recentMessages = formattedRecentMessages && formattedRecentMessages.length > 0 ? addHeader9("# Conversation Messages", formattedRecentMessages) : "";
+      if (!recentPosts && !recentMessages && recentMessagesData.length === 0 && !message.content.text) {
+        return {
+          data: {
+            recentMessages: [],
+            recentInteractions: []
+          },
+          values: {
+            recentPosts: "",
+            recentMessages: "",
+            recentMessageInteractions: "",
+            recentPostInteractions: "",
+            recentInteractions: ""
+          },
+          text: "No recent messages available"
+        };
+      }
+      const metaData = message.metadata;
+      const senderName = metaData?.entityName || "unknown";
+      const receivedMessageContent = message.content.text;
+      const hasReceivedMessage = !!receivedMessageContent?.trim();
+      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.`
+      ) : "";
+      const interactionEntityMap = /* @__PURE__ */ new Map();
+      if (recentInteractionsData.length > 0) {
+        const uniqueEntityIds = [
+          ...new Set(
+            recentInteractionsData.map((message2) => message2.entityId).filter((id) => id !== runtime.agentId)
+          )
+        ];
+        const uniqueEntityIdSet = new Set(uniqueEntityIds);
+        const entitiesDataIdSet = /* @__PURE__ */ new Set();
+        entitiesData.forEach((entity) => {
+          if (uniqueEntityIdSet.has(entity.id)) {
+            interactionEntityMap.set(entity.id, entity);
+            entitiesDataIdSet.add(entity.id);
           }
         });
+        const remainingEntityIds = uniqueEntityIds.filter((id) => !entitiesDataIdSet.has(id));
+        if (remainingEntityIds.length > 0) {
+          const entities = await Promise.all(
+            remainingEntityIds.map((entityId) => runtime.getEntityById(entityId))
+          );
+          entities.forEach((entity, index) => {
+            if (entity) {
+              interactionEntityMap.set(remainingEntityIds[index], entity);
+            }
+          });
+        }
       }
-    }
-    const getRecentMessageInteractions = async (recentInteractionsData2) => {
-      const formattedInteractions = recentInteractionsData2.map((message2) => {
-        const isSelf = message2.entityId === runtime.agentId;
-        let sender;
-        if (isSelf) {
-          sender = runtime.character.name;
-        } else {
-          sender = interactionEntityMap.get(message2.entityId)?.metadata?.username || "unknown";
+      const getRecentMessageInteractions = async (recentInteractionsData2) => {
+        const formattedInteractions = recentInteractionsData2.map((message2) => {
+          const isSelf = message2.entityId === runtime.agentId;
+          let sender;
+          if (isSelf) {
+            sender = runtime.character.name;
+          } else {
+            sender = interactionEntityMap.get(message2.entityId)?.metadata?.username || "unknown";
+          }
+          return `${sender}: ${message2.content.text}`;
+        });
+        return formattedInteractions.join("\n");
+      };
+      const getRecentPostInteractions = async (recentInteractionsData2, entities) => {
+        const combinedEntities = [...entities];
+        const actorIds = new Set(entities.map((entity) => entity.id));
+        for (const [id, entity] of interactionEntityMap.entries()) {
+          if (!actorIds.has(id)) {
+            combinedEntities.push(entity);
+          }
         }
-        return `${sender}: ${message2.content.text}`;
-      });
-      return formattedInteractions.join("\n");
-    };
-    const getRecentPostInteractions = async (recentInteractionsData2, entities) => {
-      const combinedEntities = [...entities];
-      const actorIds = new Set(entities.map((entity) => entity.id));
-      for (const [id, entity] of interactionEntityMap.entries()) {
-        if (!actorIds.has(id)) {
-          combinedEntities.push(entity);
-        }
-      }
-      const formattedInteractions = formatPosts({
-        messages: recentInteractionsData2,
-        entities: combinedEntities,
-        conversationHeader: true
-      });
-      return formattedInteractions;
-    };
-    const [recentMessageInteractions, recentPostInteractions] = await Promise.all([
-      getRecentMessageInteractions(recentInteractionsData),
-      getRecentPostInteractions(recentInteractionsData, entitiesData)
-    ]);
-    const data = {
-      recentMessages: recentMessagesData,
-      recentInteractions: recentInteractionsData
-    };
-    const values = {
-      recentPosts,
-      recentMessages,
-      recentMessageInteractions,
-      recentPostInteractions,
-      recentInteractions: isPostFormat ? recentPostInteractions : recentMessageInteractions
-    };
-    const text = [isPostFormat ? recentPosts : recentMessages + receivedMessageHeader + focusHeader].filter(Boolean).join("\n\n");
-    return {
-      data,
-      values,
-      text
-    };
+        const formattedInteractions = formatPosts({
+          messages: recentInteractionsData2,
+          entities: combinedEntities,
+          conversationHeader: true
+        });
+        return formattedInteractions;
+      };
+      const [recentMessageInteractions, recentPostInteractions] = await Promise.all([
+        getRecentMessageInteractions(recentInteractionsData),
+        getRecentPostInteractions(recentInteractionsData, entitiesData)
+      ]);
+      const data = {
+        recentMessages: recentMessagesData,
+        recentInteractions: recentInteractionsData
+      };
+      const values = {
+        recentPosts,
+        recentMessages,
+        recentMessageInteractions,
+        recentPostInteractions,
+        recentInteractions: isPostFormat ? recentPostInteractions : recentMessageInteractions
+      };
+      const text = [
+        isPostFormat ? recentPosts : recentMessages,
+        // Only add received message and focus headers if there are messages or a current message to process
+        recentMessages || recentPosts || message.content.text ? receivedMessageHeader : "",
+        recentMessages || recentPosts || message.content.text ? focusHeader : ""
+      ].filter(Boolean).join("\n\n");
+      return {
+        data,
+        values,
+        text
+      };
+    } catch (error) {
+      logger13.error("Error in recentMessagesProvider:", error);
+      return {
+        data: {
+          recentMessages: [],
+          recentInteractions: []
+        },
+        values: {
+          recentPosts: "",
+          recentMessages: "",
+          recentMessageInteractions: "",
+          recentPostInteractions: "",
+          recentInteractions: ""
+        },
+        text: "Error retrieving recent messages."
+        // Or 'No recent messages available' as the test expects
+      };
+    }
   }
 };
 
@@ -4512,7 +4639,7 @@ ${formattedRelationships}`
 import {
   ChannelType as ChannelType6,
   createUniqueUuid as createUniqueUuid2,
-  logger as logger12
+  logger as logger14
 } from "@elizaos/core";
 var roleProvider = {
   name: "ROLES",
@@ -4537,106 +4664,108 @@ var roleProvider = {
     if (!serverId) {
       throw new Error("No server ID found");
     }
-    try {
-      logger12.info(`Using server ID: ${serverId}`);
-      const worldId = createUniqueUuid2(runtime, serverId);
-      const world = await runtime.getWorld(worldId);
-      if (!world || !world.metadata?.ownership?.ownerId) {
-        logger12.info(
-          `No ownership data found for server ${serverId}, initializing empty role hierarchy`
-        );
-        return {
-          data: {
-            roles: []
-          },
-          values: {
-            roles: "No role information available for this server."
-          },
-          text: "No role information available for this server."
-        };
-      }
-      const roles = world.metadata.roles || {};
-      if (Object.keys(roles).length === 0) {
-        logger12.info(`No roles found for server ${serverId}`);
-        return {
-          data: {
-            roles: []
-          },
-          values: {
-            roles: "No role information available for this server."
-          }
-        };
-      }
-      logger12.info(`Found ${Object.keys(roles).length} roles`);
-      const owners = [];
-      const admins = [];
-      const members = [];
-      for (const entityId of Object.keys(roles)) {
-        const userRole = roles[entityId];
-        const user = await runtime.getEntityById(entityId);
-        const name = user.metadata[room.source]?.name;
-        const username = user.metadata[room.source]?.username;
-        const names = user.names;
-        if (owners.some((owner) => owner.username === username) || admins.some((admin) => admin.username === username) || members.some((member) => member.username === username)) {
-          continue;
-        }
-        switch (userRole) {
-          case "OWNER":
-            owners.push({ name, username, names });
-            break;
-          case "ADMIN":
-            admins.push({ name, username, names });
-            break;
-          default:
-            members.push({ name, username, names });
-            break;
-        }
-      }
-      let response = "# Server Role Hierarchy\n\n";
-      if (owners.length > 0) {
-        response += "## Owners\n";
-        owners.forEach((owner) => {
-          response += `${owner.name} (${owner.names.join(", ")})
-`;
-        });
-        response += "\n";
-      }
-      if (admins.length > 0) {
-        response += "## Administrators\n";
-        admins.forEach((admin) => {
-          response += `${admin.name} (${admin.names.join(", ")}) (${admin.username})
-`;
-        });
-        response += "\n";
-      }
-      if (members.length > 0) {
-        response += "## Members\n";
-        members.forEach((member) => {
-          response += `${member.name} (${member.names.join(", ")}) (${member.username})
-`;
-        });
-      }
+    logger14.info(`Using server ID: ${serverId}`);
+    const worldId = createUniqueUuid2(runtime, serverId);
+    const world = await runtime.getWorld(worldId);
+    if (!world || !world.metadata?.ownership?.ownerId) {
+      logger14.info(
+        `No ownership data found for server ${serverId}, initializing empty role hierarchy`
+      );
       return {
         data: {
-          roles: response
+          roles: []
         },
         values: {
-          roles: response
+          roles: "No role information available for this server."
         },
-        text: response
+        text: "No role information available for this server."
       };
-    } catch (error) {
-      logger12.error("Error in role provider:", error);
+    }
+    const roles = world.metadata.roles || {};
+    if (Object.keys(roles).length === 0) {
+      logger14.info(`No roles found for server ${serverId}`);
       return {
         data: {
           roles: []
         },
         values: {
-          roles: "There was an error retrieving role information."
+          roles: "No role information available for this server."
+        }
+      };
+    }
+    logger14.info(`Found ${Object.keys(roles).length} roles`);
+    const owners = [];
+    const admins = [];
+    const members = [];
+    for (const entityId of Object.keys(roles)) {
+      const userRole = roles[entityId];
+      const user = await runtime.getEntityById(entityId);
+      const name = user?.metadata?.[room.source]?.name;
+      const username = user?.metadata?.[room.source]?.username;
+      const names = user?.names;
+      if (owners.some((owner) => owner.username === username) || admins.some((admin) => admin.username === username) || members.some((member) => member.username === username)) {
+        continue;
+      }
+      if (!name || !username || !names) {
+        logger14.warn(`User ${entityId} has no name or username, skipping`);
+        continue;
+      }
+      switch (userRole) {
+        case "OWNER":
+          owners.push({ name, username, names });
+          break;
+        case "ADMIN":
+          admins.push({ name, username, names });
+          break;
+        default:
+          members.push({ name, username, names });
+          break;
+      }
+    }
+    let response = "# Server Role Hierarchy\n\n";
+    if (owners.length > 0) {
+      response += "## Owners\n";
+      owners.forEach((owner) => {
+        response += `${owner.name} (${owner.names.join(", ")})
+`;
+      });
+      response += "\n";
+    }
+    if (admins.length > 0) {
+      response += "## Administrators\n";
+      admins.forEach((admin) => {
+        response += `${admin.name} (${admin.names.join(", ")}) (${admin.username})
+`;
+      });
+      response += "\n";
+    }
+    if (members.length > 0) {
+      response += "## Members\n";
+      members.forEach((member) => {
+        response += `${member.name} (${member.names.join(", ")}) (${member.username})
+`;
+      });
+    }
+    if (owners.length === 0 && admins.length === 0 && members.length === 0) {
+      return {
+        data: {
+          roles: []
+        },
+        values: {
+          roles: "No role information available for this server."
         },
-        text: "There was an error retrieving role information."
+        text: "No role information available for this server."
       };
     }
+    return {
+      data: {
+        roles: response
+      },
+      values: {
+        roles: response
+      },
+      text: response
+    };
   }
 };
 
@@ -4645,7 +4774,7 @@ import {
   ChannelType as ChannelType7,
   findWorldsForOwner as findWorldsForOwner2,
   getWorldSettings as getWorldSettings2,
-  logger as logger13
+  logger as logger15
 } from "@elizaos/core";
 var formatSettingValue = (setting, isOnboarding) => {
   if (setting.value === null) return "Not set";
@@ -4672,13 +4801,13 @@ function generateStatusMessage(runtime, worldSettings, isOnboarding, state) {
       };
     }).filter(Boolean);
     const requiredUnconfigured = formattedSettings.filter(
-      (s) => s.required && !s.configured
+      (s) => s?.required && !s.configured
     ).length;
     if (isOnboarding) {
       const settingsList = formattedSettings.map((s) => {
-        const label = s.required ? "(Required)" : "(Optional)";
-        return `${s.key}: ${s.value} ${label}
-(${s.name}) ${s.usageDescription}`;
+        const label = s?.required ? "(Required)" : "(Optional)";
+        return `${s?.key}: ${s?.value} ${label}
+(${s?.name}) ${s?.usageDescription}`;
       }).join("\n\n");
       const validKeys = `Valid setting keys: ${Object.keys(worldSettings).join(", ")}`;
       const commonInstructions = `Instructions for ${runtime.character.name}:
@@ -4688,7 +4817,7 @@ function generateStatusMessage(runtime, worldSettings, isOnboarding, state) {
       - Do not call UPDATE_SETTINGS just because the user has started onboarding or you think a setting needs to be configured. Only update when the user clearly provides a specific value for a setting you are currently asking about.
       - Answer setting-related questions using only the name, description, and value from the list.`;
       if (requiredUnconfigured > 0) {
-        return `# PRIORITY TASK: Onboarding with ${state.senderName}
+        return `# PRIORITY TASK: Onboarding with ${state?.senderName}
 
         ${runtime.character.name} needs to help the user configure ${requiredUnconfigured} required settings:
         
@@ -4712,11 +4841,11 @@ function generateStatusMessage(runtime, worldSettings, isOnboarding, state) {
 
 ${requiredUnconfigured > 0 ? `IMPORTANT!: ${requiredUnconfigured} required settings still need configuration. ${runtime.character.name} should get onboarded with the OWNER as soon as possible.
 
-` : "All required settings are configured.\n\n"}${formattedSettings.map((s) => `### ${s.name}
-**Value:** ${s.value}
-**Description:** ${s.description}`).join("\n\n")}`;
+` : "All required settings are configured.\n\n"}${formattedSettings.map((s) => `### ${s?.name}
+**Value:** ${s?.value}
+**Description:** ${s?.description}`).join("\n\n")}`;
   } catch (error) {
-    logger13.error(`Error generating status message: ${error}`);
+    logger15.error(`Error generating status message: ${error}`);
     return "Error generating configuration status.";
   }
 }
@@ -4729,11 +4858,11 @@ var settingsProvider = {
         runtime.getRoom(message.roomId),
         findWorldsForOwner2(runtime, message.entityId)
       ]).catch((error) => {
-        logger13.error(`Error fetching initial data: ${error}`);
+        logger15.error(`Error fetching initial data: ${error}`);
         throw new Error("Failed to retrieve room or user world information");
       });
       if (!room) {
-        logger13.error("No room found for settings provider");
+        logger15.error("No room found for settings provider");
         return {
           data: {
             settings: []
@@ -4745,7 +4874,7 @@ var settingsProvider = {
         };
       }
       if (!room.worldId) {
-        logger13.debug("No world found for settings provider -- settings provider will be skipped");
+        logger15.debug("No world found for settings provider -- settings provider will be skipped");
         return {
           data: {
             settings: []
@@ -4758,42 +4887,42 @@ var settingsProvider = {
       }
       const type = room.type;
       const isOnboarding = type === ChannelType7.DM;
-      let world;
-      let serverId;
-      let worldSettings;
+      let world = null;
+      let serverId = void 0;
+      let worldSettings = null;
       if (isOnboarding) {
-        world = userWorlds.find((world2) => world2.metadata.settings);
+        world = userWorlds?.find((world2) => world2.metadata?.settings);
         if (!world) {
-          logger13.error("No world found for user during onboarding");
+          logger15.error("No world found for user during onboarding");
           throw new Error("No server ownership found for onboarding");
         }
         serverId = world.serverId;
         try {
           worldSettings = await getWorldSettings2(runtime, serverId);
         } catch (error) {
-          logger13.error(`Error fetching world settings: ${error}`);
+          logger15.error(`Error fetching world settings: ${error}`);
           throw new Error(`Failed to retrieve settings for server ${serverId}`);
         }
       } else {
         try {
           world = await runtime.getWorld(room.worldId);
           if (!world) {
-            logger13.error(`No world found for room ${room.worldId}`);
+            logger15.error(`No world found for room ${room.worldId}`);
             throw new Error(`No world found for room ${room.worldId}`);
           }
           serverId = world.serverId;
           if (serverId) {
             worldSettings = await getWorldSettings2(runtime, serverId);
           } else {
-            logger13.error(`No server ID found for world ${room.worldId}`);
+            logger15.error(`No server ID found for world ${room.worldId}`);
           }
         } catch (error) {
-          logger13.error(`Error processing world data: ${error}`);
+          logger15.error(`Error processing world data: ${error}`);
           throw new Error("Failed to process world information");
         }
       }
       if (!serverId) {
-        logger13.info(
+        logger15.info(
           `No server ownership found for user ${message.entityId} after recovery attempt`
         );
         return isOnboarding ? {
@@ -4815,7 +4944,7 @@ var settingsProvider = {
         };
       }
       if (!worldSettings) {
-        logger13.info(`No settings state found for server ${serverId}`);
+        logger15.info(`No settings state found for server ${serverId}`);
         return isOnboarding ? {
           data: {
             settings: []
@@ -4845,7 +4974,7 @@ var settingsProvider = {
         text: output
       };
     } catch (error) {
-      logger13.error(`Critical error in settings provider: ${error}`);
+      logger15.error(`Critical error in settings provider: ${error}`);
       return {
         data: {
           settings: []
@@ -4884,7 +5013,7 @@ var timeProvider = {
 
 // src/providers/world.ts
 import {
-  logger as logger14,
+  logger as logger16,
   addHeader as addHeader10,
   ChannelType as ChannelType8
 } from "@elizaos/core";
@@ -4894,10 +5023,10 @@ var worldProvider = {
   dynamic: true,
   get: async (runtime, message) => {
     try {
-      logger14.debug("\u{1F310} World provider activated for roomId:", message.roomId);
+      logger16.debug("\u{1F310} World provider activated for roomId:", message.roomId);
       const currentRoom = await runtime.getRoom(message.roomId);
       if (!currentRoom) {
-        logger14.warn(`World provider: Room not found for roomId ${message.roomId}`);
+        logger16.warn(`World provider: Room not found for roomId ${message.roomId}`);
         return {
           data: {
             world: {
@@ -4907,11 +5036,22 @@ var worldProvider = {
           text: "Unable to retrieve world information - room not found"
         };
       }
-      logger14.debug(`\u{1F310} World provider: Found room "${currentRoom.name}" (${currentRoom.type})`);
+      logger16.debug(`\u{1F310} World provider: Found room "${currentRoom.name}" (${currentRoom.type})`);
       const worldId = currentRoom.worldId;
+      if (!worldId) {
+        logger16.warn(`World provider: World ID not found for roomId ${message.roomId}`);
+        return {
+          data: {
+            world: {
+              info: "Unable to retrieve world information - world ID not found"
+            }
+          },
+          text: "Unable to retrieve world information - world ID not found"
+        };
+      }
       const world = await runtime.getWorld(worldId);
       if (!world) {
-        logger14.warn(`World provider: World not found for worldId ${worldId}`);
+        logger16.warn(`World provider: World not found for worldId ${worldId}`);
         return {
           data: {
             world: {
@@ -4921,11 +5061,11 @@ var worldProvider = {
           text: "Unable to retrieve world information - world not found"
         };
       }
-      logger14.debug(`\u{1F310} World provider: Found world "${world.name}" (ID: ${world.id})`);
+      logger16.debug(`\u{1F310} World provider: Found world "${world.name}" (ID: ${world.id})`);
       const worldRooms = await runtime.getRooms(worldId);
-      logger14.debug(`\u{1F310} World provider: Found ${worldRooms.length} rooms in world "${world.name}"`);
+      logger16.debug(`\u{1F310} World provider: Found ${worldRooms.length} rooms in world "${world.name}"`);
       const participants = await runtime.getParticipantsForRoom(message.roomId);
-      logger14.debug(
+      logger16.debug(
         `\u{1F310} World provider: Found ${participants.length} participants in room "${currentRoom.name}"`
       );
       const channelsByType = {
@@ -4937,6 +5077,10 @@ var worldProvider = {
         other: []
       };
       for (const room of worldRooms) {
+        if (!room?.id || !room.name) {
+          logger16.warn(`World provider: Room ID or name is missing for room ${room.id}`);
+          continue;
+        }
         const roomInfo = {
           id: room.id,
           name: room.name,
@@ -5003,14 +5147,14 @@ var worldProvider = {
         worldInfo: worldInfoText
       };
       const formattedText = addHeader10("# World Information", worldInfoText);
-      logger14.debug("\u{1F310} World provider completed successfully");
+      logger16.debug("\u{1F310} World provider completed successfully");
       return {
         data,
         values,
         text: formattedText
       };
     } catch (error) {
-      logger14.error(
+      logger16.error(
         `Error in world provider: ${error instanceof Error ? error.message : String(error)}`
       );
       return {
@@ -5032,7 +5176,7 @@ import {
   EventType,
   Service,
   createUniqueUuid as createUniqueUuid3,
-  logger as logger15
+  logger as logger17
 } from "@elizaos/core";
 var ScenarioService = class _ScenarioService extends Service {
   /**
@@ -5076,7 +5220,7 @@ var ScenarioService = class _ScenarioService extends Service {
         startTime: Date.now(),
         completed: false
       });
-      logger15.debug("Evaluator started", data);
+      logger17.debug("[Bootstrap] Evaluator started", data);
       return Promise.resolve();
     });
     this.runtime.registerEvent(
@@ -5087,7 +5231,7 @@ var ScenarioService = class _ScenarioService extends Service {
           evaluator.completed = true;
           evaluator.error = data.error;
         }
-        logger15.debug("Evaluator completed", data);
+        logger17.debug("[Bootstrap] Evaluator completed", data);
         return Promise.resolve();
       }
     );
@@ -5168,7 +5312,8 @@ var ScenarioService = class _ScenarioService extends Service {
       source: "scenario",
       type: ChannelType9.GROUP,
       channelId: roomId,
-      serverId: worldId
+      serverId: worldId,
+      worldId
     });
     return roomId;
   }
@@ -5268,7 +5413,7 @@ var ScenarioService = class _ScenarioService extends Service {
 
 // src/services/task.ts
 import {
-  logger as logger16,
+  logger as logger18,
   Service as Service2,
   ServiceType
 } from "@elizaos/core";
@@ -5296,21 +5441,21 @@ var TaskService = class _TaskService extends Service2 {
     this.runtime.registerTaskWorker({
       name: "REPEATING_TEST_TASK",
       validate: async (_runtime, _message, _state) => {
-        logger16.debug("Validating repeating test task");
+        logger18.debug("[Bootstrap] Validating repeating test task");
         return true;
       },
       execute: async (_runtime, _options) => {
-        logger16.debug("Executing repeating test task");
+        logger18.debug("[Bootstrap] Executing repeating test task");
       }
     });
     this.runtime.registerTaskWorker({
       name: "ONETIME_TEST_TASK",
       validate: async (_runtime, _message, _state) => {
-        logger16.debug("Validating one-time test task");
+        logger18.debug("[Bootstrap] Validating one-time test task");
         return true;
       },
       execute: async (_runtime, _options) => {
-        logger16.debug("Executing one-time test task");
+        logger18.debug("[Bootstrap] Executing one-time test task");
       }
     });
     const tasks = await this.runtime.getTasksByName("REPEATING_TEST_TASK");
@@ -5347,7 +5492,7 @@ var TaskService = class _TaskService extends Service2 {
       try {
         await this.checkTasks();
       } catch (error) {
-        logger16.error("Error checking tasks:", error);
+        logger18.error("[Bootstrap] Error checking tasks:", error);
       }
     }, this.TICK_INTERVAL);
   }
@@ -5376,7 +5521,7 @@ var TaskService = class _TaskService extends Service2 {
             continue;
           }
         } catch (error) {
-          logger16.error(`Error validating task ${task.name}:`, error);
+          logger18.error(`[Bootstrap] Error validating task ${task.name}:`, error);
           continue;
         }
       }
@@ -5416,22 +5561,22 @@ var TaskService = class _TaskService extends Service2 {
           await this.executeTask(task);
           continue;
         }
-        if (task.metadata.updatedAt === task.metadata.createdAt) {
+        if (task.metadata?.updatedAt === task.metadata?.createdAt) {
           if (task.tags?.includes("immediate")) {
-            logger16.debug("immediately running task", task.name);
+            logger18.debug("[Bootstrap] Immediately running task", task.name);
             await this.executeTask(task);
             continue;
           }
         }
         if (now - taskStartTime >= updateIntervalMs) {
-          logger16.debug(
-            `Executing task ${task.name} - interval of ${updateIntervalMs}ms has elapsed`
+          logger18.debug(
+            `[Bootstrap] Executing task ${task.name} - interval of ${updateIntervalMs}ms has elapsed`
           );
           await this.executeTask(task);
         }
       }
     } catch (error) {
-      logger16.error("Error checking tasks:", error);
+      logger18.error("[Bootstrap] Error checking tasks:", error);
     }
   }
   /**
@@ -5441,13 +5586,13 @@ var TaskService = class _TaskService extends Service2 {
    */
   async executeTask(task) {
     try {
-      if (!task) {
-        logger16.debug(`Task ${task.id} not found`);
+      if (!task || !task.id) {
+        logger18.debug(`[Bootstrap] Task not found`);
         return;
       }
       const worker = this.runtime.getTaskWorker(task.name);
       if (!worker) {
-        logger16.debug(`No worker found for task type: ${task.name}`);
+        logger18.debug(`[Bootstrap] No worker found for task type: ${task.name}`);
         return;
       }
       if (task.tags?.includes("repeat")) {
@@ -5457,16 +5602,20 @@ var TaskService = class _TaskService extends Service2 {
             updatedAt: Date.now()
           }
         });
-        logger16.debug(`Updated repeating task ${task.name} (${task.id}) with new timestamp`);
+        logger18.debug(
+          `[Bootstrap] Updated repeating task ${task.name} (${task.id}) with new timestamp`
+        );
       }
-      logger16.debug(`Executing task ${task.name} (${task.id})`);
+      logger18.debug(`[Bootstrap] Executing task ${task.name} (${task.id})`);
       await worker.execute(this.runtime, task.metadata || {}, task);
       if (!task.tags?.includes("repeat")) {
         await this.runtime.deleteTask(task.id);
-        logger16.debug(`Deleted non-repeating task ${task.name} (${task.id}) after execution`);
+        logger18.debug(
+          `[Bootstrap] Deleted non-repeating task ${task.name} (${task.id}) after execution`
+        );
       }
     } catch (error) {
-      logger16.error(`Error executing task ${task.id}:`, error);
+      logger18.error(`[Bootstrap] Error executing task ${task.id}:`, error);
     }
   }
   /**
@@ -5516,6 +5665,7 @@ var messageReceivedHandler = async ({
   callback,
   onComplete
 }) => {
+  logger19.info(`[Bootstrap] Message received from ${message.entityId} in room ${message.roomId}`);
   const responseId = v4_default();
   if (!latestResponseIds.has(runtime.agentId)) {
     latestResponseIds.set(runtime.agentId, /* @__PURE__ */ new Map());
@@ -5538,7 +5688,7 @@ var messageReceivedHandler = async ({
     source: "messageHandler"
   });
   const timeoutDuration = 60 * 60 * 1e3;
-  let timeoutId;
+  let timeoutId = void 0;
   const timeoutPromise = new Promise((_, reject) => {
     timeoutId = setTimeout(async () => {
       await runtime.emitEvent(EventType2.RUN_TIMEOUT, {
@@ -5560,15 +5710,20 @@ var messageReceivedHandler = async ({
   const processingPromise = (async () => {
     try {
       if (message.entityId === runtime.agentId) {
+        logger19.debug(`[Bootstrap] Skipping message from self (${runtime.agentId})`);
         throw new Error("Message is from the agent itself");
       }
+      logger19.debug(
+        `[Bootstrap] Processing message: ${truncateToCompleteSentence(message.content.text || "", 50)}...`
+      );
+      logger19.debug("[Bootstrap] Saving message to memory and embeddings");
       await Promise.all([
         runtime.addEmbeddingToMemory(message),
         runtime.createMemory(message, "messages")
       ]);
       const agentUserState = await runtime.getParticipantUserState(message.roomId, runtime.agentId);
       if (agentUserState === "MUTED" && !message.content.text?.toLowerCase().includes(runtime.character.name.toLowerCase())) {
-        logger17.debug("Ignoring muted room");
+        logger19.debug(`[Bootstrap] Ignoring muted room ${message.roomId}`);
         return;
       }
       let state = await runtime.composeState(message, [
@@ -5579,26 +5734,25 @@ var messageReceivedHandler = async ({
         "RECENT_MESSAGES"
       ]);
       const room = await runtime.getRoom(message.roomId);
-      const shouldSkipShouldRespond = room?.type === ChannelType10.DM || room?.type === ChannelType10.VOICE_DM || room?.type === ChannelType10.SELF;
+      const shouldSkipShouldRespond = room?.type === ChannelType10.DM || room?.type === ChannelType10.VOICE_DM || room?.type === ChannelType10.SELF || room?.type === ChannelType10.API;
       let shouldRespond = true;
       if (!shouldSkipShouldRespond) {
         const shouldRespondPrompt = composePromptFromState9({
           state,
           template: runtime.character.templates?.shouldRespondTemplate || shouldRespondTemplate
         });
-        logger17.debug(
-          `*** Should Respond Prompt for ${runtime.character.name} ***
-`,
-          shouldRespondPrompt
+        logger19.debug(
+          `[Bootstrap] Evaluating response for ${runtime.character.name}
+Prompt: ${shouldRespondPrompt}`
         );
         const response = await runtime.useModel(ModelType13.TEXT_SMALL, {
           prompt: shouldRespondPrompt
         });
-        logger17.debug(`*** Should Respond Response for ${runtime.character.name} ***
-`, response);
-        logger17.debug(`*** Raw Response Type: ${typeof response} ***`);
+        logger19.debug(`[Bootstrap] Response evaluation for ${runtime.character.name}:
+${response}`);
+        logger19.debug(`[Bootstrap] Response type: ${typeof response}`);
         const responseObject = parseKeyValueXml(response);
-        logger17.debug("*** Parsed XML Response Object ***", responseObject);
+        logger19.debug("[Bootstrap] Parsed response:", responseObject);
         shouldRespond = responseObject?.action && responseObject.action === "RESPOND";
       } else {
         shouldRespond = true;
@@ -5617,11 +5771,12 @@ var messageReceivedHandler = async ({
           let response = await runtime.useModel(ModelType13.TEXT_LARGE, {
             prompt
           });
-          logger17.debug("*** Raw LLM Response ***\n", response);
+          logger19.debug("[Bootstrap] *** Raw LLM Response ***\n", response);
           const parsedXml = parseKeyValueXml(response);
-          logger17.debug("*** Parsed XML Content ***\n", parsedXml);
+          logger19.debug("[Bootstrap] *** Parsed XML Content ***\n", parsedXml);
           if (parsedXml) {
             responseContent = {
+              ...parsedXml,
               thought: parsedXml.thought || "",
               actions: parsedXml.actions || ["IGNORE"],
               providers: parsedXml.providers || [],
@@ -5633,17 +5788,19 @@ var messageReceivedHandler = async ({
           }
           retries++;
           if (!responseContent?.thought || !responseContent?.actions) {
-            logger17.warn("*** Missing required fields (thought or actions), retrying... ***");
+            logger19.warn(
+              "[Bootstrap] *** Missing required fields (thought or actions), retrying... ***"
+            );
           }
         }
         const currentResponseId = agentResponses.get(message.roomId);
         if (currentResponseId !== responseId) {
-          logger17.info(
+          logger19.info(
             `Response discarded - newer message being processed for agent: ${runtime.agentId}, room: ${message.roomId}`
           );
           return;
         }
-        if (responseContent) {
+        if (responseContent && message.id) {
           responseContent.inReplyTo = createUniqueUuid4(runtime, message.id);
           const responseMesssage = {
             id: asUUID(v4_default()),
@@ -5659,24 +5816,28 @@ var messageReceivedHandler = async ({
         if (agentResponses.size === 0) {
           latestResponseIds.delete(runtime.agentId);
         }
-        if (responseContent?.providers.length > 0) {
-          state = await runtime.composeState(message, null, [...responseContent?.providers]);
+        if (responseContent?.providers?.length && responseContent?.providers?.length > 0) {
+          state = await runtime.composeState(message, responseContent?.providers || []);
         }
-        if (responseContent && responseContent.simple && responseContent.text && (responseContent.actions.length === 0 || responseContent.actions.length === 1 && responseContent.actions[0].toUpperCase() === "REPLY")) {
+        if (responseContent && responseContent.simple && responseContent.text && (responseContent.actions?.length === 0 || responseContent.actions?.length === 1 && responseContent.actions[0].toUpperCase() === "REPLY")) {
           await callback(responseContent);
         } else {
           await runtime.processActions(message, responseMessages, state, callback);
         }
         await runtime.evaluate(message, state, shouldRespond, callback, responseMessages);
       } else {
-        logger17.debug("Agent decided not to respond (shouldRespond is false).");
+        logger19.debug("[Bootstrap] Agent decided not to respond (shouldRespond is false).");
         const currentResponseId = agentResponses.get(message.roomId);
         if (currentResponseId !== responseId) {
-          logger17.info(
+          logger19.info(
             `Ignore response discarded - newer message being processed for agent: ${runtime.agentId}, room: ${message.roomId}`
           );
           return;
         }
+        if (!message.id) {
+          logger19.error("[Bootstrap] Message ID is missing, cannot create ignore response.");
+          return;
+        }
         const ignoreContent = {
           thought: "Agent decided not to respond to this message.",
           actions: ["IGNORE"],
@@ -5695,7 +5856,7 @@ var messageReceivedHandler = async ({
           createdAt: Date.now()
         };
         await runtime.createMemory(ignoreMemory, "messages");
-        logger17.debug("Saved ignore response to memory", { memoryId: ignoreMemory.id });
+        logger19.debug("[Bootstrap] Saved ignore response to memory", { memoryId: ignoreMemory.id });
         agentResponses.delete(message.roomId);
         if (agentResponses.size === 0) {
           latestResponseIds.delete(runtime.agentId);
@@ -5723,13 +5884,12 @@ var messageReceivedHandler = async ({
         roomId: message.roomId,
         entityId: message.entityId,
         startTime,
-        status: "completed",
+        status: "error",
         endTime: Date.now(),
         duration: Date.now() - startTime,
         error: error.message,
         source: "messageHandler"
       });
-      throw error;
     }
   })();
   try {
@@ -5746,10 +5906,10 @@ var reactionReceivedHandler = async ({
     await runtime.createMemory(message, "messages");
   } catch (error) {
     if (error.code === "23505") {
-      logger17.warn("Duplicate reaction memory, skipping");
+      logger19.warn("[Bootstrap] Duplicate reaction memory, skipping");
       return;
     }
-    logger17.error("Error in reaction handler:", error);
+    logger19.error("[Bootstrap] Error in reaction handler:", error);
   }
 };
 var postGeneratedHandler = async ({
@@ -5760,7 +5920,7 @@ var postGeneratedHandler = async ({
   roomId,
   source
 }) => {
-  logger17.info("Generating new post...");
+  logger19.info("[Bootstrap] Generating new post...");
   await runtime.ensureWorldExists({
     id: worldId,
     name: `${runtime.character.name}'s Feed`,
@@ -5787,10 +5947,10 @@ var postGeneratedHandler = async ({
       type: "message"
     }
   };
-  let state = await runtime.composeState(message, null, [
+  let state = await runtime.composeState(message, [
     "PROVIDERS",
     "CHARACTER",
-    //'RECENT_MESSAGES',
+    "RECENT_MESSAGES",
     "ENTITIES"
   ]);
   const entity = await runtime.getEntityById(runtime.agentId);
@@ -5822,10 +5982,10 @@ var postGeneratedHandler = async ({
     }
     retries++;
     if (!responseContent?.thought || !responseContent?.actions) {
-      logger17.warn("*** Missing required fields, retrying... ***");
+      logger19.warn("[Bootstrap] *** Missing required fields, retrying... ***");
     }
   }
-  state = await runtime.composeState(message, responseContent.providers);
+  state = await runtime.composeState(message, responseContent?.providers);
   const postPrompt = composePromptFromState9({
     state,
     template: runtime.character.templates?.postCreationTemplate || postCreationTemplate
@@ -5835,7 +5995,10 @@ var postGeneratedHandler = async ({
   });
   const parsedXmlResponse = parseKeyValueXml(xmlResponseText);
   if (!parsedXmlResponse) {
-    logger17.error("Failed to parse XML response for post creation. Raw response:", xmlResponseText);
+    logger19.error(
+      "[Bootstrap] Failed to parse XML response for post creation. Raw response:",
+      xmlResponseText
+    );
     return;
   }
   function cleanupPostText(text) {
@@ -5851,7 +6014,7 @@ var postGeneratedHandler = async ({
   if (RM) {
     for (const m of RM.data.recentMessages) {
       if (cleanedText === m.content.text) {
-        logger17.log("we've already recently posted that, retrying", cleanedText);
+        logger19.log("[Bootstrap] Already recently posted that, retrying", cleanedText);
         postGeneratedHandler({
           runtime,
           callback,
@@ -5869,7 +6032,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)) {
-    logger17.log("got prompt moderation refusal, retrying", cleanedText);
+    logger19.log("[Bootstrap] Got prompt moderation refusal, retrying", cleanedText);
     postGeneratedHandler({
       runtime,
       callback,
@@ -5897,15 +6060,15 @@ var postGeneratedHandler = async ({
     }
   ];
   for (const message2 of responseMessages) {
-    await callback(message2.content);
+    await callback?.(message2.content);
   }
 };
 var syncSingleUser = async (entityId, runtime, serverId, channelId, type, source) => {
   try {
     const entity = await runtime.getEntityById(entityId);
-    logger17.info(`Syncing user: ${entity?.metadata[source]?.username || entityId}`);
+    logger19.info(`[Bootstrap] Syncing user: ${entity?.metadata?.[source]?.username || entityId}`);
     if (!channelId) {
-      logger17.warn(`Cannot sync user ${entity?.id} without a valid channelId`);
+      logger19.warn(`[Bootstrap] Cannot sync user ${entity?.id} without a valid channelId`);
       return;
     }
     const roomId = createUniqueUuid4(runtime, channelId);
@@ -5913,17 +6076,19 @@ var syncSingleUser = async (entityId, runtime, serverId, channelId, type, source
     await runtime.ensureConnection({
       entityId,
       roomId,
-      userName: entity?.metadata[source].username || entityId,
-      name: entity?.metadata[source].name || entity?.metadata[source].username || `User${entityId}`,
+      userName: entity?.metadata?.[source].username || entityId,
+      name: entity?.metadata?.[source].name || entity?.metadata?.[source].username || `User${entityId}`,
       source,
       channelId,
       serverId,
       type,
       worldId
     });
-    logger17.success(`Successfully synced user: ${entity?.id}`);
+    logger19.success(`[Bootstrap] Successfully synced user: ${entity?.id}`);
   } catch (error) {
-    logger17.error(`Error syncing user: ${error instanceof Error ? error.message : String(error)}`);
+    logger19.error(
+      `[Bootstrap] Error syncing user: ${error instanceof Error ? error.message : String(error)}`
+    );
   }
 };
 var handleServerSync = async ({
@@ -5934,7 +6099,7 @@ var handleServerSync = async ({
   source,
   onComplete
 }) => {
-  logger17.debug(`Handling server sync event for server: ${world.name}`);
+  logger19.debug(`[Bootstrap] Handling server sync event for server: ${world.name}`);
   try {
     await runtime.ensureWorldExists({
       id: world.id,
@@ -5963,14 +6128,22 @@ var handleServerSync = async ({
       for (let i2 = 0; i2 < entities.length; i2 += batchSize) {
         const entityBatch = entities.slice(i2, i2 + batchSize);
         const firstRoomUserIsIn = rooms.length > 0 ? rooms[0] : null;
+        if (!firstRoomUserIsIn) {
+          logger19.warn(`[Bootstrap] No rooms found for syncing users`);
+          continue;
+        }
         await Promise.all(
           entityBatch.map(async (entity) => {
             try {
+              if (!entity?.id) {
+                logger19.warn(`[Bootstrap] No entity ID found for syncing users`);
+                return;
+              }
               await runtime.ensureConnection({
                 entityId: entity.id,
                 roomId: firstRoomUserIsIn.id,
-                userName: entity.metadata[source].username,
-                name: entity.metadata[source].name,
+                userName: entity.metadata?.[source].username,
+                name: entity.metadata?.[source].name,
                 source,
                 channelId: firstRoomUserIsIn.channelId,
                 serverId: world.serverId,
@@ -5978,7 +6151,7 @@ var handleServerSync = async ({
                 worldId: world.id
               });
             } catch (err) {
-              logger17.warn(`Failed to sync user ${entity.metadata.username}: ${err}`);
+              logger19.warn(`[Bootstrap] Failed to sync user ${entity.metadata?.username}: ${err}`);
             }
           })
         );
@@ -5987,10 +6160,10 @@ var handleServerSync = async ({
         }
       }
     }
-    logger17.debug(`Successfully synced standardized world structure for ${world.name}`);
+    logger19.debug(`Successfully synced standardized world structure for ${world.name}`);
     onComplete?.();
   } catch (error) {
-    logger17.error(
+    logger19.error(
       `Error processing standardized server data: ${error instanceof Error ? error.message : String(error)}`
     );
   }
@@ -6001,7 +6174,7 @@ var controlMessageHandler = async ({
   source
 }) => {
   try {
-    logger17.debug(
+    logger19.debug(
       `[controlMessageHandler] Processing control message: ${message.payload.action} for room ${message.roomId}`
     );
     const serviceNames = Array.from(runtime.getAllServices().keys());
@@ -6019,22 +6192,26 @@ var controlMessageHandler = async ({
             roomId: message.roomId
           }
         });
-        logger17.debug(
+        logger19.debug(
           `[controlMessageHandler] Control message ${message.payload.action} sent successfully`
         );
       } else {
-        logger17.error("[controlMessageHandler] WebSocket service does not have sendMessage method");
+        logger19.error("[controlMessageHandler] WebSocket service does not have sendMessage method");
       }
     } else {
-      logger17.error("[controlMessageHandler] No WebSocket service found to send control message");
+      logger19.error("[controlMessageHandler] No WebSocket service found to send control message");
     }
   } catch (error) {
-    logger17.error(`[controlMessageHandler] Error processing control message: ${error}`);
+    logger19.error(`[controlMessageHandler] Error processing control message: ${error}`);
   }
 };
 var events = {
   [EventType2.MESSAGE_RECEIVED]: [
     async (payload) => {
+      if (!payload.callback) {
+        logger19.error("No callback provided for message");
+        return;
+      }
       await messageReceivedHandler({
         runtime: payload.runtime,
         message: payload.message,
@@ -6045,6 +6222,10 @@ var events = {
   ],
   [EventType2.VOICE_MESSAGE_RECEIVED]: [
     async (payload) => {
+      if (!payload.callback) {
+        logger19.error("No callback provided for voice message");
+        return;
+      }
       await messageReceivedHandler({
         runtime: payload.runtime,
         message: payload.message,
@@ -6067,7 +6248,7 @@ var events = {
   ],
   [EventType2.MESSAGE_SENT]: [
     async (payload) => {
-      logger17.debug(`Message sent: ${payload.message.content.text}`);
+      logger19.debug(`[Bootstrap] Message sent: ${payload.message.content.text}`);
     }
   ],
   [EventType2.WORLD_JOINED]: [
@@ -6082,6 +6263,18 @@ var events = {
   ],
   [EventType2.ENTITY_JOINED]: [
     async (payload) => {
+      if (!payload.worldId) {
+        logger19.error("[Bootstrap] No callback provided for entity joined");
+        return;
+      }
+      if (!payload.roomId) {
+        logger19.error("[Bootstrap] No roomId provided for entity joined");
+        return;
+      }
+      if (!payload.metadata?.type) {
+        logger19.error("[Bootstrap] No type provided for entity joined");
+        return;
+      }
       await syncSingleUser(
         payload.entityId,
         payload.runtime,
@@ -6104,32 +6297,36 @@ var events = {
           };
           await payload.runtime.updateEntity(entity);
         }
-        logger17.info(`User ${payload.entityId} left world ${payload.worldId}`);
+        logger19.info(`[Bootstrap] User ${payload.entityId} left world ${payload.worldId}`);
       } catch (error) {
-        logger17.error(`Error handling user left: ${error.message}`);
+        logger19.error(`[Bootstrap] Error handling user left: ${error.message}`);
       }
     }
   ],
   [EventType2.ACTION_STARTED]: [
     async (payload) => {
-      logger17.debug(`Action started: ${payload.actionName} (${payload.actionId})`);
+      logger19.debug(`[Bootstrap] Action started: ${payload.actionName} (${payload.actionId})`);
     }
   ],
   [EventType2.ACTION_COMPLETED]: [
     async (payload) => {
       const status = payload.error ? `failed: ${payload.error.message}` : "completed";
-      logger17.debug(`Action ${status}: ${payload.actionName} (${payload.actionId})`);
+      logger19.debug(`[Bootstrap] Action ${status}: ${payload.actionName} (${payload.actionId})`);
     }
   ],
   [EventType2.EVALUATOR_STARTED]: [
     async (payload) => {
-      logger17.debug(`Evaluator started: ${payload.evaluatorName} (${payload.evaluatorId})`);
+      logger19.debug(
+        `[Bootstrap] Evaluator started: ${payload.evaluatorName} (${payload.evaluatorId})`
+      );
     }
   ],
   [EventType2.EVALUATOR_COMPLETED]: [
     async (payload) => {
       const status = payload.error ? `failed: ${payload.error.message}` : "completed";
-      logger17.debug(`Evaluator ${status}: ${payload.evaluatorName} (${payload.evaluatorId})`);
+      logger19.debug(
+        `[Bootstrap] Evaluator ${status}: ${payload.evaluatorName} (${payload.evaluatorId})`
+      );
     }
   ],
   CONTROL_MESSAGE: [controlMessageHandler]
@@ -6151,6 +6348,7 @@ var bootstrapPlugin = {
     updateRoleAction,
     updateSettingsAction
   ],
+  // this is jank, these events are not valid
   events,
   evaluators: [reflectionEvaluator],
   providers: [