@elizaos/plugin-bootstrap 1.3.1 → 1.4.2

package/dist/index.js

@@ -83,6 +83,7 @@ import {
   ModelType as ModelType14,
   parseKeyValueXml as parseKeyValueXml9,
   postCreationTemplate,
+  parseBooleanFromText as parseBooleanFromText2,
   Role as Role2,
   shouldRespondTemplate,
   truncateToCompleteSentence,
@@ -337,7 +338,7 @@ var choiceAction = {
       }
       return pendingTasks && pendingTasks.length > 0 && pendingTasks.some((task) => task.metadata?.options);
     } catch (error) {
-      logger.error("Error validating choice action:", error);
+      logger.error({ error }, "Error validating choice action");
       return false;
     }
   },
@@ -518,7 +519,7 @@ ${task.options?.map((opt) => `- ${opt.name}: ${opt.description}`).join("\n")}`;
           success: true
         };
       } catch (error) {
-        logger.error("Error executing task with option:", error);
+        logger.error({ error }, "Error executing task with option");
         await callback?.({
           text: "There was an error processing your selection.",
           actions: ["SELECT_OPTION_ERROR"],
@@ -744,7 +745,7 @@ var followRoomAction = {
           success: true
         };
       } catch (error) {
-        logger2.error("Error following room:", error);
+        logger2.error({ error }, "Error following room");
         return {
           text: "Failed to follow room",
           values: {
@@ -1409,7 +1410,7 @@ var muteRoomAction = {
           success: true
         };
       } catch (error) {
-        logger3.error("Error muting room:", error);
+        logger3.error({ error }, "Error muting room");
         return {
           text: "Failed to mute room",
           values: {
@@ -2059,7 +2060,7 @@ IMPORTANT: Your response must ONLY contain the <response></response> XML block a
         await runtime.updateWorld(world);
         logger5.info(`Updated roles in world metadata for server ${serverId}`);
       } catch (error) {
-        logger5.error("Failed to save world updates:", error);
+        logger5.error({ error }, "Failed to save world updates");
         return {
           text: "Failed to save role updates",
           values: {
@@ -2900,7 +2901,7 @@ async function processSettingUpdates(runtime, serverId, worldSettings, updates)
     }
     return { updatedAny, messages };
   } catch (error) {
-    logger7.error("Error processing setting updates:", error);
+    logger7.error({ error }, "Error processing setting updates:");
     return {
       updatedAny: false,
       messages: ["Error occurred while updating settings"]
@@ -4082,7 +4083,7 @@ var unmuteRoomAction = {
           success: true
         };
       } catch (error) {
-        logger8.error("Error unmuting room:", error);
+        logger8.error({ error }, "Error unmuting room:");
         return {
           text: "Failed to unmute room",
           values: {
@@ -4666,7 +4667,7 @@ function resolveEntity(entityId, entities) {
 async function handler(runtime, message, state) {
   const { agentId, roomId } = message;
   if (!agentId || !roomId) {
-    logger10.warn("Missing agentId or roomId in message", message);
+    logger10.warn({ message }, "Missing agentId or roomId in message");
     return;
   }
   const [existingRelationships, entities, knownFacts] = await Promise.all([
@@ -4697,20 +4698,20 @@ async function handler(runtime, message, state) {
       prompt
     });
     if (!response) {
-      logger10.warn("Getting reflection failed - empty response", prompt);
+      logger10.warn({ prompt }, "Getting reflection failed - empty response");
       return;
     }
     const reflection = parseKeyValueXml8(response);
     if (!reflection) {
-      logger10.warn("Getting reflection failed - failed to parse XML", response);
+      logger10.warn({ response }, "Getting reflection failed - failed to parse XML");
       return;
     }
     if (!reflection.facts) {
-      logger10.warn("Getting reflection failed - invalid facts structure", reflection);
+      logger10.warn({ reflection }, "Getting reflection failed - invalid facts structure");
       return;
     }
     if (!reflection.relationships) {
-      logger10.warn("Getting reflection failed - invalid relationships structure", reflection);
+      logger10.warn({ reflection }, "Getting reflection failed - invalid relationships structure");
       return;
     }
     let factsArray = [];
@@ -4779,7 +4780,7 @@ async function handler(runtime, message, state) {
       message?.id || ""
     );
   } catch (error) {
-    logger10.error("Error in reflection handler:", error);
+    logger10.error({ error }, "Error in reflection handler:");
     return;
   }
 }
@@ -5105,7 +5106,7 @@ ${values}`;
         (msg) => msg.content?.type === "action_result" && msg.metadata?.type === "action_result"
       );
     } catch (error) {
-      logger11?.error("Failed to retrieve action memories:", error);
+      logger11?.error({ error }, "Failed to retrieve action memories:");
     }
     let actionMemoriesText = "";
     if (recentActionMemories.length > 0) {
@@ -5351,7 +5352,7 @@ var capabilitiesProvider = {
 ${formattedCapabilities}`
       };
     } catch (error) {
-      logger12.error("Error in capabilities provider:", error);
+      logger12.error({ error }, "Error in capabilities provider:");
       return {
         text: "Error retrieving capabilities from services."
       };
@@ -5530,7 +5531,7 @@ var choiceProvider = {
         text: output
       };
     } catch (error) {
-      logger13.error("Error in options provider:", error);
+      logger13.error({ error }, "Error in options provider:");
       return {
         data: {
           tasks: []
@@ -5756,7 +5757,7 @@ var factsProvider = {
         text
       };
     } catch (error) {
-      logger14.error("Error in factsProvider:", error);
+      logger14.error({ error }, "Error in factsProvider:");
       return {
         values: {
           facts: ""
@@ -6009,7 +6010,7 @@ ${runText}`;
         text
       };
     } catch (error) {
-      logger15.error("Error in recentMessagesProvider:", error);
+      logger15.error({ error }, "Error in recentMessagesProvider:");
       return {
         data: {
           recentMessages: [],
@@ -6512,7 +6513,7 @@ var worldProvider = {
   dynamic: true,
   get: async (runtime, message) => {
     try {
-      logger18.debug("[\u{1F310}] World provider activated for roomId:", message.roomId);
+      logger18.debug({ roomId: message.roomId }, "[\u{1F310}] World provider activated for roomId:");
       const currentRoom = await runtime.getRoom(message.roomId);
       if (!currentRoom) {
         logger18.warn(`World provider: Room not found for roomId ${message.roomId}`);
@@ -6742,7 +6743,7 @@ var TaskService = class _TaskService extends Service {
       try {
         await this.checkTasks();
       } catch (error) {
-        logger19.error("[Bootstrap] Error checking tasks:", error);
+        logger19.error({ error }, "[Bootstrap] Error checking tasks:");
       }
     }, this.TICK_INTERVAL);
   }
@@ -6771,7 +6772,10 @@ var TaskService = class _TaskService extends Service {
             continue;
           }
         } catch (error) {
-          logger19.error(`[Bootstrap] Error validating task ${task.name}:`, error);
+          logger19.error(
+            { error, taskName: task.name },
+            `[Bootstrap] Error validating task ${task.name}:`
+          );
           continue;
         }
       }
@@ -6826,7 +6830,7 @@ var TaskService = class _TaskService extends Service {
         }
       }
     } catch (error) {
-      logger19.error("[Bootstrap] Error checking tasks:", error);
+      logger19.error({ error }, "[Bootstrap] Error checking tasks:");
     }
   }
   /**
@@ -6865,7 +6869,7 @@ var TaskService = class _TaskService extends Service {
         );
       }
     } catch (error) {
-      logger19.error(`[Bootstrap] Error executing task ${task.id}:`, error);
+      logger19.error({ error, taskId: task.id }, `[Bootstrap] Error executing task ${task.id}:`);
     }
   }
   /**
@@ -6913,7 +6917,7 @@ async function processAttachments(attachments, runtime) {
   if (!attachments || attachments.length === 0) {
     return [];
   }
-  logger20.debug(`[Bootstrap] Processing ${attachments.length} attachment(s)`);
+  runtime.logger.debug(`[Bootstrap] Processing ${attachments.length} attachment(s)`);
   const processedAttachments = [];
   for (const attachment of attachments) {
     try {
@@ -6921,7 +6925,7 @@ async function processAttachments(attachments, runtime) {
       const isRemote = /^(http|https):\/\//.test(attachment.url);
       const url = isRemote ? attachment.url : getLocalServerUrl(attachment.url);
       if (attachment.contentType === ContentType2.IMAGE && !attachment.description) {
-        logger20.debug(`[Bootstrap] Generating description for image: ${attachment.url}`);
+        runtime.logger.debug(`[Bootstrap] Generating description for image: ${attachment.url}`);
         let imageUrl = url;
         if (!isRemote) {
           const res = await fetch(url);
@@ -6942,24 +6946,24 @@ async function processAttachments(attachments, runtime) {
               processedAttachment.description = parsedXml.description;
               processedAttachment.title = parsedXml.title || "Image";
               processedAttachment.text = parsedXml.text;
-              logger20.debug(
+              runtime.logger.debug(
                 `[Bootstrap] Generated description: ${processedAttachment.description?.substring(0, 100)}...`
               );
             } else {
-              logger20.warn(`[Bootstrap] Failed to parse XML response for image description`);
+              runtime.logger.warn(`[Bootstrap] Failed to parse XML response for image description`);
             }
           } else if (response && typeof response === "object" && "description" in response) {
             processedAttachment.description = response.description;
             processedAttachment.title = response.title || "Image";
             processedAttachment.text = response.description;
-            logger20.debug(
+            runtime.logger.debug(
               `[Bootstrap] Generated description: ${processedAttachment.description?.substring(0, 100)}...`
             );
           } else {
-            logger20.warn(`[Bootstrap] Unexpected response format for image description`);
+            runtime.logger.warn(`[Bootstrap] Unexpected response format for image description`);
           }
         } catch (error) {
-          logger20.error(`[Bootstrap] Error generating image description:`, error);
+          runtime.logger.error({ error }, `[Bootstrap] Error generating image description:`);
         }
       } else if (attachment.contentType === ContentType2.DOCUMENT && !attachment.text) {
         const res = await fetch(url);
@@ -6967,20 +6971,23 @@ async function processAttachments(attachments, runtime) {
         const contentType = res.headers.get("content-type") || "";
         const isPlainText = contentType.startsWith("text/plain");
         if (isPlainText) {
-          logger20.debug(`[Bootstrap] Processing plain text document: ${attachment.url}`);
+          runtime.logger.debug(`[Bootstrap] Processing plain text document: ${attachment.url}`);
           const textContent = await res.text();
           processedAttachment.text = textContent;
           processedAttachment.title = processedAttachment.title || "Text File";
-          logger20.debug(
+          runtime.logger.debug(
             `[Bootstrap] Extracted text content (first 100 chars): ${processedAttachment.text?.substring(0, 100)}...`
           );
         } else {
-          logger20.warn(`[Bootstrap] Skipping non-plain-text document: ${contentType}`);
+          runtime.logger.warn(`[Bootstrap] Skipping non-plain-text document: ${contentType}`);
         }
       }
       processedAttachments.push(processedAttachment);
     } catch (error) {
-      logger20.error(`[Bootstrap] Failed to process attachment ${attachment.url}:`, error);
+      runtime.logger.error(
+        { error, attachmentUrl: attachment.url },
+        `[Bootstrap] Failed to process attachment ${attachment.url}:`
+      );
       processedAttachments.push(attachment);
     }
   }
@@ -7025,7 +7032,9 @@ var messageReceivedHandler = async ({
   const timeoutDuration = 60 * 60 * 1e3;
   let timeoutId = void 0;
   try {
-    logger20.info(`[Bootstrap] Message received from ${message.entityId} in room ${message.roomId}`);
+    runtime.logger.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());
@@ -7034,6 +7043,12 @@ var messageReceivedHandler = async ({
     if (!agentResponses) {
       throw new Error("Agent responses map not found");
     }
+    const previousResponseId = agentResponses.get(message.roomId);
+    if (previousResponseId) {
+      logger20.warn(
+        `[Bootstrap] Updating response ID for room ${message.roomId} from ${previousResponseId} to ${responseId} - this may discard in-progress responses`
+      );
+    }
     agentResponses.set(message.roomId, responseId);
     const runId = runtime.startRun();
     const startTime = Date.now();
@@ -7045,7 +7060,10 @@ var messageReceivedHandler = async ({
       entityId: message.entityId,
       startTime,
       status: "started",
-      source: "messageHandler"
+      source: "messageHandler",
+      // this shouldn't be a standard
+      // but we need to expose content somewhere
+      metadata: message.content
     });
     const timeoutPromise = new Promise((_, reject) => {
       timeoutId = setTimeout(async () => {
@@ -7068,23 +7086,65 @@ var messageReceivedHandler = async ({
     const processingPromise = (async () => {
       try {
         if (message.entityId === runtime.agentId) {
-          logger20.debug(`[Bootstrap] Skipping message from self (${runtime.agentId})`);
+          runtime.logger.debug(`[Bootstrap] Skipping message from self (${runtime.agentId})`);
           throw new Error("Message is from the agent itself");
         }
-        logger20.debug(
+        runtime.logger.debug(
           `[Bootstrap] Processing message: ${truncateToCompleteSentence(message.content.text || "", 50)}...`
         );
-        logger20.debug("[Bootstrap] Saving message to memory and embeddings");
-        await Promise.all([
-          runtime.addEmbeddingToMemory(message),
-          runtime.createMemory(message, "messages")
-        ]);
+        runtime.logger.debug("[Bootstrap] Saving message to memory and embeddings");
+        if (message.id) {
+          const existingMemory = await runtime.getMemoryById(message.id);
+          if (existingMemory) {
+            runtime.logger.debug("[Bootstrap] Memory already exists, skipping creation");
+            await runtime.addEmbeddingToMemory(message);
+          } else {
+            await Promise.all([
+              runtime.addEmbeddingToMemory(message),
+              runtime.createMemory(message, "messages")
+            ]);
+          }
+        } else {
+          await Promise.all([
+            runtime.addEmbeddingToMemory(message),
+            runtime.createMemory(message, "messages")
+          ]);
+        }
         const agentUserState = await runtime.getParticipantUserState(
           message.roomId,
           runtime.agentId
         );
+        const defLllmOff = parseBooleanFromText2(runtime.getSetting("BOOTSTRAP_DEFLLMOFF"));
+        if (defLllmOff && agentUserState === null) {
+          runtime.logger.debug("bootstrap - LLM is off by default");
+          await runtime.emitEvent(EventType.RUN_ENDED, {
+            runtime,
+            runId,
+            messageId: message.id,
+            roomId: message.roomId,
+            entityId: message.entityId,
+            startTime,
+            status: "off",
+            endTime: Date.now(),
+            duration: Date.now() - startTime,
+            source: "messageHandler"
+          });
+          return;
+        }
         if (agentUserState === "MUTED" && !message.content.text?.toLowerCase().includes(runtime.character.name.toLowerCase())) {
-          logger20.debug(`[Bootstrap] Ignoring muted room ${message.roomId}`);
+          runtime.logger.debug(`[Bootstrap] Ignoring muted room ${message.roomId}`);
+          await runtime.emitEvent(EventType.RUN_ENDED, {
+            runtime,
+            runId,
+            messageId: message.id,
+            roomId: message.roomId,
+            entityId: message.entityId,
+            startTime,
+            status: "muted",
+            endTime: Date.now(),
+            duration: Date.now() - startTime,
+            source: "messageHandler"
+          });
           return;
         }
         let state = await runtime.composeState(
@@ -7116,50 +7176,50 @@ var messageReceivedHandler = async ({
             state,
             template: runtime.character.templates?.shouldRespondTemplate || shouldRespondTemplate
           });
-          logger20.debug(
+          runtime.logger.debug(
             `[Bootstrap] Evaluating response for ${runtime.character.name}
 Prompt: ${shouldRespondPrompt}`
           );
           const response = await runtime.useModel(ModelType14.TEXT_SMALL, {
             prompt: shouldRespondPrompt
           });
-          logger20.debug(
+          runtime.logger.debug(
             `[Bootstrap] Response evaluation for ${runtime.character.name}:
 ${response}`
           );
-          logger20.debug(`[Bootstrap] Response type: ${typeof response}`);
+          runtime.logger.debug(`[Bootstrap] Response type: ${typeof response}`);
           const responseObject = parseKeyValueXml9(response);
-          logger20.debug("[Bootstrap] Parsed response:", responseObject);
+          runtime.logger.debug({ responseObject }, "[Bootstrap] Parsed response:");
           const nonResponseActions = ["IGNORE", "NONE"];
           shouldRespond = responseObject?.action && !nonResponseActions.includes(responseObject.action.toUpperCase());
         } else {
-          logger20.debug(
+          runtime.logger.debug(
             `[Bootstrap] Skipping shouldRespond check for ${runtime.character.name} because ${room?.type} ${room?.source}`
           );
           shouldRespond = true;
         }
         let responseMessages = [];
-        console.log("shouldRespond is", shouldRespond);
-        console.log("shouldSkipShouldRespond", shouldSkipShouldRespond);
+        let responseContent = null;
         if (shouldRespond) {
           state = await runtime.composeState(message, ["ACTIONS"]);
           if (!state.values.actionNames) {
-            logger20.warn("actionNames data missing from state, even though it was requested");
+            runtime.logger.warn(
+              "actionNames data missing from state, even though it was requested"
+            );
           }
           const prompt = composePromptFromState10({
             state,
             template: runtime.character.templates?.messageHandlerTemplate || messageHandlerTemplate
           });
-          let responseContent = null;
           let retries = 0;
           const maxRetries = 3;
           while (retries < maxRetries && (!responseContent?.thought || !responseContent?.actions)) {
             let response = await runtime.useModel(ModelType14.TEXT_LARGE, {
               prompt
             });
-            logger20.debug("[Bootstrap] *** Raw LLM Response ***\n", response);
+            runtime.logger.debug({ response }, "[Bootstrap] *** Raw LLM Response ***");
             const parsedXml = parseKeyValueXml9(response);
-            logger20.debug("[Bootstrap] *** Parsed XML Content ***\n", parsedXml);
+            runtime.logger.debug({ parsedXml }, "[Bootstrap] *** Parsed XML Content ***");
             if (parsedXml) {
               responseContent = {
                 ...parsedXml,
@@ -7174,17 +7234,15 @@ ${response}`
             }
             retries++;
             if (!responseContent?.thought || !responseContent?.actions) {
-              logger20.warn(
-                "[Bootstrap] *** Missing required fields (thought or actions), retrying... ***\n",
-                response,
-                parsedXml,
-                responseContent
+              runtime.logger.warn(
+                { response, parsedXml, responseContent },
+                "[Bootstrap] *** Missing required fields (thought or actions), retrying... ***"
               );
             }
           }
           const currentResponseId = agentResponses.get(message.roomId);
           if (currentResponseId !== responseId) {
-            logger20.info(
+            runtime.logger.info(
               `Response discarded - newer message being processed for agent: ${runtime.agentId}, room: ${message.roomId}`
             );
             return;
@@ -7232,24 +7290,74 @@ ${response}`
           }
           if (responseContent && responseContent.simple && responseContent.text) {
             if (responseContent.providers && responseContent.providers.length > 0) {
-              logger20.debug("[Bootstrap] Simple response used providers", responseContent.providers);
+              runtime.logger.debug(
+                { providers: responseContent.providers },
+                "[Bootstrap] Simple response used providers"
+              );
             }
             await callback(responseContent);
           } else {
-            await runtime.processActions(message, responseMessages, state, callback);
+            await runtime.processActions(message, responseMessages, state, async (content) => {
+              runtime.logger.debug({ content }, "action callback");
+              if (responseContent) {
+                responseContent.actionCallbacks = content;
+              }
+              return callback(content);
+            });
           }
-          await runtime.evaluate(message, state, shouldRespond, callback, responseMessages);
+          await runtime.evaluate(
+            message,
+            state,
+            shouldRespond,
+            async (content) => {
+              runtime.logger.debug({ content }, "evaluate callback");
+              if (responseContent) {
+                responseContent.evalCallbacks = content;
+              }
+              return callback(content);
+            },
+            responseMessages
+          );
         } else {
-          logger20.debug("[Bootstrap] Agent decided not to respond (shouldRespond is false).");
+          runtime.logger.debug(
+            "[Bootstrap] Agent decided not to respond (shouldRespond is false)."
+          );
           const currentResponseId = agentResponses.get(message.roomId);
-          if (currentResponseId !== responseId) {
-            logger20.info(
+          const keepResp = parseBooleanFromText2(runtime.getSetting("BOOTSTRAP_KEEP_RESP"));
+          if (currentResponseId !== responseId && !keepResp) {
+            runtime.logger.info(
               `Ignore response discarded - newer message being processed for agent: ${runtime.agentId}, room: ${message.roomId}`
             );
+            await runtime.emitEvent(EventType.RUN_ENDED, {
+              runtime,
+              runId,
+              messageId: message.id,
+              roomId: message.roomId,
+              entityId: message.entityId,
+              startTime,
+              status: "replaced",
+              endTime: Date.now(),
+              duration: Date.now() - startTime,
+              source: "messageHandler"
+            });
             return;
           }
           if (!message.id) {
-            logger20.error("[Bootstrap] Message ID is missing, cannot create ignore response.");
+            runtime.logger.error(
+              "[Bootstrap] Message ID is missing, cannot create ignore response."
+            );
+            await runtime.emitEvent(EventType.RUN_ENDED, {
+              runtime,
+              runId,
+              messageId: message.id,
+              roomId: message.roomId,
+              entityId: message.entityId,
+              startTime,
+              status: "noMessageId",
+              endTime: Date.now(),
+              duration: Date.now() - startTime,
+              source: "messageHandler"
+            });
             return;
           }
           const ignoreContent = {
@@ -7270,7 +7378,7 @@ ${response}`
             createdAt: Date.now()
           };
           await runtime.createMemory(ignoreMemory, "messages");
-          logger20.debug("[Bootstrap] Saved ignore response to memory", {
+          runtime.logger.debug("[Bootstrap] Saved ignore response to memory", {
             memoryId: ignoreMemory.id
           });
           agentResponses.delete(message.roomId);
@@ -7278,6 +7386,51 @@ ${response}`
             latestResponseIds.delete(runtime.agentId);
           }
         }
+        let entityName = "noname";
+        if (message.metadata && "entityName" in message.metadata) {
+          entityName = message.metadata.entityName;
+        }
+        const isDM = message.content?.channelType?.toUpperCase() === "DM";
+        let roomName = entityName;
+        if (!isDM) {
+          const roomDatas = await runtime.getRoomsByIds([message.roomId]);
+          if (roomDatas?.length) {
+            const roomData = roomDatas[0];
+            if (roomData.name) {
+              roomName = roomData.name;
+            }
+            if (roomData.worldId) {
+              const worldData = await runtime.getWorld(roomData.worldId);
+              if (worldData) {
+                roomName = worldData.name + "-" + roomName;
+              }
+            }
+          }
+        }
+        const date = /* @__PURE__ */ new Date();
+        const availableActions = state.data?.providers?.ACTIONS?.data?.actionsData?.map(
+          (a2) => a2.name
+        ) || [-1];
+        const logData = {
+          at: date.toString(),
+          timestamp: parseInt("" + date.getTime() / 1e3),
+          messageId: message.id,
+          // can extract roomId or whatever
+          userEntityId: message.entityId,
+          input: message.content.text,
+          thought: responseContent?.thought,
+          simple: responseContent?.simple,
+          availableActions,
+          actions: responseContent?.actions,
+          providers: responseContent?.providers,
+          irt: responseContent?.inReplyTo,
+          output: responseContent?.text,
+          // to strip out
+          entityName,
+          source: message.content.source,
+          channelType: message.content.channelType,
+          roomName
+        };
         await runtime.emitEvent(EventType.RUN_ENDED, {
           runtime,
           runId,
@@ -7288,7 +7441,10 @@ ${response}`
           status: "completed",
           endTime: Date.now(),
           duration: Date.now() - startTime,
-          source: "messageHandler"
+          source: "messageHandler",
+          entityName,
+          responseContent,
+          metadata: logData
         });
       } catch (error) {
         console.error("error is", error);
@@ -7321,10 +7477,10 @@ var reactionReceivedHandler = async ({
     await runtime.createMemory(message, "messages");
   } catch (error) {
     if (error.code === "23505") {
-      logger20.warn("[Bootstrap] Duplicate reaction memory, skipping");
+      runtime.logger.warn("[Bootstrap] Duplicate reaction memory, skipping");
       return;
     }
-    logger20.error("[Bootstrap] Error in reaction handler:", error);
+    runtime.logger.error({ error }, "[Bootstrap] Error in reaction handler:");
   }
 };
 var messageDeletedHandler = async ({
@@ -7333,14 +7489,22 @@ var messageDeletedHandler = async ({
 }) => {
   try {
     if (!message.id) {
-      logger20.error("[Bootstrap] Cannot delete memory: message ID is missing");
+      runtime.logger.error("[Bootstrap] Cannot delete memory: message ID is missing");
       return;
     }
-    logger20.info("[Bootstrap] Deleting memory for message", message.id, "from room", message.roomId);
+    runtime.logger.info(
+      "[Bootstrap] Deleting memory for message",
+      message.id,
+      "from room",
+      message.roomId
+    );
     await runtime.deleteMemory(message.id);
-    logger20.debug("[Bootstrap] Successfully deleted memory for message", message.id);
+    runtime.logger.debug(
+      { messageId: message.id },
+      "[Bootstrap] Successfully deleted memory for message"
+    );
   } catch (error) {
-    logger20.error("[Bootstrap] Error in message deleted handler:", error);
+    runtime.logger.error({ error }, "[Bootstrap] Error in message deleted handler:");
   }
 };
 var channelClearedHandler = async ({
@@ -7350,7 +7514,7 @@ var channelClearedHandler = async ({
   memoryCount
 }) => {
   try {
-    logger20.info(
+    runtime.logger.info(
       `[Bootstrap] Clearing ${memoryCount} message memories from channel ${channelId} -> room ${roomId}`
     );
     const memories = await runtime.getMemoriesByRoomIds({
@@ -7364,15 +7528,18 @@ var channelClearedHandler = async ({
           await runtime.deleteMemory(memory.id);
           deletedCount++;
         } catch (error) {
-          logger20.warn(`[Bootstrap] Failed to delete message memory ${memory.id}:`, error);
+          runtime.logger.warn(
+            { error, memoryId: memory.id },
+            `[Bootstrap] Failed to delete message memory ${memory.id}:`
+          );
         }
       }
     }
-    logger20.info(
+    runtime.logger.info(
       `[Bootstrap] Successfully cleared ${deletedCount}/${memories.length} message memories from channel ${channelId}`
     );
   } catch (error) {
-    logger20.error("[Bootstrap] Error in channel cleared handler:", error);
+    runtime.logger.error({ error }, "[Bootstrap] Error in channel cleared handler:");
   }
 };
 var postGeneratedHandler = async ({
@@ -7383,7 +7550,7 @@ var postGeneratedHandler = async ({
   roomId,
   source
 }) => {
-  logger20.info("[Bootstrap] Generating new post...");
+  runtime.logger.info("[Bootstrap] Generating new post...");
   await runtime.ensureWorldExists({
     id: worldId,
     name: `${runtime.character.name}'s Feed`,
@@ -7447,7 +7614,7 @@ var postGeneratedHandler = async ({
     }
     retries++;
     if (!responseContent?.thought || !responseContent?.actions) {
-      logger20.warn(
+      runtime.logger.warn(
         "[Bootstrap] *** Missing required fields, retrying... ***\n",
         response,
         parsedXml,
@@ -7465,7 +7632,7 @@ var postGeneratedHandler = async ({
   });
   const parsedXmlResponse = parseKeyValueXml9(xmlResponseText);
   if (!parsedXmlResponse) {
-    logger20.error(
+    runtime.logger.error(
       "[Bootstrap] Failed to parse XML response for post creation. Raw response:",
       xmlResponseText
     );
@@ -7482,7 +7649,7 @@ var postGeneratedHandler = async ({
   if (RM) {
     for (const m of RM.data.recentMessages) {
       if (cleanedText === m.content.text) {
-        logger20.log("[Bootstrap] Already recently posted that, retrying", cleanedText);
+        runtime.logger.info({ cleanedText }, "[Bootstrap] Already recently posted that, retrying");
         postGeneratedHandler({
           runtime,
           callback,
@@ -7500,7 +7667,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)) {
-    logger20.log("[Bootstrap] Got prompt moderation refusal, retrying", cleanedText);
+    runtime.logger.info({ cleanedText }, "[Bootstrap] Got prompt moderation refusal, retrying");
     postGeneratedHandler({
       runtime,
       callback,
@@ -7534,9 +7701,9 @@ var postGeneratedHandler = async ({
 var syncSingleUser = async (entityId, runtime, serverId, channelId, type, source) => {
   try {
     const entity = await runtime.getEntityById(entityId);
-    logger20.info(`[Bootstrap] Syncing user: ${entity?.metadata?.username || entityId}`);
+    runtime.logger.info(`[Bootstrap] Syncing user: ${entity?.metadata?.username || entityId}`);
     if (!channelId) {
-      logger20.warn(`[Bootstrap] Cannot sync user ${entity?.id} without a valid channelId`);
+      runtime.logger.warn(`[Bootstrap] Cannot sync user ${entity?.id} without a valid channelId`);
       return;
     }
     const roomId = createUniqueUuid3(runtime, channelId);
@@ -7551,7 +7718,7 @@ var syncSingleUser = async (entityId, runtime, serverId, channelId, type, source
       settings: {}
       // Initialize empty settings for onboarding
     } : void 0;
-    logger20.info(
+    runtime.logger.info(
       `[Bootstrap] syncSingleUser - type: ${type}, isDM: ${type === ChannelType9.DM}, worldMetadata: ${JSON.stringify(worldMetadata)}`
     );
     await runtime.ensureConnection({
@@ -7567,15 +7734,15 @@ var syncSingleUser = async (entityId, runtime, serverId, channelId, type, source
     });
     try {
       const createdWorld = await runtime.getWorld(worldId);
-      logger20.info(
+      runtime.logger.info(
         `[Bootstrap] Created world check - ID: ${worldId}, metadata: ${JSON.stringify(createdWorld?.metadata)}`
       );
     } catch (error) {
-      logger20.error(`[Bootstrap] Failed to verify created world: ${error}`);
+      runtime.logger.error(`[Bootstrap] Failed to verify created world: ${error}`);
     }
-    logger20.success(`[Bootstrap] Successfully synced user: ${entity?.id}`);
+    runtime.logger.success(`[Bootstrap] Successfully synced user: ${entity?.id}`);
   } catch (error) {
-    logger20.error(
+    runtime.logger.error(
       `[Bootstrap] Error syncing user: ${error instanceof Error ? error.message : String(error)}`
     );
   }
@@ -7588,13 +7755,13 @@ var handleServerSync = async ({
   source,
   onComplete
 }) => {
-  logger20.debug(`[Bootstrap] Handling server sync event for server: ${world.name}`);
+  runtime.logger.debug(`[Bootstrap] Handling server sync event for server: ${world.name}`);
   try {
     await runtime.ensureConnections(entities, rooms, source, world);
-    logger20.debug(`Successfully synced standardized world structure for ${world.name}`);
+    runtime.logger.debug(`Successfully synced standardized world structure for ${world.name}`);
     onComplete?.();
   } catch (error) {
-    logger20.error(
+    runtime.logger.error(
       `Error processing standardized server data: ${error instanceof Error ? error.message : String(error)}`
     );
   }
@@ -7604,7 +7771,7 @@ var controlMessageHandler = async ({
   message
 }) => {
   try {
-    logger20.debug(
+    runtime.logger.debug(
       `[controlMessageHandler] Processing control message: ${message.payload.action} for room ${message.roomId}`
     );
     const serviceNames = Array.from(runtime.getAllServices().keys());
@@ -7622,24 +7789,28 @@ var controlMessageHandler = async ({
             roomId: message.roomId
           }
         });
-        logger20.debug(
+        runtime.logger.debug(
           `[controlMessageHandler] Control message ${message.payload.action} sent successfully`
         );
       } else {
-        logger20.error("[controlMessageHandler] WebSocket service does not have sendMessage method");
+        runtime.logger.error(
+          "[controlMessageHandler] WebSocket service does not have sendMessage method"
+        );
       }
     } else {
-      logger20.error("[controlMessageHandler] No WebSocket service found to send control message");
+      runtime.logger.error(
+        "[controlMessageHandler] No WebSocket service found to send control message"
+      );
     }
   } catch (error) {
-    logger20.error(`[controlMessageHandler] Error processing control message: ${error}`);
+    runtime.logger.error(`[controlMessageHandler] Error processing control message: ${error}`);
   }
 };
 var events = {
   [EventType.MESSAGE_RECEIVED]: [
     async (payload) => {
       if (!payload.callback) {
-        logger20.error("No callback provided for message");
+        payload.runtime.logger.error("No callback provided for message");
         return;
       }
       await messageReceivedHandler({
@@ -7653,7 +7824,7 @@ var events = {
   [EventType.VOICE_MESSAGE_RECEIVED]: [
     async (payload) => {
       if (!payload.callback) {
-        logger20.error("No callback provided for voice message");
+        payload.runtime.logger.error("No callback provided for voice message");
         return;
       }
       await messageReceivedHandler({
@@ -7679,7 +7850,7 @@ var events = {
   ],
   [EventType.MESSAGE_SENT]: [
     async (payload) => {
-      logger20.debug(`[Bootstrap] Message sent: ${payload.message.content.text}`);
+      payload.runtime.logger.debug(`[Bootstrap] Message sent: ${payload.message.content.text}`);
     }
   ],
   [EventType.MESSAGE_DELETED]: [
@@ -7712,17 +7883,19 @@ var events = {
   ],
   [EventType.ENTITY_JOINED]: [
     async (payload) => {
-      logger20.debug(`[Bootstrap] ENTITY_JOINED event received for entity ${payload.entityId}`);
+      payload.runtime.logger.debug(
+        `[Bootstrap] ENTITY_JOINED event received for entity ${payload.entityId}`
+      );
       if (!payload.worldId) {
-        logger20.error("[Bootstrap] No worldId provided for entity joined");
+        payload.runtime.logger.error("[Bootstrap] No worldId provided for entity joined");
         return;
       }
       if (!payload.roomId) {
-        logger20.error("[Bootstrap] No roomId provided for entity joined");
+        payload.runtime.logger.error("[Bootstrap] No roomId provided for entity joined");
         return;
       }
       if (!payload.metadata?.type) {
-        logger20.error("[Bootstrap] No type provided for entity joined");
+        payload.runtime.logger.error("[Bootstrap] No type provided for entity joined");
         return;
       }
       await syncSingleUser(
@@ -7747,9 +7920,11 @@ var events = {
           };
           await payload.runtime.updateEntity(entity);
         }
-        logger20.info(`[Bootstrap] User ${payload.entityId} left world ${payload.worldId}`);
+        payload.runtime.logger.info(
+          `[Bootstrap] User ${payload.entityId} left world ${payload.worldId}`
+        );
       } catch (error) {
-        logger20.error(`[Bootstrap] Error handling user left: ${error.message}`);
+        payload.runtime.logger.error(`[Bootstrap] Error handling user left: ${error.message}`);
       }
     }
   ],