@elizaos/plugin-bootstrap 1.0.0-beta.49 → 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,
@@ -190,61 +190,69 @@ 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 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}
+    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 selectedTask = tasksWithOptions.find((task) => task.id === taskInfo.fullId);
-        if (!selectedTask) {
+    }).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?.({
+          text: "Error locating the selected task. Please try again.",
+          actions: ["SELECT_OPTION_ERROR"],
+          source: message.content.source
+        });
+        return;
+      }
+      if (selectedOption === "ABORT") {
+        if (!selectedTask?.id) {
           await callback?.({
             text: "Error locating the selected task. Please try again.",
             actions: ["SELECT_OPTION_ERROR"],
@@ -252,67 +260,50 @@ ${task.options?.map((opt) => `- ${opt.name}: ${opt.description}`).join("\n")}`;
           });
           return;
         }
-        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;
-          }
-          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: [
     [
@@ -4247,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");
 }
@@ -4255,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
-    };
   }
 };
 
@@ -4377,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]);
@@ -4393,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
+      };
+    }
   }
 };
 
@@ -4595,7 +4639,7 @@ ${formattedRelationships}`
 import {
   ChannelType as ChannelType6,
   createUniqueUuid as createUniqueUuid2,
-  logger as logger12
+  logger as logger14
 } from "@elizaos/core";
 var roleProvider = {
   name: "ROLES",
@@ -4620,110 +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;
-        }
-        if (!name || !username || !names) {
-          logger12.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})
-`;
-        });
-      }
+    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: "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: "There was an error retrieving role information."
+          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
+    };
   }
 };
 
@@ -4732,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";
@@ -4803,7 +4845,7 @@ ${requiredUnconfigured > 0 ? `IMPORTANT!: ${requiredUnconfigured} required setti
 **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.";
   }
 }
@@ -4816,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: []
@@ -4832,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: []
@@ -4851,36 +4893,36 @@ var settingsProvider = {
       if (isOnboarding) {
         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 ? {
@@ -4902,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: []
@@ -4932,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: []
@@ -4971,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";
@@ -4981,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: {
@@ -4994,10 +5036,10 @@ 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) {
-        logger14.warn(`World provider: World ID not found for roomId ${message.roomId}`);
+        logger16.warn(`World provider: World ID not found for roomId ${message.roomId}`);
         return {
           data: {
             world: {
@@ -5009,7 +5051,7 @@ var worldProvider = {
       }
       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: {
@@ -5019,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 = {
@@ -5036,7 +5078,7 @@ var worldProvider = {
       };
       for (const room of worldRooms) {
         if (!room?.id || !room.name) {
-          logger14.warn(`World provider: Room ID or name is missing for room ${room.id}`);
+          logger16.warn(`World provider: Room ID or name is missing for room ${room.id}`);
           continue;
         }
         const roomInfo = {
@@ -5105,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 {
@@ -5134,7 +5176,7 @@ import {
   EventType,
   Service,
   createUniqueUuid as createUniqueUuid3,
-  logger as logger15
+  logger as logger17
 } from "@elizaos/core";
 var ScenarioService = class _ScenarioService extends Service {
   /**
@@ -5178,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(
@@ -5189,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();
       }
     );
@@ -5270,7 +5312,8 @@ var ScenarioService = class _ScenarioService extends Service {
       source: "scenario",
       type: ChannelType9.GROUP,
       channelId: roomId,
-      serverId: worldId
+      serverId: worldId,
+      worldId
     });
     return roomId;
   }
@@ -5370,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";
@@ -5398,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");
@@ -5449,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);
   }
@@ -5478,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;
         }
       }
@@ -5520,20 +5563,20 @@ var TaskService = class _TaskService extends Service2 {
         }
         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);
     }
   }
   /**
@@ -5544,12 +5587,12 @@ var TaskService = class _TaskService extends Service2 {
   async executeTask(task) {
     try {
       if (!task || !task.id) {
-        logger16.debug(`Task not found`);
+        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")) {
@@ -5559,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);
     }
   }
   /**
@@ -5618,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());
@@ -5662,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, [
@@ -5681,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;
@@ -5719,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 || [],
@@ -5735,12 +5788,14 @@ 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;
@@ -5761,8 +5816,8 @@ var messageReceivedHandler = async ({
         if (agentResponses.size === 0) {
           latestResponseIds.delete(runtime.agentId);
         }
-        if (responseContent?.providers?.length && responseContent.providers.length > 0) {
-          state = await runtime.composeState(message, void 0, [...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")) {
           await callback(responseContent);
@@ -5771,16 +5826,16 @@ var messageReceivedHandler = async ({
         }
         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) {
-          logger17.error("Message ID is missing, cannot create ignore response.");
+          logger19.error("[Bootstrap] Message ID is missing, cannot create ignore response.");
           return;
         }
         const ignoreContent = {
@@ -5801,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);
@@ -5829,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 {
@@ -5852,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 ({
@@ -5866,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`,
@@ -5893,10 +5947,10 @@ var postGeneratedHandler = async ({
       type: "message"
     }
   };
-  let state = await runtime.composeState(message, void 0, [
+  let state = await runtime.composeState(message, [
     "PROVIDERS",
     "CHARACTER",
-    //'RECENT_MESSAGES',
+    "RECENT_MESSAGES",
     "ENTITIES"
   ]);
   const entity = await runtime.getEntityById(runtime.agentId);
@@ -5928,7 +5982,7 @@ 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);
@@ -5941,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) {
@@ -5957,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,
@@ -5975,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,
@@ -6009,9 +6066,9 @@ var postGeneratedHandler = async ({
 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);
@@ -6027,9 +6084,11 @@ var syncSingleUser = async (entityId, runtime, serverId, channelId, type, source
       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 ({
@@ -6040,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,
@@ -6070,14 +6129,14 @@ var handleServerSync = async ({
         const entityBatch = entities.slice(i2, i2 + batchSize);
         const firstRoomUserIsIn = rooms.length > 0 ? rooms[0] : null;
         if (!firstRoomUserIsIn) {
-          logger17.warn(`No rooms found for syncing users`);
+          logger19.warn(`[Bootstrap] No rooms found for syncing users`);
           continue;
         }
         await Promise.all(
           entityBatch.map(async (entity) => {
             try {
               if (!entity?.id) {
-                logger17.warn(`No entity ID found for syncing users`);
+                logger19.warn(`[Bootstrap] No entity ID found for syncing users`);
                 return;
               }
               await runtime.ensureConnection({
@@ -6092,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}`);
             }
           })
         );
@@ -6101,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)}`
     );
   }
@@ -6115,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());
@@ -6133,24 +6192,24 @@ 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) {
-        logger17.error("No callback provided for message");
+        logger19.error("No callback provided for message");
         return;
       }
       await messageReceivedHandler({
@@ -6164,7 +6223,7 @@ var events = {
   [EventType2.VOICE_MESSAGE_RECEIVED]: [
     async (payload) => {
       if (!payload.callback) {
-        logger17.error("No callback provided for voice message");
+        logger19.error("No callback provided for voice message");
         return;
       }
       await messageReceivedHandler({
@@ -6189,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]: [
@@ -6205,15 +6264,15 @@ var events = {
   [EventType2.ENTITY_JOINED]: [
     async (payload) => {
       if (!payload.worldId) {
-        logger17.error("No callback provided for entity joined");
+        logger19.error("[Bootstrap] No callback provided for entity joined");
         return;
       }
       if (!payload.roomId) {
-        logger17.error("No roomId provided for entity joined");
+        logger19.error("[Bootstrap] No roomId provided for entity joined");
         return;
       }
       if (!payload.metadata?.type) {
-        logger17.error("No type provided for entity joined");
+        logger19.error("[Bootstrap] No type provided for entity joined");
         return;
       }
       await syncSingleUser(
@@ -6238,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]