@elizaos/plugin-bootstrap 1.0.0-beta.32 → 1.0.0-beta.34

package/dist/index.js

@@ -72,11 +72,11 @@ var require_dedent = __commonJS({
 // src/index.ts
 import {
   asUUID,
-  ChannelType as ChannelType9,
+  ChannelType as ChannelType10,
   composePromptFromState as composePromptFromState9,
   createUniqueUuid as createUniqueUuid4,
   EventType as EventType2,
-  logger as logger16,
+  logger as logger17,
   messageHandlerTemplate,
   ModelType as ModelType13,
   parseJSONObjectFromText as parseJSONObjectFromText4,
@@ -1602,7 +1602,6 @@ var updateRoleAction = {
     ]
   ]
 };
-var roles_default = updateRoleAction;
 
 // src/actions/sendMessage.ts
 import {
@@ -2486,7 +2485,6 @@ var updateSettingsAction = {
     ]
   ]
 };
-var settings_default = updateSettingsAction;
 
 // src/actions/unfollowRoom.ts
 import {
@@ -4867,13 +4865,157 @@ var timeProvider = {
   }
 };
 
+// src/providers/world.ts
+import {
+  logger as logger14,
+  addHeader as addHeader10,
+  ChannelType as ChannelType8
+} from "@elizaos/core";
+var worldProvider = {
+  name: "WORLD",
+  description: "World and environment information",
+  dynamic: true,
+  get: async (runtime, message) => {
+    try {
+      logger14.debug("\u{1F310} World provider activated for roomId:", message.roomId);
+      const currentRoom = await runtime.getRoom(message.roomId);
+      if (!currentRoom) {
+        logger14.warn(`World provider: Room not found for roomId ${message.roomId}`);
+        return {
+          data: {
+            world: {
+              info: "Unable to retrieve world information - room not found"
+            }
+          },
+          text: "Unable to retrieve world information - room not found"
+        };
+      }
+      logger14.debug(`\u{1F310} World provider: Found room "${currentRoom.name}" (${currentRoom.type})`);
+      const worldId = currentRoom.worldId;
+      const world = await runtime.getWorld(worldId);
+      if (!world) {
+        logger14.warn(`World provider: World not found for worldId ${worldId}`);
+        return {
+          data: {
+            world: {
+              info: "Unable to retrieve world information - world not found"
+            }
+          },
+          text: "Unable to retrieve world information - world not found"
+        };
+      }
+      logger14.debug(`\u{1F310} World provider: Found world "${world.name}" (ID: ${world.id})`);
+      const worldRooms = await runtime.getRooms(worldId);
+      logger14.debug(`\u{1F310} World provider: Found ${worldRooms.length} rooms in world "${world.name}"`);
+      const participants = await runtime.getParticipantsForRoom(message.roomId);
+      logger14.debug(
+        `\u{1F310} World provider: Found ${participants.length} participants in room "${currentRoom.name}"`
+      );
+      const channelsByType = {
+        text: [],
+        voice: [],
+        dm: [],
+        feed: [],
+        thread: [],
+        other: []
+      };
+      for (const room of worldRooms) {
+        const roomInfo = {
+          id: room.id,
+          name: room.name,
+          isCurrentChannel: room.id === message.roomId
+        };
+        if (room.type === ChannelType8.GROUP || room.type === ChannelType8.WORLD || room.type === ChannelType8.FORUM) {
+          channelsByType.text.push(roomInfo);
+        } else if (room.type === ChannelType8.VOICE_GROUP || room.type === ChannelType8.VOICE_DM) {
+          channelsByType.voice.push(roomInfo);
+        } else if (room.type === ChannelType8.DM || room.type === ChannelType8.SELF) {
+          channelsByType.dm.push(roomInfo);
+        } else if (room.type === ChannelType8.FEED) {
+          channelsByType.feed.push(roomInfo);
+        } else if (room.type === ChannelType8.THREAD) {
+          channelsByType.thread.push(roomInfo);
+        } else {
+          channelsByType.other.push({
+            ...roomInfo,
+            type: room.type
+          });
+        }
+      }
+      const worldInfoText = [
+        `# World: ${world.name}`,
+        `Current Channel: ${currentRoom.name} (${currentRoom.type})`,
+        `Total Channels: ${worldRooms.length}`,
+        `Participants in current channel: ${participants.length}`,
+        "",
+        `Text channels: ${channelsByType.text.length}`,
+        `Voice channels: ${channelsByType.voice.length}`,
+        `DM channels: ${channelsByType.dm.length}`,
+        `Feed channels: ${channelsByType.feed.length}`,
+        `Thread channels: ${channelsByType.thread.length}`,
+        `Other channels: ${channelsByType.other.length}`
+      ].join("\n");
+      const data = {
+        world: {
+          id: world.id,
+          name: world.name,
+          serverId: world.serverId,
+          metadata: world.metadata || {},
+          currentRoom: {
+            id: currentRoom.id,
+            name: currentRoom.name,
+            type: currentRoom.type,
+            channelId: currentRoom.channelId,
+            participantCount: participants.length
+          },
+          channels: channelsByType,
+          channelStats: {
+            total: worldRooms.length,
+            text: channelsByType.text.length,
+            voice: channelsByType.voice.length,
+            dm: channelsByType.dm.length,
+            feed: channelsByType.feed.length,
+            thread: channelsByType.thread.length,
+            other: channelsByType.other.length
+          }
+        }
+      };
+      const values = {
+        worldName: world.name,
+        currentChannelName: currentRoom.name,
+        worldInfo: worldInfoText
+      };
+      const formattedText = addHeader10("# World Information", worldInfoText);
+      logger14.debug("\u{1F310} World provider completed successfully");
+      return {
+        data,
+        values,
+        text: formattedText
+      };
+    } catch (error) {
+      logger14.error(
+        `Error in world provider: ${error instanceof Error ? error.message : String(error)}`
+      );
+      return {
+        data: {
+          world: {
+            info: "Error retrieving world information",
+            error: error instanceof Error ? error.message : "Unknown error"
+          }
+        },
+        text: "Error retrieving world information"
+      };
+    }
+  }
+};
+
 // src/services/scenario.ts
 import {
-  ChannelType as ChannelType8,
+  ChannelType as ChannelType9,
   EventType,
   Service,
   createUniqueUuid as createUniqueUuid3,
-  logger as logger14
+  logger as logger15
 } from "@elizaos/core";
 var ScenarioService = class _ScenarioService extends Service {
   /**
@@ -4917,7 +5059,7 @@ var ScenarioService = class _ScenarioService extends Service {
         startTime: Date.now(),
         completed: false
       });
-      logger14.debug("Evaluator started", data);
+      logger15.debug("Evaluator started", data);
       return Promise.resolve();
     });
     this.runtime.registerEvent(
@@ -4928,7 +5070,7 @@ var ScenarioService = class _ScenarioService extends Service {
           evaluator.completed = true;
           evaluator.error = data.error;
         }
-        logger14.debug("Evaluator completed", data);
+        logger15.debug("Evaluator completed", data);
         return Promise.resolve();
       }
     );
@@ -5007,7 +5149,7 @@ var ScenarioService = class _ScenarioService extends Service {
       id: roomId,
       name,
       source: "scenario",
-      type: ChannelType8.GROUP,
+      type: ChannelType9.GROUP,
       channelId: roomId,
       serverId: worldId
     });
@@ -5051,7 +5193,7 @@ var ScenarioService = class _ScenarioService extends Service {
         source: "scenario",
         name: sender.character.name,
         userName: sender.character.name,
-        channelType: ChannelType8.GROUP
+        channelType: ChannelType9.GROUP
       }
     };
     const participants = await this.runtime.getParticipantsForRoom(roomId);
@@ -5062,7 +5204,7 @@ var ScenarioService = class _ScenarioService extends Service {
         roomId,
         entityId: participantId,
         source: "scenario",
-        type: ChannelType8.GROUP
+        type: ChannelType9.GROUP
       });
     }
   }
@@ -5109,7 +5251,7 @@ var ScenarioService = class _ScenarioService extends Service {
 
 // src/services/task.ts
 import {
-  logger as logger15,
+  logger as logger16,
   Service as Service2,
   ServiceType
 } from "@elizaos/core";
@@ -5137,21 +5279,21 @@ var TaskService = class _TaskService extends Service2 {
     this.runtime.registerTaskWorker({
       name: "REPEATING_TEST_TASK",
       validate: async (_runtime, _message, _state) => {
-        logger15.debug("Validating repeating test task");
+        logger16.debug("Validating repeating test task");
         return true;
       },
       execute: async (_runtime, _options) => {
-        logger15.debug("Executing repeating test task");
+        logger16.debug("Executing repeating test task");
       }
     });
     this.runtime.registerTaskWorker({
       name: "ONETIME_TEST_TASK",
       validate: async (_runtime, _message, _state) => {
-        logger15.debug("Validating one-time test task");
+        logger16.debug("Validating one-time test task");
         return true;
       },
       execute: async (_runtime, _options) => {
-        logger15.debug("Executing one-time test task");
+        logger16.debug("Executing one-time test task");
       }
     });
     const tasks = await this.runtime.getTasksByName("REPEATING_TEST_TASK");
@@ -5188,7 +5330,7 @@ var TaskService = class _TaskService extends Service2 {
       try {
         await this.checkTasks();
       } catch (error) {
-        logger15.error("Error checking tasks:", error);
+        logger16.error("Error checking tasks:", error);
       }
     }, this.TICK_INTERVAL);
   }
@@ -5217,7 +5359,7 @@ var TaskService = class _TaskService extends Service2 {
             continue;
           }
         } catch (error) {
-          logger15.error(`Error validating task ${task.name}:`, error);
+          logger16.error(`Error validating task ${task.name}:`, error);
           continue;
         }
       }
@@ -5254,14 +5396,14 @@ var TaskService = class _TaskService extends Service2 {
           continue;
         }
         if (now - taskStartTime >= updateIntervalMs) {
-          logger15.debug(
+          logger16.debug(
             `Executing task ${task.name} - interval of ${updateIntervalMs}ms has elapsed`
           );
           await this.executeTask(task);
         }
       }
     } catch (error) {
-      logger15.error("Error checking tasks:", error);
+      logger16.error("Error checking tasks:", error);
     }
   }
   /**
@@ -5272,17 +5414,17 @@ var TaskService = class _TaskService extends Service2 {
   async executeTask(task) {
     try {
       if (!task) {
-        logger15.debug(`Task ${task.id} not found`);
+        logger16.debug(`Task ${task.id} not found`);
         return;
       }
       const worker = this.runtime.getTaskWorker(task.name);
       if (!worker) {
-        logger15.debug(`No worker found for task type: ${task.name}`);
+        logger16.debug(`No worker found for task type: ${task.name}`);
         return;
       }
-      logger15.debug(`Executing task ${task.name} (${task.id})`);
+      logger16.debug(`Executing task ${task.name} (${task.id})`);
       await worker.execute(this.runtime, task.metadata || {}, task);
-      logger15.debug("task.tags are", task.tags);
+      logger16.debug("task.tags are", task.tags);
       if (task.tags?.includes("repeat")) {
         await this.runtime.updateTask(task.id, {
           metadata: {
@@ -5290,13 +5432,13 @@ var TaskService = class _TaskService extends Service2 {
             updatedAt: Date.now()
           }
         });
-        logger15.debug(`Updated repeating task ${task.name} (${task.id}) with new timestamp`);
+        logger16.debug(`Updated repeating task ${task.name} (${task.id}) with new timestamp`);
       } else {
         await this.runtime.deleteTask(task.id);
-        logger15.debug(`Deleted non-repeating task ${task.name} (${task.id}) after execution`);
+        logger16.debug(`Deleted non-repeating task ${task.name} (${task.id}) after execution`);
       }
     } catch (error) {
-      logger15.error(`Error executing task ${task.id}:`, error);
+      logger16.error(`Error executing task ${task.id}:`, error);
     }
   }
   /**
@@ -5398,7 +5540,7 @@ var messageReceivedHandler = async ({
       ]);
       const agentUserState = await runtime.getParticipantUserState(message.roomId, runtime.agentId);
       if (agentUserState === "MUTED" && !message.content.text?.toLowerCase().includes(runtime.character.name.toLowerCase())) {
-        logger16.debug("Ignoring muted room");
+        logger17.debug("Ignoring muted room");
         return;
       }
       let state = await runtime.composeState(message, [
@@ -5409,7 +5551,7 @@ var messageReceivedHandler = async ({
         "ENTITIES"
       ]);
       const room = await runtime.getRoom(message.roomId);
-      const shouldSkipShouldRespond = room?.type === ChannelType9.DM || room?.type === ChannelType9.VOICE_DM || room?.type === ChannelType9.SELF;
+      const shouldSkipShouldRespond = room?.type === ChannelType10.DM || room?.type === ChannelType10.VOICE_DM || room?.type === ChannelType10.SELF;
       let shouldRespond = true;
       let providers = [];
       if (!shouldSkipShouldRespond) {
@@ -5417,7 +5559,7 @@ var messageReceivedHandler = async ({
           state,
           template: runtime.character.templates?.shouldRespondTemplate || shouldRespondTemplate
         });
-        logger16.debug(
+        logger17.debug(
           `*** Should Respond Prompt for ${runtime.character.name} ***
 `,
           shouldRespondPrompt
@@ -5425,17 +5567,17 @@ var messageReceivedHandler = async ({
         const response = await runtime.useModel(ModelType13.TEXT_SMALL, {
           prompt: shouldRespondPrompt
         });
-        logger16.debug(`*** Should Respond Response for ${runtime.character.name} ***
+        logger17.debug(`*** Should Respond Response for ${runtime.character.name} ***
 `, response);
-        logger16.debug(`*** Raw Response Type: ${typeof response} ***`);
+        logger17.debug(`*** Raw Response Type: ${typeof response} ***`);
         let processedResponse = response;
         if (typeof response === "string" && response.includes("```")) {
-          logger16.debug("*** Response contains code block markers, attempting to clean up ***");
+          logger17.debug("*** Response contains code block markers, attempting to clean up ***");
           processedResponse = response.replace(/```json\n|\n```|```/g, "");
-          logger16.debug("*** Processed Response ***\n", processedResponse);
+          logger17.debug("*** Processed Response ***\n", processedResponse);
         }
         const responseObject = parseJSONObjectFromText4(processedResponse);
-        logger16.debug("*** Parsed Response Object ***", responseObject);
+        logger17.debug("*** Parsed Response Object ***", responseObject);
         shouldRespond = responseObject?.action && responseObject.action === "RESPOND";
         providers = responseObject?.providers || [];
       } else {
@@ -5449,8 +5591,8 @@ var messageReceivedHandler = async ({
         const responseObject = parseJSONObjectFromText4(response);
         providers = responseObject?.providers || [];
       }
-      logger16.debug("*** Should Respond ***", shouldRespond);
-      logger16.debug("*** Providers Value ***", providers);
+      logger17.debug("*** Should Respond ***", shouldRespond);
+      logger17.debug("*** Providers Value ***", providers);
       state = await runtime.composeState(message, null, providers);
       let responseMessages = [];
       if (shouldRespond) {
@@ -5468,12 +5610,12 @@ var messageReceivedHandler = async ({
           responseContent = parseJSONObjectFromText4(response);
           retries++;
           if (!responseContent?.thought && !responseContent?.actions) {
-            logger16.warn("*** Missing required fields, retrying... ***");
+            logger17.warn("*** Missing required fields, retrying... ***");
           }
         }
         const currentResponseId = agentResponses.get(message.roomId);
         if (currentResponseId !== responseId) {
-          logger16.info(
+          logger17.info(
             `Response discarded - newer message being processed for agent: ${runtime.agentId}, room: ${message.roomId}`
           );
           return;
@@ -5544,10 +5686,10 @@ var reactionReceivedHandler = async ({
     await runtime.createMemory(message, "messages");
   } catch (error) {
     if (error.code === "23505") {
-      logger16.warn("Duplicate reaction memory, skipping");
+      logger17.warn("Duplicate reaction memory, skipping");
       return;
     }
-    logger16.error("Error in reaction handler:", error);
+    logger17.error("Error in reaction handler:", error);
   }
 };
 var postGeneratedHandler = async ({
@@ -5558,7 +5700,7 @@ var postGeneratedHandler = async ({
   roomId,
   source
 }) => {
-  logger16.info("Generating new post...");
+  logger17.info("Generating new post...");
   await runtime.ensureWorldExists({
     id: worldId,
     name: `${runtime.character.name}'s Feed`,
@@ -5569,7 +5711,7 @@ var postGeneratedHandler = async ({
     id: roomId,
     name: `${runtime.character.name}'s Feed`,
     source,
-    type: ChannelType9.FEED,
+    type: ChannelType10.FEED,
     channelId: `${userId}-home`,
     serverId: userId,
     worldId
@@ -5611,7 +5753,7 @@ var postGeneratedHandler = async ({
       content: {
         text: cleanedText,
         source,
-        channelType: ChannelType9.FEED,
+        channelType: ChannelType10.FEED,
         thought: jsonResponse.thought || "",
         type: "post"
       },
@@ -5625,10 +5767,10 @@ var postGeneratedHandler = async ({
 };
 var syncSingleUser = async (entityId, runtime, serverId, channelId, type, source) => {
   const entity = await runtime.getEntityById(entityId);
-  logger16.info(`Syncing user: ${entity.metadata[source].username || entity.id}`);
+  logger17.info(`Syncing user: ${entity.metadata[source].username || entity.id}`);
   try {
     if (!channelId) {
-      logger16.warn(`Cannot sync user ${entity.id} without a valid channelId`);
+      logger17.warn(`Cannot sync user ${entity.id} without a valid channelId`);
       return;
     }
     const roomId = createUniqueUuid4(runtime, channelId);
@@ -5644,9 +5786,9 @@ var syncSingleUser = async (entityId, runtime, serverId, channelId, type, source
       type,
       worldId
     });
-    logger16.success(`Successfully synced user: ${entity.id}`);
+    logger17.success(`Successfully synced user: ${entity.id}`);
   } catch (error) {
-    logger16.error(`Error syncing user: ${error instanceof Error ? error.message : String(error)}`);
+    logger17.error(`Error syncing user: ${error instanceof Error ? error.message : String(error)}`);
   }
 };
 var handleServerSync = async ({
@@ -5657,7 +5799,7 @@ var handleServerSync = async ({
   source,
   onComplete
 }) => {
-  logger16.debug(`Handling server sync event for server: ${world.name}`);
+  logger17.debug(`Handling server sync event for server: ${world.name}`);
   try {
     await runtime.ensureWorldExists({
       id: world.id,
@@ -5701,7 +5843,7 @@ var handleServerSync = async ({
                 worldId: world.id
               });
             } catch (err) {
-              logger16.warn(`Failed to sync user ${entity.metadata.username}: ${err}`);
+              logger17.warn(`Failed to sync user ${entity.metadata.username}: ${err}`);
             }
           })
         );
@@ -5710,14 +5852,51 @@ var handleServerSync = async ({
         }
       }
     }
-    logger16.debug(`Successfully synced standardized world structure for ${world.name}`);
+    logger17.debug(`Successfully synced standardized world structure for ${world.name}`);
     onComplete?.();
   } catch (error) {
-    logger16.error(
+    logger17.error(
       `Error processing standardized server data: ${error instanceof Error ? error.message : String(error)}`
     );
   }
 };
+var controlMessageHandler = async ({
+  runtime,
+  message,
+  source
+}) => {
+  try {
+    logger17.debug(
+      `[controlMessageHandler] Processing control message: ${message.payload.action} for room ${message.roomId}`
+    );
+    const serviceNames = Array.from(runtime.getAllServices().keys());
+    const websocketServiceName = serviceNames.find(
+      (name) => name.toLowerCase().includes("websocket") || name.toLowerCase().includes("socket")
+    );
+    if (websocketServiceName) {
+      const websocketService = runtime.getService(websocketServiceName);
+      if (websocketService && "sendMessage" in websocketService) {
+        await websocketService.sendMessage({
+          type: "controlMessage",
+          payload: {
+            action: message.payload.action,
+            target: message.payload.target,
+            roomId: message.roomId
+          }
+        });
+        logger17.debug(
+          `[controlMessageHandler] Control message ${message.payload.action} sent successfully`
+        );
+      } else {
+        logger17.error("[controlMessageHandler] WebSocket service does not have sendMessage method");
+      }
+    } else {
+      logger17.error("[controlMessageHandler] No WebSocket service found to send control message");
+    }
+  } catch (error) {
+    logger17.error(`[controlMessageHandler] Error processing control message: ${error}`);
+  }
+};
 var events = {
   [EventType2.MESSAGE_RECEIVED]: [
     async (payload) => {
@@ -5753,7 +5932,7 @@ var events = {
   ],
   [EventType2.MESSAGE_SENT]: [
     async (payload) => {
-      logger16.debug(`Message sent: ${payload.message.content.text}`);
+      logger17.debug(`Message sent: ${payload.message.content.text}`);
     }
   ],
   [EventType2.WORLD_JOINED]: [
@@ -5790,34 +5969,35 @@ var events = {
           };
           await payload.runtime.updateEntity(entity);
         }
-        logger16.info(`User ${payload.entityId} left world ${payload.worldId}`);
+        logger17.info(`User ${payload.entityId} left world ${payload.worldId}`);
       } catch (error) {
-        logger16.error(`Error handling user left: ${error.message}`);
+        logger17.error(`Error handling user left: ${error.message}`);
       }
     }
   ],
   [EventType2.ACTION_STARTED]: [
     async (payload) => {
-      logger16.debug(`Action started: ${payload.actionName} (${payload.actionId})`);
+      logger17.debug(`Action started: ${payload.actionName} (${payload.actionId})`);
     }
   ],
   [EventType2.ACTION_COMPLETED]: [
     async (payload) => {
       const status = payload.error ? `failed: ${payload.error.message}` : "completed";
-      logger16.debug(`Action ${status}: ${payload.actionName} (${payload.actionId})`);
+      logger17.debug(`Action ${status}: ${payload.actionName} (${payload.actionId})`);
     }
   ],
   [EventType2.EVALUATOR_STARTED]: [
     async (payload) => {
-      logger16.debug(`Evaluator started: ${payload.evaluatorName} (${payload.evaluatorId})`);
+      logger17.debug(`Evaluator started: ${payload.evaluatorName} (${payload.evaluatorId})`);
     }
   ],
   [EventType2.EVALUATOR_COMPLETED]: [
     async (payload) => {
       const status = payload.error ? `failed: ${payload.error.message}` : "completed";
-      logger16.debug(`Evaluator ${status}: ${payload.evaluatorName} (${payload.evaluatorId})`);
+      logger17.debug(`Evaluator ${status}: ${payload.evaluatorName} (${payload.evaluatorId})`);
     }
-  ]
+  ],
+  CONTROL_MESSAGE: [controlMessageHandler]
 };
 var bootstrapPlugin = {
   name: "bootstrap",
@@ -5833,8 +6013,8 @@ var bootstrapPlugin = {
     sendMessageAction,
     updateEntityAction,
     choiceAction,
-    roles_default,
-    settings_default
+    updateRoleAction,
+    updateSettingsAction
   ],
   events,
   evaluators: [reflectionEvaluator],
@@ -5854,14 +6034,45 @@ var bootstrapPlugin = {
     providersProvider,
     actionsProvider,
     characterProvider,
-    recentMessagesProvider
+    recentMessagesProvider,
+    worldProvider
   ],
   services: [TaskService, ScenarioService]
 };
 var index_default = bootstrapPlugin;
 export {
+  actionsProvider,
+  anxietyProvider,
+  attachmentsProvider,
   bootstrapPlugin,
+  capabilitiesProvider,
+  characterProvider,
+  choiceAction,
+  choiceProvider,
   index_default as default,
-  fetchMediaData
+  entitiesProvider,
+  evaluatorsProvider,
+  factsProvider,
+  fetchMediaData,
+  followRoomAction,
+  ignoreAction,
+  knowledgeProvider,
+  muteRoomAction,
+  noneAction,
+  providersProvider,
+  recentMessagesProvider,
+  reflectionEvaluator,
+  relationshipsProvider,
+  replyAction,
+  roleProvider,
+  sendMessageAction,
+  settingsProvider,
+  timeProvider,
+  unfollowRoomAction,
+  unmuteRoomAction,
+  updateEntityAction,
+  updateRoleAction,
+  updateSettingsAction,
+  worldProvider
 };
 //# sourceMappingURL=index.js.map