@elizaos/plugin-bootstrap 1.0.4 → 1.0.6

package/dist/index.js

@@ -72,19 +72,19 @@ var require_dedent = __commonJS({
 // src/index.ts
 import {
   asUUID,
-  ChannelType as ChannelType10,
+  ChannelType as ChannelType9,
   composePromptFromState as composePromptFromState9,
-  createUniqueUuid as createUniqueUuid4,
-  EventType as EventType2,
-  logger as logger19,
+  ContentType,
+  createUniqueUuid as createUniqueUuid3,
+  EventType,
+  imageDescriptionTemplate,
+  logger as logger18,
   messageHandlerTemplate,
   ModelType as ModelType13,
+  parseKeyValueXml,
   postCreationTemplate,
   shouldRespondTemplate,
-  truncateToCompleteSentence,
-  parseKeyValueXml,
-  imageDescriptionTemplate,
-  ContentType
+  truncateToCompleteSentence
 } from "@elizaos/core";
 
 // ../../node_modules/uuid/dist/esm/stringify.js
@@ -180,10 +180,6 @@ var choiceAction = {
       logger.error("State is required for validating the action");
       throw new Error("State is required for validating the action");
     }
-    const pendingTasks = await runtime.getTasks({
-      roomId: message.roomId,
-      tags: ["AWAITING_CHOICE"]
-    });
     const room = state.data.room ?? await runtime.getRoom(message.roomId);
     if (!room || !room.serverId) {
       return false;
@@ -192,7 +188,21 @@ var choiceAction = {
     if (userRole !== "OWNER" && userRole !== "ADMIN") {
       return false;
     }
-    return pendingTasks && pendingTasks.length > 0 && pendingTasks.some((task) => task.metadata?.options);
+    try {
+      const pendingTasks = await runtime.getTasks({
+        roomId: message.roomId,
+        tags: ["AWAITING_CHOICE"]
+      });
+      const room2 = state.data.room ?? await runtime.getRoom(message.roomId);
+      const userRole2 = await getUserServerRole(runtime, message.entityId, room2.serverId);
+      if (userRole2 !== "OWNER" && userRole2 !== "ADMIN") {
+        return false;
+      }
+      return pendingTasks && pendingTasks.length > 0 && pendingTasks.some((task) => task.metadata?.options);
+    } catch (error) {
+      logger.error("Error validating choice action:", error);
+      return false;
+    }
   },
   handler: async (runtime, message, state, _options, callback, responses) => {
     const pendingTasks = await runtime.getTasks({
@@ -4907,8 +4917,9 @@ var settingsProvider = {
           world = await runtime.getWorld(room.worldId);
           if (!world) {
             logger15.error(`No world found for room ${room.worldId}`);
+            throw new Error(`No world found for room ${room.worldId}`);
           }
-          serverId = world?.serverId;
+          serverId = world.serverId;
           if (serverId) {
             worldSettings = await getWorldSettings2(runtime, serverId);
           } else {
@@ -4916,6 +4927,7 @@ var settingsProvider = {
           }
         } catch (error) {
           logger15.error(`Error processing world data: ${error}`);
+          throw new Error("Failed to process world information");
         }
       }
       if (!serverId) {
@@ -5169,254 +5181,13 @@ var worldProvider = {
   }
 };
 
-// src/services/scenario.ts
-import {
-  ChannelType as ChannelType9,
-  EventType,
-  Service,
-  createUniqueUuid as createUniqueUuid3,
-  logger as logger17
-} from "@elizaos/core";
-var ScenarioService = class _ScenarioService extends Service {
-  /**
-   * Constructor for creating a new instance of the class.
-   *
-   * @param runtime - The IAgentRuntime instance to be passed to the constructor.
-   */
-  constructor(runtime) {
-    super(runtime);
-    this.runtime = runtime;
-    this.setupEventListeners();
-  }
-  static serviceType = "scenario";
-  capabilityDescription = "The agent is currently in a scenario testing environment. It can Create groups, send messages, and talk to other agents in a live interactive testing environment.";
-  messageHandlers = /* @__PURE__ */ new Map();
-  worlds = /* @__PURE__ */ new Map();
-  activeActions = /* @__PURE__ */ new Map();
-  activeEvaluators = /* @__PURE__ */ new Map();
-  setupEventListeners() {
-    this.runtime.registerEvent(EventType.ACTION_STARTED, async (data) => {
-      this.activeActions.set(data.actionId, {
-        actionId: data.actionId,
-        actionName: data.actionName,
-        startTime: Date.now(),
-        completed: false
-      });
-      return Promise.resolve();
-    });
-    this.runtime.registerEvent(EventType.ACTION_COMPLETED, async (data) => {
-      const action = this.activeActions.get(data.actionId);
-      if (action) {
-        action.completed = true;
-        action.error = data.error;
-      }
-      return Promise.resolve();
-    });
-    this.runtime.registerEvent(EventType.EVALUATOR_STARTED, async (data) => {
-      this.activeEvaluators.set(data.evaluatorId, {
-        evaluatorId: data.evaluatorId,
-        evaluatorName: data.evaluatorName,
-        startTime: Date.now(),
-        completed: false
-      });
-      logger17.debug("[Bootstrap] Evaluator started", data);
-      return Promise.resolve();
-    });
-    this.runtime.registerEvent(
-      EventType.EVALUATOR_COMPLETED,
-      async (data) => {
-        const evaluator = this.activeEvaluators.get(data.evaluatorId);
-        if (evaluator) {
-          evaluator.completed = true;
-          evaluator.error = data.error;
-        }
-        logger17.debug("[Bootstrap] Evaluator completed", data);
-        return Promise.resolve();
-      }
-    );
-  }
-  /**
-   * Start the scenario service with the given runtime.
-   * @param {IAgentRuntime} runtime - The agent runtime
-   * @returns {Promise<ScenarioService>} - The started scenario service
-   */
-  static async start(runtime) {
-    const service = new _ScenarioService(runtime);
-    return service;
-  }
-  /**
-   * Stops the Scenario service associated with the given runtime.
-   *
-   * @param {IAgentRuntime} runtime The runtime to stop the service for.
-   * @throws {Error} When the Scenario service is not found.
-   */
-  static async stop(runtime) {
-    const service = runtime.getService(_ScenarioService.serviceType);
-    if (!service) {
-      throw new Error("Scenario service not found");
-    }
-    service.stop();
-  }
-  /**
-   * Asynchronously stops the current process by clearing all message handlers and worlds.
-   */
-  async stop() {
-    this.messageHandlers.clear();
-    this.worlds.clear();
-    this.activeActions.clear();
-    this.activeEvaluators.clear();
-  }
-  /**
-   * Creates a new world with the specified name and owner.
-   * @param name The name of the world
-   * @param ownerName The name of the world owner
-   * @returns The created world's ID
-   */
-  async createWorld(name, ownerName) {
-    const serverId = createUniqueUuid3(this.runtime.agentId, name);
-    const worldId = v4_default();
-    const ownerId = v4_default();
-    const world = {
-      id: worldId,
-      name,
-      serverId,
-      agentId: this.runtime.agentId,
-      // TODO: get the server id, create it or whatever
-      metadata: {
-        // this is wrong, the owner needs to be tracked by scenario and similar to how we do it with Discord etc
-        owner: {
-          id: ownerId,
-          name: ownerName
-        }
-      }
-    };
-    this.worlds.set(worldId, world);
-    return worldId;
-  }
-  /**
-   * Creates a room in the specified world.
-   * @param worldId The ID of the world to create the room in
-   * @param name The name of the room
-   * @returns The created room's ID
-   */
-  async createRoom(worldId, name) {
-    const world = this.worlds.get(worldId);
-    if (!world) {
-      throw new Error(`World ${worldId} not found`);
-    }
-    const roomId = v4_default();
-    await this.runtime.ensureRoomExists({
-      id: roomId,
-      name,
-      source: "scenario",
-      type: ChannelType9.GROUP,
-      channelId: roomId,
-      serverId: worldId,
-      worldId
-    });
-    return roomId;
-  }
-  /**
-   * Adds a participant to a room
-   * @param worldId The world ID
-   * @param roomId The room ID
-   * @param participantId The participant's ID
-   */
-  async addParticipant(worldId, roomId, participantId) {
-    const world = this.worlds.get(worldId);
-    if (!world) {
-      throw new Error(`World ${worldId} not found`);
-    }
-    const room = this.runtime.getRoom(roomId);
-    if (!room) {
-      throw new Error(`Room ${roomId} not found in world ${worldId}`);
-    }
-    await this.runtime.addParticipant(roomId, participantId);
-  }
-  /**
-   * Sends a message in a specific room
-   * @param sender The runtime of the sending agent
-   * @param worldId The world ID
-   * @param roomId The room ID
-   * @param text The message text
-   */
-  async sendMessage(sender, worldId, roomId, text) {
-    const world = this.worlds.get(worldId);
-    if (!world) {
-      throw new Error(`World ${worldId} not found`);
-    }
-    const memory = {
-      entityId: sender.agentId,
-      agentId: sender.agentId,
-      roomId,
-      content: {
-        text,
-        source: "scenario",
-        name: sender.character.name,
-        userName: sender.character.name,
-        channelType: ChannelType9.GROUP
-      }
-    };
-    const participants = await this.runtime.getParticipantsForRoom(roomId);
-    for (const participantId of participants) {
-      this.runtime.emitEvent("MESSAGE_RECEIVED", {
-        runtime: this.runtime,
-        message: memory,
-        roomId,
-        entityId: participantId,
-        source: "scenario",
-        type: ChannelType9.GROUP
-      });
-    }
-  }
-  /**
-   * Waits for all active actions and evaluators to complete
-   * @param timeout Maximum time to wait in milliseconds
-   * @returns True if all completed successfully, false if timeout occurred
-   */
-  async waitForCompletion(timeout = 3e4) {
-    const startTime = Date.now();
-    while (Date.now() - startTime < timeout) {
-      const allActionsComplete = Array.from(this.activeActions.values()).every(
-        (action) => action.completed
-      );
-      const allEvaluatorsComplete = Array.from(this.activeEvaluators.values()).every(
-        (evaluator) => evaluator.completed
-      );
-      if (allActionsComplete && allEvaluatorsComplete) {
-        return true;
-      }
-      await new Promise((resolve) => setTimeout(resolve, 100));
-    }
-    return false;
-  }
-  /**
-   * Gets the current state of all active actions and evaluators
-   */
-  getActiveState() {
-    return {
-      actions: Array.from(this.activeActions.values()),
-      evaluators: Array.from(this.activeEvaluators.values())
-    };
-  }
-  /**
-   * Cleans up the scenario state
-   */
-  async cleanup() {
-    this.worlds.clear();
-    this.activeActions.clear();
-    this.activeEvaluators.clear();
-    this.messageHandlers.clear();
-  }
-};
-
 // src/services/task.ts
 import {
-  logger as logger18,
-  Service as Service2,
+  logger as logger17,
+  Service,
   ServiceType
 } from "@elizaos/core";
-var TaskService = class _TaskService extends Service2 {
+var TaskService = class _TaskService extends Service {
   timer = null;
   TICK_INTERVAL = 1e3;
   // Check every second
@@ -5425,7 +5196,7 @@ var TaskService = class _TaskService extends Service2 {
   /**
    * Start the TaskService with the given runtime.
    * @param {IAgentRuntime} runtime - The runtime for the TaskService.
-   * @returns {Promise<TaskService>} A promise that resolves with the TaskService instance.
+   * @returns {Promise<Service>} A promise that resolves with the TaskService instance.
    */
   static async start(runtime) {
     const service = new _TaskService(runtime);
@@ -5440,21 +5211,21 @@ var TaskService = class _TaskService extends Service2 {
     this.runtime.registerTaskWorker({
       name: "REPEATING_TEST_TASK",
       validate: async (_runtime, _message, _state) => {
-        logger18.debug("[Bootstrap] Validating repeating test task");
+        logger17.debug("[Bootstrap] Validating repeating test task");
         return true;
       },
       execute: async (_runtime, _options) => {
-        logger18.debug("[Bootstrap] Executing repeating test task");
+        logger17.debug("[Bootstrap] Executing repeating test task");
       }
     });
     this.runtime.registerTaskWorker({
       name: "ONETIME_TEST_TASK",
       validate: async (_runtime, _message, _state) => {
-        logger18.debug("[Bootstrap] Validating one-time test task");
+        logger17.debug("[Bootstrap] Validating one-time test task");
         return true;
       },
       execute: async (_runtime, _options) => {
-        logger18.debug("[Bootstrap] Executing one-time test task");
+        logger17.debug("[Bootstrap] Executing one-time test task");
       }
     });
     const tasks = await this.runtime.getTasksByName("REPEATING_TEST_TASK");
@@ -5491,7 +5262,7 @@ var TaskService = class _TaskService extends Service2 {
       try {
         await this.checkTasks();
       } catch (error) {
-        logger18.error("[Bootstrap] Error checking tasks:", error);
+        logger17.error("[Bootstrap] Error checking tasks:", error);
       }
     }, this.TICK_INTERVAL);
   }
@@ -5520,7 +5291,7 @@ var TaskService = class _TaskService extends Service2 {
             continue;
           }
         } catch (error) {
-          logger18.error(`[Bootstrap] Error validating task ${task.name}:`, error);
+          logger17.error(`[Bootstrap] Error validating task ${task.name}:`, error);
           continue;
         }
       }
@@ -5562,20 +5333,20 @@ var TaskService = class _TaskService extends Service2 {
         }
         if (task.metadata?.updatedAt === task.metadata?.createdAt) {
           if (task.tags?.includes("immediate")) {
-            logger18.debug("[Bootstrap] Immediately running task", task.name);
+            logger17.debug("[Bootstrap] Immediately running task", task.name);
             await this.executeTask(task);
             continue;
           }
         }
         if (now - taskStartTime >= updateIntervalMs) {
-          logger18.debug(
+          logger17.debug(
             `[Bootstrap] Executing task ${task.name} - interval of ${updateIntervalMs}ms has elapsed`
           );
           await this.executeTask(task);
         }
       }
     } catch (error) {
-      logger18.error("[Bootstrap] Error checking tasks:", error);
+      logger17.error("[Bootstrap] Error checking tasks:", error);
     }
   }
   /**
@@ -5586,12 +5357,12 @@ var TaskService = class _TaskService extends Service2 {
   async executeTask(task) {
     try {
       if (!task || !task.id) {
-        logger18.debug(`[Bootstrap] Task not found`);
+        logger17.debug(`[Bootstrap] Task not found`);
         return;
       }
       const worker = this.runtime.getTaskWorker(task.name);
       if (!worker) {
-        logger18.debug(`[Bootstrap] No worker found for task type: ${task.name}`);
+        logger17.debug(`[Bootstrap] No worker found for task type: ${task.name}`);
         return;
       }
       if (task.tags?.includes("repeat")) {
@@ -5601,20 +5372,20 @@ var TaskService = class _TaskService extends Service2 {
             updatedAt: Date.now()
           }
         });
-        logger18.debug(
+        logger17.debug(
           `[Bootstrap] Updated repeating task ${task.name} (${task.id}) with new timestamp`
         );
       }
-      logger18.debug(`[Bootstrap] Executing task ${task.name} (${task.id})`);
+      logger17.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);
-        logger18.debug(
+        logger17.debug(
           `[Bootstrap] Deleted non-repeating task ${task.name} (${task.id}) after execution`
         );
       }
     } catch (error) {
-      logger18.error(`[Bootstrap] Error executing task ${task.id}:`, error);
+      logger17.error(`[Bootstrap] Error executing task ${task.id}:`, error);
     }
   }
   /**
@@ -5662,13 +5433,13 @@ async function processAttachments(attachments, runtime) {
   if (!attachments || attachments.length === 0) {
     return [];
   }
-  logger19.debug(`[Bootstrap] Processing ${attachments.length} attachment(s)`);
+  logger18.debug(`[Bootstrap] Processing ${attachments.length} attachment(s)`);
   const processedAttachments = [];
   for (const attachment of attachments) {
     try {
       const processedAttachment = { ...attachment };
       if (attachment.contentType === ContentType.IMAGE && !attachment.description) {
-        logger19.debug(`[Bootstrap] Generating description for image: ${attachment.url}`);
+        logger18.debug(`[Bootstrap] Generating description for image: ${attachment.url}`);
         try {
           const response = await runtime.useModel(ModelType13.IMAGE_DESCRIPTION, {
             prompt: imageDescriptionTemplate,
@@ -5680,29 +5451,29 @@ async function processAttachments(attachments, runtime) {
               processedAttachment.description = parsedXml.description;
               processedAttachment.title = parsedXml.title || "Image";
               processedAttachment.text = parsedXml.text;
-              logger19.debug(
+              logger18.debug(
                 `[Bootstrap] Generated description: ${processedAttachment.description?.substring(0, 100)}...`
               );
             } else {
-              logger19.warn(`[Bootstrap] Failed to parse XML response for image description`);
+              logger18.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;
-            logger19.debug(
+            logger18.debug(
               `[Bootstrap] Generated description: ${processedAttachment.description?.substring(0, 100)}...`
             );
           } else {
-            logger19.warn(`[Bootstrap] Unexpected response format for image description`);
+            logger18.warn(`[Bootstrap] Unexpected response format for image description`);
           }
         } catch (error) {
-          logger19.error(`[Bootstrap] Error generating image description:`, error);
+          logger18.error(`[Bootstrap] Error generating image description:`, error);
         }
       }
       processedAttachments.push(processedAttachment);
     } catch (error) {
-      logger19.error(`[Bootstrap] Failed to process attachment ${attachment.url}:`, error);
+      logger18.error(`[Bootstrap] Failed to process attachment ${attachment.url}:`, error);
       processedAttachments.push(attachment);
     }
   }
@@ -5716,10 +5487,10 @@ function shouldBypassShouldRespond(runtime, room, source) {
     return cleaned.split(",").map((v) => v.trim()).filter(Boolean);
   }
   const defaultBypassTypes = [
-    ChannelType10.DM,
-    ChannelType10.VOICE_DM,
-    ChannelType10.SELF,
-    ChannelType10.API
+    ChannelType9.DM,
+    ChannelType9.VOICE_DM,
+    ChannelType9.SELF,
+    ChannelType9.API
   ];
   const defaultBypassSources = ["client_chat"];
   const bypassTypesSetting = normalizeEnvList(runtime.getSetting("SHOULD_RESPOND_BYPASS_TYPES"));
@@ -5747,7 +5518,7 @@ var messageReceivedHandler = async ({
   const timeoutDuration = 60 * 60 * 1e3;
   let timeoutId = void 0;
   try {
-    logger19.info(`[Bootstrap] Message received from ${message.entityId} in room ${message.roomId}`);
+    logger18.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());
@@ -5759,7 +5530,7 @@ var messageReceivedHandler = async ({
     agentResponses.set(message.roomId, responseId);
     const runId = asUUID(v4_default());
     const startTime = Date.now();
-    await runtime.emitEvent(EventType2.RUN_STARTED, {
+    await runtime.emitEvent(EventType.RUN_STARTED, {
       runtime,
       runId,
       messageId: message.id,
@@ -5771,7 +5542,7 @@ var messageReceivedHandler = async ({
     });
     const timeoutPromise = new Promise((_, reject) => {
       timeoutId = setTimeout(async () => {
-        await runtime.emitEvent(EventType2.RUN_TIMEOUT, {
+        await runtime.emitEvent(EventType.RUN_TIMEOUT, {
           runtime,
           runId,
           messageId: message.id,
@@ -5790,13 +5561,13 @@ var messageReceivedHandler = async ({
     const processingPromise = (async () => {
       try {
         if (message.entityId === runtime.agentId) {
-          logger19.debug(`[Bootstrap] Skipping message from self (${runtime.agentId})`);
+          logger18.debug(`[Bootstrap] Skipping message from self (${runtime.agentId})`);
           throw new Error("Message is from the agent itself");
         }
-        logger19.debug(
+        logger18.debug(
           `[Bootstrap] Processing message: ${truncateToCompleteSentence(message.content.text || "", 50)}...`
         );
-        logger19.debug("[Bootstrap] Saving message to memory and embeddings");
+        logger18.debug("[Bootstrap] Saving message to memory and embeddings");
         await Promise.all([
           runtime.addEmbeddingToMemory(message),
           runtime.createMemory(message, "messages")
@@ -5806,7 +5577,7 @@ var messageReceivedHandler = async ({
           runtime.agentId
         );
         if (agentUserState === "MUTED" && !message.content.text?.toLowerCase().includes(runtime.character.name.toLowerCase())) {
-          logger19.debug(`[Bootstrap] Ignoring muted room ${message.roomId}`);
+          logger18.debug(`[Bootstrap] Ignoring muted room ${message.roomId}`);
           return;
         }
         let state = await runtime.composeState(
@@ -5832,23 +5603,24 @@ var messageReceivedHandler = async ({
             state,
             template: runtime.character.templates?.shouldRespondTemplate || shouldRespondTemplate
           });
-          logger19.debug(
+          logger18.debug(
             `[Bootstrap] Evaluating response for ${runtime.character.name}
 Prompt: ${shouldRespondPrompt}`
           );
           const response = await runtime.useModel(ModelType13.TEXT_SMALL, {
             prompt: shouldRespondPrompt
           });
-          logger19.debug(
+          logger18.debug(
             `[Bootstrap] Response evaluation for ${runtime.character.name}:
 ${response}`
           );
-          logger19.debug(`[Bootstrap] Response type: ${typeof response}`);
+          logger18.debug(`[Bootstrap] Response type: ${typeof response}`);
           const responseObject = parseKeyValueXml(response);
-          logger19.debug("[Bootstrap] Parsed response:", responseObject);
-          shouldRespond = responseObject?.action && responseObject.action === "RESPOND";
+          logger18.debug("[Bootstrap] Parsed response:", responseObject);
+          const nonResponseActions = ["IGNORE", "NONE"];
+          shouldRespond = responseObject?.action && !nonResponseActions.includes(responseObject.action.toUpperCase());
         } else {
-          logger19.debug(
+          logger18.debug(
             `[Bootstrap] Skipping shouldRespond check for ${runtime.character.name} because ${room?.type} ${room?.source}`
           );
           shouldRespond = true;
@@ -5859,7 +5631,7 @@ ${response}`
         if (shouldRespond) {
           state = await runtime.composeState(message, ["ACTIONS"]);
           if (!state.values.actionNames) {
-            logger19.warn("actionNames data missing from state, even though it was requested");
+            logger18.warn("actionNames data missing from state, even though it was requested");
           }
           const prompt = composePromptFromState9({
             state,
@@ -5872,9 +5644,9 @@ ${response}`
             let response = await runtime.useModel(ModelType13.TEXT_LARGE, {
               prompt
             });
-            logger19.debug("[Bootstrap] *** Raw LLM Response ***\n", response);
+            logger18.debug("[Bootstrap] *** Raw LLM Response ***\n", response);
             const parsedXml = parseKeyValueXml(response);
-            logger19.debug("[Bootstrap] *** Parsed XML Content ***\n", parsedXml);
+            logger18.debug("[Bootstrap] *** Parsed XML Content ***\n", parsedXml);
             if (parsedXml) {
               responseContent = {
                 ...parsedXml,
@@ -5889,7 +5661,7 @@ ${response}`
             }
             retries++;
             if (!responseContent?.thought || !responseContent?.actions) {
-              logger19.warn(
+              logger18.warn(
                 "[Bootstrap] *** Missing required fields (thought or actions), retrying... ***\n",
                 response,
                 parsedXml,
@@ -5899,13 +5671,13 @@ ${response}`
           }
           const currentResponseId = agentResponses.get(message.roomId);
           if (currentResponseId !== responseId) {
-            logger19.info(
+            logger18.info(
               `Response discarded - newer message being processed for agent: ${runtime.agentId}, room: ${message.roomId}`
             );
             return;
           }
           if (responseContent && message.id) {
-            responseContent.inReplyTo = createUniqueUuid4(runtime, message.id);
+            responseContent.inReplyTo = createUniqueUuid3(runtime, message.id);
             const isSimple = responseContent.actions?.length === 1 && responseContent.actions[0].toUpperCase() === "REPLY" && (!responseContent.providers || responseContent.providers.length === 0);
             responseContent.simple = isSimple;
             const responseMesssage = {
@@ -5927,7 +5699,7 @@ ${response}`
           }
           if (responseContent && responseContent.simple && responseContent.text) {
             if (responseContent.providers && responseContent.providers.length > 0) {
-              logger19.debug("[Bootstrap] Simple response used providers", responseContent.providers);
+              logger18.debug("[Bootstrap] Simple response used providers", responseContent.providers);
             }
             await callback(responseContent);
           } else {
@@ -5942,7 +5714,7 @@ ${response}`
             if (responseMessages.length) {
               for (const responseMessage of responseMessages) {
                 if (responseMessage.content.providers && responseMessage.content.providers.length > 0) {
-                  logger19.debug(
+                  logger18.debug(
                     "[Bootstrap] Complex response used providers",
                     responseMessage.content.providers
                   );
@@ -5963,16 +5735,16 @@ ${response}`
             responseMessages
           );
         } else {
-          logger19.debug("[Bootstrap] Agent decided not to respond (shouldRespond is false).");
+          logger18.debug("[Bootstrap] Agent decided not to respond (shouldRespond is false).");
           const currentResponseId = agentResponses.get(message.roomId);
           if (currentResponseId !== responseId) {
-            logger19.info(
+            logger18.info(
               `Ignore response discarded - newer message being processed for agent: ${runtime.agentId}, room: ${message.roomId}`
             );
             return;
           }
           if (!message.id) {
-            logger19.error("[Bootstrap] Message ID is missing, cannot create ignore response.");
+            logger18.error("[Bootstrap] Message ID is missing, cannot create ignore response.");
             return;
           }
           const ignoreContent = {
@@ -5980,7 +5752,7 @@ ${response}`
             actions: ["IGNORE"],
             simple: true,
             // Treat it as simple for callback purposes
-            inReplyTo: createUniqueUuid4(runtime, message.id)
+            inReplyTo: createUniqueUuid3(runtime, message.id)
             // Reference original message
           };
           await callback(ignoreContent);
@@ -5993,7 +5765,7 @@ ${response}`
             createdAt: Date.now()
           };
           await runtime.createMemory(ignoreMemory, "messages");
-          logger19.debug("[Bootstrap] Saved ignore response to memory", {
+          logger18.debug("[Bootstrap] Saved ignore response to memory", {
             memoryId: ignoreMemory.id
           });
           agentResponses.delete(message.roomId);
@@ -6001,7 +5773,7 @@ ${response}`
             latestResponseIds.delete(runtime.agentId);
           }
         }
-        await runtime.emitEvent(EventType2.RUN_ENDED, {
+        await runtime.emitEvent(EventType.RUN_ENDED, {
           runtime,
           runId,
           messageId: message.id,
@@ -6015,7 +5787,7 @@ ${response}`
         });
       } catch (error) {
         console.error("error is", error);
-        await runtime.emitEvent(EventType2.RUN_ENDED, {
+        await runtime.emitEvent(EventType.RUN_ENDED, {
           runtime,
           runId,
           messageId: message.id,
@@ -6044,10 +5816,10 @@ var reactionReceivedHandler = async ({
     await runtime.createMemory(message, "messages");
   } catch (error) {
     if (error.code === "23505") {
-      logger19.warn("[Bootstrap] Duplicate reaction memory, skipping");
+      logger18.warn("[Bootstrap] Duplicate reaction memory, skipping");
       return;
     }
-    logger19.error("[Bootstrap] Error in reaction handler:", error);
+    logger18.error("[Bootstrap] Error in reaction handler:", error);
   }
 };
 var postGeneratedHandler = async ({
@@ -6058,7 +5830,7 @@ var postGeneratedHandler = async ({
   roomId,
   source
 }) => {
-  logger19.info("[Bootstrap] Generating new post...");
+  logger18.info("[Bootstrap] Generating new post...");
   await runtime.ensureWorldExists({
     id: worldId,
     name: `${runtime.character.name}'s Feed`,
@@ -6069,13 +5841,13 @@ var postGeneratedHandler = async ({
     id: roomId,
     name: `${runtime.character.name}'s Feed`,
     source,
-    type: ChannelType10.FEED,
+    type: ChannelType9.FEED,
     channelId: `${userId}-home`,
     serverId: userId,
     worldId
   });
   const message = {
-    id: createUniqueUuid4(runtime, `tweet-${Date.now()}`),
+    id: createUniqueUuid3(runtime, `tweet-${Date.now()}`),
     entityId: runtime.agentId,
     agentId: runtime.agentId,
     roomId,
@@ -6122,7 +5894,7 @@ var postGeneratedHandler = async ({
     }
     retries++;
     if (!responseContent?.thought || !responseContent?.actions) {
-      logger19.warn(
+      logger18.warn(
         "[Bootstrap] *** Missing required fields, retrying... ***\n",
         response,
         parsedXml,
@@ -6140,7 +5912,7 @@ var postGeneratedHandler = async ({
   });
   const parsedXmlResponse = parseKeyValueXml(xmlResponseText);
   if (!parsedXmlResponse) {
-    logger19.error(
+    logger18.error(
       "[Bootstrap] Failed to parse XML response for post creation. Raw response:",
       xmlResponseText
     );
@@ -6160,7 +5932,7 @@ var postGeneratedHandler = async ({
   if (RM) {
     for (const m of RM.data.recentMessages) {
       if (cleanedText === m.content.text) {
-        logger19.log("[Bootstrap] Already recently posted that, retrying", cleanedText);
+        logger18.log("[Bootstrap] Already recently posted that, retrying", cleanedText);
         postGeneratedHandler({
           runtime,
           callback,
@@ -6178,7 +5950,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)) {
-    logger19.log("[Bootstrap] Got prompt moderation refusal, retrying", cleanedText);
+    logger18.log("[Bootstrap] Got prompt moderation refusal, retrying", cleanedText);
     postGeneratedHandler({
       runtime,
       callback,
@@ -6197,7 +5969,7 @@ var postGeneratedHandler = async ({
       content: {
         text: cleanedText,
         source,
-        channelType: ChannelType10.FEED,
+        channelType: ChannelType9.FEED,
         thought: parsedXmlResponse.thought || "",
         type: "post"
       },
@@ -6212,13 +5984,13 @@ var postGeneratedHandler = async ({
 var syncSingleUser = async (entityId, runtime, serverId, channelId, type, source) => {
   try {
     const entity = await runtime.getEntityById(entityId);
-    logger19.info(`[Bootstrap] Syncing user: ${entity?.metadata?.[source]?.username || entityId}`);
+    logger18.info(`[Bootstrap] Syncing user: ${entity?.metadata?.[source]?.username || entityId}`);
     if (!channelId) {
-      logger19.warn(`[Bootstrap] Cannot sync user ${entity?.id} without a valid channelId`);
+      logger18.warn(`[Bootstrap] Cannot sync user ${entity?.id} without a valid channelId`);
       return;
     }
-    const roomId = createUniqueUuid4(runtime, channelId);
-    const worldId = createUniqueUuid4(runtime, serverId);
+    const roomId = createUniqueUuid3(runtime, channelId);
+    const worldId = createUniqueUuid3(runtime, serverId);
     await runtime.ensureConnection({
       entityId,
       roomId,
@@ -6230,9 +6002,9 @@ var syncSingleUser = async (entityId, runtime, serverId, channelId, type, source
       type,
       worldId
     });
-    logger19.success(`[Bootstrap] Successfully synced user: ${entity?.id}`);
+    logger18.success(`[Bootstrap] Successfully synced user: ${entity?.id}`);
   } catch (error) {
-    logger19.error(
+    logger18.error(
       `[Bootstrap] Error syncing user: ${error instanceof Error ? error.message : String(error)}`
     );
   }
@@ -6245,71 +6017,13 @@ var handleServerSync = async ({
   source,
   onComplete
 }) => {
-  logger19.debug(`[Bootstrap] Handling server sync event for server: ${world.name}`);
+  logger18.debug(`[Bootstrap] Handling server sync event for server: ${world.name}`);
   try {
-    await runtime.ensureWorldExists({
-      id: world.id,
-      name: world.name,
-      agentId: runtime.agentId,
-      serverId: world.serverId,
-      metadata: {
-        ...world.metadata
-      }
-    });
-    if (rooms && rooms.length > 0) {
-      for (const room of rooms) {
-        await runtime.ensureRoomExists({
-          id: room.id,
-          name: room.name,
-          source,
-          type: room.type,
-          channelId: room.channelId,
-          serverId: world.serverId,
-          worldId: world.id
-        });
-      }
-    }
-    if (entities && entities.length > 0) {
-      const batchSize = 50;
-      for (let i2 = 0; i2 < entities.length; i2 += batchSize) {
-        const entityBatch = entities.slice(i2, i2 + batchSize);
-        const firstRoomUserIsIn = rooms.length > 0 ? rooms[0] : null;
-        if (!firstRoomUserIsIn) {
-          logger19.warn(`[Bootstrap] No rooms found for syncing users`);
-          continue;
-        }
-        await Promise.all(
-          entityBatch.map(async (entity) => {
-            try {
-              if (!entity?.id) {
-                logger19.warn(`[Bootstrap] No entity ID found for syncing users`);
-                return;
-              }
-              await runtime.ensureConnection({
-                entityId: entity.id,
-                roomId: firstRoomUserIsIn.id,
-                userName: entity.metadata?.[source].username,
-                name: entity.metadata?.[source].name,
-                source,
-                channelId: firstRoomUserIsIn.channelId,
-                serverId: world.serverId,
-                type: firstRoomUserIsIn.type,
-                worldId: world.id
-              });
-            } catch (err) {
-              logger19.warn(`[Bootstrap] Failed to sync user ${entity.metadata?.username}: ${err}`);
-            }
-          })
-        );
-        if (i2 + batchSize < entities.length) {
-          await new Promise((resolve) => setTimeout(resolve, 500));
-        }
-      }
-    }
-    logger19.debug(`Successfully synced standardized world structure for ${world.name}`);
+    await runtime.ensureConnections(entities, rooms, source, world);
+    logger18.debug(`Successfully synced standardized world structure for ${world.name}`);
     onComplete?.();
   } catch (error) {
-    logger19.error(
+    logger18.error(
       `Error processing standardized server data: ${error instanceof Error ? error.message : String(error)}`
     );
   }
@@ -6320,7 +6034,7 @@ var controlMessageHandler = async ({
   source
 }) => {
   try {
-    logger19.debug(
+    logger18.debug(
       `[controlMessageHandler] Processing control message: ${message.payload.action} for room ${message.roomId}`
     );
     const serviceNames = Array.from(runtime.getAllServices().keys());
@@ -6338,24 +6052,24 @@ var controlMessageHandler = async ({
             roomId: message.roomId
           }
         });
-        logger19.debug(
+        logger18.debug(
           `[controlMessageHandler] Control message ${message.payload.action} sent successfully`
         );
       } else {
-        logger19.error("[controlMessageHandler] WebSocket service does not have sendMessage method");
+        logger18.error("[controlMessageHandler] WebSocket service does not have sendMessage method");
       }
     } else {
-      logger19.error("[controlMessageHandler] No WebSocket service found to send control message");
+      logger18.error("[controlMessageHandler] No WebSocket service found to send control message");
     }
   } catch (error) {
-    logger19.error(`[controlMessageHandler] Error processing control message: ${error}`);
+    logger18.error(`[controlMessageHandler] Error processing control message: ${error}`);
   }
 };
 var events = {
-  [EventType2.MESSAGE_RECEIVED]: [
+  [EventType.MESSAGE_RECEIVED]: [
     async (payload) => {
       if (!payload.callback) {
-        logger19.error("No callback provided for message");
+        logger18.error("No callback provided for message");
         return;
       }
       await messageReceivedHandler({
@@ -6366,10 +6080,10 @@ var events = {
       });
     }
   ],
-  [EventType2.VOICE_MESSAGE_RECEIVED]: [
+  [EventType.VOICE_MESSAGE_RECEIVED]: [
     async (payload) => {
       if (!payload.callback) {
-        logger19.error("No callback provided for voice message");
+        logger18.error("No callback provided for voice message");
         return;
       }
       await messageReceivedHandler({
@@ -6380,7 +6094,7 @@ var events = {
       });
     }
   ],
-  [EventType2.REACTION_RECEIVED]: [
+  [EventType.REACTION_RECEIVED]: [
     async (payload) => {
       await reactionReceivedHandler({
         runtime: payload.runtime,
@@ -6388,38 +6102,38 @@ var events = {
       });
     }
   ],
-  [EventType2.POST_GENERATED]: [
+  [EventType.POST_GENERATED]: [
     async (payload) => {
       await postGeneratedHandler(payload);
     }
   ],
-  [EventType2.MESSAGE_SENT]: [
+  [EventType.MESSAGE_SENT]: [
     async (payload) => {
-      logger19.debug(`[Bootstrap] Message sent: ${payload.message.content.text}`);
+      logger18.debug(`[Bootstrap] Message sent: ${payload.message.content.text}`);
     }
   ],
-  [EventType2.WORLD_JOINED]: [
+  [EventType.WORLD_JOINED]: [
     async (payload) => {
       await handleServerSync(payload);
     }
   ],
-  [EventType2.WORLD_CONNECTED]: [
+  [EventType.WORLD_CONNECTED]: [
     async (payload) => {
       await handleServerSync(payload);
     }
   ],
-  [EventType2.ENTITY_JOINED]: [
+  [EventType.ENTITY_JOINED]: [
     async (payload) => {
       if (!payload.worldId) {
-        logger19.error("[Bootstrap] No callback provided for entity joined");
+        logger18.error("[Bootstrap] No callback provided for entity joined");
         return;
       }
       if (!payload.roomId) {
-        logger19.error("[Bootstrap] No roomId provided for entity joined");
+        logger18.error("[Bootstrap] No roomId provided for entity joined");
         return;
       }
       if (!payload.metadata?.type) {
-        logger19.error("[Bootstrap] No type provided for entity joined");
+        logger18.error("[Bootstrap] No type provided for entity joined");
         return;
       }
       await syncSingleUser(
@@ -6432,7 +6146,7 @@ var events = {
       );
     }
   ],
-  [EventType2.ENTITY_LEFT]: [
+  [EventType.ENTITY_LEFT]: [
     async (payload) => {
       try {
         const entity = await payload.runtime.getEntityById(payload.entityId);
@@ -6444,34 +6158,34 @@ var events = {
           };
           await payload.runtime.updateEntity(entity);
         }
-        logger19.info(`[Bootstrap] User ${payload.entityId} left world ${payload.worldId}`);
+        logger18.info(`[Bootstrap] User ${payload.entityId} left world ${payload.worldId}`);
       } catch (error) {
-        logger19.error(`[Bootstrap] Error handling user left: ${error.message}`);
+        logger18.error(`[Bootstrap] Error handling user left: ${error.message}`);
       }
     }
   ],
-  [EventType2.ACTION_STARTED]: [
+  [EventType.ACTION_STARTED]: [
     async (payload) => {
-      logger19.debug(`[Bootstrap] Action started: ${payload.actionName} (${payload.actionId})`);
+      logger18.debug(`[Bootstrap] Action started: ${payload.actionName} (${payload.actionId})`);
     }
   ],
-  [EventType2.ACTION_COMPLETED]: [
+  [EventType.ACTION_COMPLETED]: [
     async (payload) => {
       const status = payload.error ? `failed: ${payload.error.message}` : "completed";
-      logger19.debug(`[Bootstrap] Action ${status}: ${payload.actionName} (${payload.actionId})`);
+      logger18.debug(`[Bootstrap] Action ${status}: ${payload.actionName} (${payload.actionId})`);
     }
   ],
-  [EventType2.EVALUATOR_STARTED]: [
+  [EventType.EVALUATOR_STARTED]: [
     async (payload) => {
-      logger19.debug(
+      logger18.debug(
         `[Bootstrap] Evaluator started: ${payload.evaluatorName} (${payload.evaluatorId})`
       );
     }
   ],
-  [EventType2.EVALUATOR_COMPLETED]: [
+  [EventType.EVALUATOR_COMPLETED]: [
     async (payload) => {
       const status = payload.error ? `failed: ${payload.error.message}` : "completed";
-      logger19.debug(
+      logger18.debug(
         `[Bootstrap] Evaluator ${status}: ${payload.evaluatorName} (${payload.evaluatorId})`
       );
     }
@@ -6516,7 +6230,7 @@ var bootstrapPlugin = {
     recentMessagesProvider,
     worldProvider
   ],
-  services: [TaskService, ScenarioService]
+  services: [TaskService]
 };
 var index_default = bootstrapPlugin;
 export {