@elizaos/plugin-bootstrap 1.3.1 → 1.3.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,
@@ -6913,7 +6914,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 +6922,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 +6943,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(`[Bootstrap] Error generating image description:`, error);
         }
       } else if (attachment.contentType === ContentType2.DOCUMENT && !attachment.text) {
         const res = await fetch(url);
@@ -6967,20 +6968,20 @@ 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(`[Bootstrap] Failed to process attachment ${attachment.url}:`, error);
       processedAttachments.push(attachment);
     }
   }
@@ -7025,7 +7026,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 +7037,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 +7054,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 +7080,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 +7170,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("[Bootstrap] Parsed response:", responseObject);
           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("[Bootstrap] *** Raw LLM Response ***\n", response);
             const parsedXml = parseKeyValueXml9(response);
-            logger20.debug("[Bootstrap] *** Parsed XML Content ***\n", parsedXml);
+            runtime.logger.debug("[Bootstrap] *** Parsed XML Content ***\n", parsedXml);
             if (parsedXml) {
               responseContent = {
                 ...parsedXml,
@@ -7174,7 +7228,7 @@ ${response}`
             }
             retries++;
             if (!responseContent?.thought || !responseContent?.actions) {
-              logger20.warn(
+              runtime.logger.warn(
                 "[Bootstrap] *** Missing required fields (thought or actions), retrying... ***\n",
                 response,
                 parsedXml,
@@ -7184,7 +7238,7 @@ ${response}`
           }
           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 +7286,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(
+                "[Bootstrap] Simple response used providers",
+                responseContent.providers
+              );
             }
             await callback(responseContent);
           } else {
-            await runtime.processActions(message, responseMessages, state, callback);
+            await runtime.processActions(message, responseMessages, state, async (content) => {
+              runtime.logger.debug("action callback", content);
+              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("evaluate callback", content);
+              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 +7374,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 +7382,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 +7437,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 +7473,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("[Bootstrap] Error in reaction handler:", error);
   }
 };
 var messageDeletedHandler = async ({
@@ -7333,14 +7485,19 @@ 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("[Bootstrap] Successfully deleted memory for message", message.id);
   } catch (error) {
-    logger20.error("[Bootstrap] Error in message deleted handler:", error);
+    runtime.logger.error("[Bootstrap] Error in message deleted handler:", error);
   }
 };
 var channelClearedHandler = async ({
@@ -7350,7 +7507,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 +7521,15 @@ 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(`[Bootstrap] Failed to delete message memory ${memory.id}:`, error);
         }
       }
     }
-    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("[Bootstrap] Error in channel cleared handler:", error);
   }
 };
 var postGeneratedHandler = async ({
@@ -7383,7 +7540,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 +7604,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 +7622,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 +7639,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("[Bootstrap] Already recently posted that, retrying", cleanedText);
         postGeneratedHandler({
           runtime,
           callback,
@@ -7500,7 +7657,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("[Bootstrap] Got prompt moderation refusal, retrying", cleanedText);
     postGeneratedHandler({
       runtime,
       callback,
@@ -7534,9 +7691,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 +7708,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 +7724,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 +7745,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 +7761,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 +7779,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 +7814,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 +7840,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 +7873,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 +7910,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}`);
       }
     }
   ],