@elizaos/plugin-bootstrap 1.7.3-alpha.2 → 1.7.3-alpha.4

package/dist/index.js

@@ -83,13 +83,14 @@ import {
   ChannelType as ChannelType9,
   composePromptFromState as composePromptFromState10,
   ContentType as ContentType2,
-  createUniqueUuid,
+  createUniqueUuid as createUniqueUuid3,
   EventType as EventType2,
   imageDescriptionTemplate,
-  logger as logger16,
+  logger as logger18,
   messageHandlerTemplate,
   ModelType as ModelType15,
   parseKeyValueXml as parseKeyValueXml9,
+  parseBooleanFromText as parseBooleanFromText3,
   postCreationTemplate,
   Role as Role2,
   getLocalServerUrl
@@ -4843,7 +4844,7 @@ var updateEntityAction = {
 };
 // src/evaluators/reflection.ts
 import { z } from "zod";
-import { asUUID, getEntityDetails, parseKeyValueXml as parseKeyValueXml8 } from "@elizaos/core";
+import { asUUID, parseKeyValueXml as parseKeyValueXml8 } from "@elizaos/core";
 import { composePrompt as composePrompt4 } from "@elizaos/core";
 import {
   ModelType as ModelType12
@@ -4922,36 +4923,59 @@ Generate a response in the following format:
 </response>
 
 IMPORTANT: Your response must ONLY contain the <response></response> XML block above. Do not include any text, thinking, or reasoning before or after this XML block. Start your response immediately with <response> and end with </response>.`;
-function resolveEntity(entityId, entities) {
-  if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(entityId)) {
+var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function resolveEntityWithMaps(entityId, entityById, entityByName) {
+  if (UUID_PATTERN.test(entityId)) {
     return entityId;
   }
-  let entity;
-  entity = entities.find((a) => a.id === entityId);
-  if (entity?.id) {
-    return entity.id;
+  const byId = entityById.get(entityId);
+  if (byId?.id) {
+    return byId.id;
   }
-  entity = entities.find((a) => a.id?.includes(entityId));
-  if (entity?.id) {
-    return entity.id;
+  const byName = entityByName.get(entityId.toLowerCase());
+  if (byName?.id) {
+    return byName.id;
   }
-  entity = entities.find((a) => a.names.some((n) => n.toLowerCase().includes(entityId.toLowerCase())));
-  if (entity?.id) {
-    return entity.id;
+  for (const [id, entity] of entityById) {
+    if (id?.includes(entityId) && entity.id) {
+      return entity.id;
+    }
+  }
+  for (const entity of entityById.values()) {
+    if (entity.names.some((n) => n.toLowerCase().includes(entityId.toLowerCase())) && entity.id) {
+      return entity.id;
+    }
   }
   throw new Error(`Could not resolve entityId "${entityId}" to a valid UUID`);
 }
+function buildEntityMaps(entities) {
+  const byId = new Map;
+  const byName = new Map;
+  for (const entity of entities) {
+    if (entity.id) {
+      byId.set(entity.id, entity);
+    }
+    for (const name of entity.names || []) {
+      byName.set(name.toLowerCase(), entity);
+    }
+  }
+  return { byId, byName };
+}
 async function handler(runtime, message, state) {
-  const { agentId, roomId } = message;
+  const { agentId, roomId, entityId } = message;
   if (!agentId || !roomId) {
-    runtime.logger.warn({ src: "plugin:bootstrap:evaluator:reflection", agentId: runtime.agentId, message }, "Missing agentId or roomId in message");
+    runtime.logger.warn({ src: "plugin:bootstrap:evaluator:reflection", agentId: runtime.agentId }, "Missing agentId or roomId in message");
     return;
   }
+  if (!entityId) {
+    runtime.logger.warn({ src: "plugin:bootstrap:evaluator:reflection", agentId: runtime.agentId }, "Missing entityId in message");
+    return;
+  }
+  const entitiesProviderResult = state?.data?.providers?.ENTITIES;
+  const entitiesFromState = entitiesProviderResult && typeof entitiesProviderResult === "object" && "data" in entitiesProviderResult && Array.isArray(entitiesProviderResult.data?.entitiesData) ? entitiesProviderResult.data.entitiesData : undefined;
   const [existingRelationships, entities, knownFacts] = await Promise.all([
-    runtime.getRelationships({
-      entityId: message.entityId
-    }),
-    getEntityDetails({ runtime, roomId }),
+    runtime.getRelationships({ entityId }),
+    entitiesFromState ?? runtime.getEntitiesForRoom(roomId, true),
     runtime.getMemories({
       tableName: "facts",
       roomId,
@@ -4992,8 +5016,9 @@ async function handler(runtime, message, state) {
       return;
     }
     let factsArray = [];
-    if (reflection.facts.fact) {
-      factsArray = Array.isArray(reflection.facts.fact) ? reflection.facts.fact : [reflection.facts.fact];
+    const factsData = reflection.facts;
+    if (factsData.fact) {
+      factsArray = Array.isArray(factsData.fact) ? factsData.fact : [factsData.fact];
     }
     const newFacts = factsArray.filter((fact) => fact != null && fact.already_known === "false" && fact.in_bio === "false" && typeof fact.claim === "string" && fact.claim.trim() !== "");
     await Promise.all(newFacts.map(async (fact) => {
@@ -5011,28 +5036,36 @@ async function handler(runtime, message, state) {
       return createdMemory;
     }));
     let relationshipsArray = [];
-    if (reflection.relationships.relationship) {
-      relationshipsArray = Array.isArray(reflection.relationships.relationship) ? reflection.relationships.relationship : [reflection.relationships.relationship];
+    const relationshipsData = reflection.relationships;
+    if (relationshipsData.relationship) {
+      relationshipsArray = Array.isArray(relationshipsData.relationship) ? relationshipsData.relationship : [relationshipsData.relationship];
+    }
+    if (relationshipsArray.length === 0) {
+      await runtime.setCache(`${message.roomId}-reflection-last-processed`, message?.id || "");
+      return;
+    }
+    const { byId: entityById, byName: entityByName } = buildEntityMaps(entities);
+    const existingRelationshipMap = new Map;
+    for (const rel of existingRelationships) {
+      const key = `${rel.sourceEntityId}-${rel.targetEntityId}`;
+      existingRelationshipMap.set(key, rel);
     }
+    const relationshipPromises = [];
     for (const relationship of relationshipsArray) {
       if (!relationship.sourceEntityId || !relationship.targetEntityId) {
-        console.warn("Skipping relationship with missing entity IDs:", relationship);
+        runtime.logger.warn({ src: "plugin:bootstrap:evaluator:reflection", agentId: runtime.agentId }, "Skipping relationship with missing entity IDs");
         continue;
       }
       let sourceId;
       let targetId;
       try {
-        sourceId = resolveEntity(relationship.sourceEntityId, entities);
-        targetId = resolveEntity(relationship.targetEntityId, entities);
+        sourceId = resolveEntityWithMaps(relationship.sourceEntityId, entityById, entityByName);
+        targetId = resolveEntityWithMaps(relationship.targetEntityId, entityById, entityByName);
       } catch (error) {
-        console.warn("Failed to resolve relationship entities:", error);
-        console.warn(`relationship:
-`, relationship);
+        runtime.logger.warn({ src: "plugin:bootstrap:evaluator:reflection", agentId: runtime.agentId, error: error instanceof Error ? error.message : String(error) }, "Failed to resolve relationship entities");
         continue;
       }
-      const existingRelationship = existingRelationships.find((r) => {
-        return r.sourceEntityId === sourceId && r.targetEntityId === targetId;
-      });
+      const existingRelationship = existingRelationshipMap.get(`${sourceId}-${targetId}`);
       const tags = relationship.tags ? relationship.tags.split(",").map((tag) => tag.trim()).filter(Boolean) : [];
       if (existingRelationship) {
         const updatedMetadata = {
@@ -5040,13 +5073,13 @@ async function handler(runtime, message, state) {
           interactions: (existingRelationship.metadata?.interactions || 0) + 1
         };
         const updatedTags = Array.from(new Set([...existingRelationship.tags || [], ...tags]));
-        await runtime.updateRelationship({
+        relationshipPromises.push(runtime.updateRelationship({
           ...existingRelationship,
           tags: updatedTags,
           metadata: updatedMetadata
-        });
+        }).then(() => {}));
       } else {
-        await runtime.createRelationship({
+        relationshipPromises.push(runtime.createRelationship({
           sourceEntityId: sourceId,
           targetEntityId: targetId,
           tags,
@@ -5054,16 +5087,15 @@ async function handler(runtime, message, state) {
             interactions: 1,
             ...relationship.metadata || {}
           }
-        });
+        }).then(() => {}));
       }
     }
+    if (relationshipPromises.length > 0) {
+      await Promise.all(relationshipPromises);
+    }
     await runtime.setCache(`${message.roomId}-reflection-last-processed`, message?.id || "");
   } catch (error) {
-    runtime.logger.error({
-      src: "plugin:bootstrap:evaluator:reflection",
-      agentId: runtime.agentId,
-      error: error instanceof Error ? error.message : String(error)
-    }, "Error in reflection handler");
+    runtime.logger.error({ src: "plugin:bootstrap:evaluator:reflection", agentId: runtime.agentId, error: error instanceof Error ? error.message : String(error) }, "Error in reflection handler");
     return;
   }
 }
@@ -5071,20 +5103,28 @@ var reflectionEvaluator = {
   name: "REFLECTION",
   similes: ["REFLECT", "SELF_REFLECT", "EVALUATE_INTERACTION", "ASSESS_SITUATION"],
   validate: async (runtime, message) => {
+    if (!message.roomId) {
+      return false;
+    }
+    const reflectionInterval = Math.ceil(runtime.getConversationLength() / 4);
     const lastMessageId = await runtime.getCache(`${message.roomId}-reflection-last-processed`);
     const messages = await runtime.getMemories({
       tableName: "messages",
       roomId: message.roomId,
-      count: runtime.getConversationLength()
+      count: runtime.getConversationLength(),
+      unique: false
     });
+    if (messages.length === 0) {
+      return false;
+    }
+    let messagesSinceReflection = messages.length;
     if (lastMessageId) {
       const lastMessageIndex = messages.findIndex((msg) => msg.id === lastMessageId);
       if (lastMessageIndex !== -1) {
-        messages.splice(0, lastMessageIndex + 1);
+        messagesSinceReflection = messages.length - lastMessageIndex - 1;
       }
     }
-    const reflectionInterval = Math.ceil(runtime.getConversationLength() / 4);
-    return messages.length > reflectionInterval;
+    return messagesSinceReflection > reflectionInterval;
   },
   description: "Generate a self-reflective thought on the conversation, then extract facts and relationships between entities in the conversation.",
   handler,
@@ -5258,7 +5298,7 @@ function formatFacts(facts) {
 `);
 }
 // src/providers/actions.ts
-import { addHeader, composeActionExamples, formatActionNames, formatActions } from "@elizaos/core";
+import { addHeader, composeActionExamples, formatActionNames, formatActions, logger as logger11 } from "@elizaos/core";
 function formatActionsWithParams(actions) {
   return actions.map((action) => {
     let formatted = `## ${action.name}
@@ -5301,16 +5341,28 @@ var actionsProvider = {
           return action;
         }
       } catch (e) {
-        console.error("ACTIONS GET -> validate err", action, e);
+        logger11.error({ src: "plugin:bootstrap:provider:actions", agentId: runtime.agentId, action: action.name, error: e instanceof Error ? e.message : String(e) }, "Action validation error");
       }
       return null;
     });
     const resolvedActions = await Promise.all(actionPromises);
-    const actionsData = resolvedActions.filter(Boolean);
+    const actionsData = resolvedActions.filter((a) => a !== null);
+    if (actionsData.length === 0) {
+      return {
+        data: { actionsData: [] },
+        values: {
+          actionNames: "Possible response actions: none",
+          actionExamples: "",
+          actionsWithDescriptions: "",
+          actionsWithParams: ""
+        },
+        text: "Possible response actions: none"
+      };
+    }
     const actionNames = `Possible response actions: ${formatActionNames(actionsData)}`;
-    const actionsWithDescriptions = actionsData.length > 0 ? addHeader("# Available Actions", formatActions(actionsData)) : "";
-    const actionsWithParams = actionsData.length > 0 ? addHeader("# Available Actions with Parameters", formatActionsWithParams(actionsData)) : "";
-    const actionExamples = actionsData.length > 0 ? addHeader("# Action Examples", composeActionExamples(actionsData, 10)) : "";
+    const actionsWithDescriptions = addHeader("# Available Actions", formatActions(actionsData));
+    const actionExamples = addHeader("# Action Examples", composeActionExamples(actionsData, 10));
+    const actionsWithParams = addHeader("# Available Actions with Parameters", formatActionsWithParams(actionsData));
     const data = {
       actionsData
     };
@@ -5320,7 +5372,7 @@ var actionsProvider = {
       actionsWithDescriptions,
       actionsWithParams
     };
-    const text = [actionNames, actionsWithDescriptions, actionExamples].filter(Boolean).join(`
+    const text = [actionNames, actionsWithDescriptions, actionExamples].join(`
 
 `);
     return {
@@ -5333,12 +5385,13 @@ var actionsProvider = {
 // src/providers/actionState.ts
 import {
   addHeader as addHeader2,
-  logger as logger11
+  logger as logger12
 } from "@elizaos/core";
 var actionStateProvider = {
   name: "ACTION_STATE",
   description: "Previous action results, working memory, and action plan from the current execution run",
   position: 150,
+  dynamic: true,
   get: async (runtime, message, state) => {
     const actionResults = state.data?.actionResults || [];
     const actionPlan = state.data?.actionPlan || null;
@@ -5428,7 +5481,7 @@ ${values}`;
       });
       recentActionMemories = recentMessages.filter((msg) => msg.content?.type === "action_result" && msg.metadata?.type === "action_result");
     } catch (error) {
-      logger11?.error({
+      logger12?.error({
         src: "plugin:bootstrap:provider:action_state",
         agentId: runtime.agentId,
         error: error instanceof Error ? error.message : String(error)
@@ -5513,7 +5566,10 @@ var anxietyProvider = {
       "You frequently over-explain simple concepts. If you can't be concise and confident in your response, please default to using IGNORE.",
       "Your helpful nature sometimes results in verbose, meandering responses. When in doubt, use IGNORE rather than attempting to cover every possibility.",
       "Like many AI assistants, you try to be too comprehensive. Remember that IGNORE is a valid response when you can't be both brief and certain.",
-      "You often provide more detail than necessary in an attempt to be thorough. If you can't give a clear, concise answer, please use IGNORE instead."
+      "You often provide more detail than necessary in an attempt to be thorough. If you can't give a clear, concise answer, please use IGNORE instead.",
+      "CRITICAL: When someone just says 'ok', 'yes', 'good', 'right', 'yep', etc. - this is conversational closure. Do NOT respond with another acknowledgment. Use IGNORE to let the conversation end naturally.",
+      "Watch out for ping-pong loops: if you and another agent are just exchanging brief acknowledgments back and forth ('Good.' 'Yep.' 'Right.' 'Sure.'), STOP immediately. Use IGNORE.",
+      "If the last few messages are just short confirmations going back and forth, the conversation is OVER. Do not extend it with another acknowledgment. Use IGNORE."
     ];
     const directAnxietyExamples = [
       "Be engaging and helpful in direct conversations, but keep responses focused and relevant.",
@@ -5617,13 +5673,22 @@ var attachmentsProvider = {
         allAttachments = [...currentMessageAttachments, ...recentAttachments];
       }
     }
-    const formattedAttachments = allAttachments.map((attachment) => `ID: ${attachment.id}
+    const formattedAttachments = allAttachments.map((attachment) => {
+      let displayUrl = attachment.url;
+      if (attachment.url?.startsWith("data:")) {
+        const mimeMatch = attachment.url.match(/^data:([^;,]+)/);
+        const mimeType = mimeMatch ? mimeMatch[1] : "unknown";
+        const sizeEstimate = Math.round(attachment.url.length * 3 / 4 / 1024);
+        displayUrl = `[Embedded ${mimeType} ~${sizeEstimate}KB]`;
+      }
+      return `ID: ${attachment.id}
     Name: ${attachment.title}
-    URL: ${attachment.url}
-    Type: ${attachment.source}
+    URL: ${displayUrl}
+    Type: ${attachment.source || attachment.contentType}
     Description: ${attachment.description}
     Text: ${attachment.text}
-    `).join(`
+    `;
+    }).join(`
 `);
     const text = formattedAttachments && formattedAttachments.length > 0 ? addHeader4("# Attachments", formattedAttachments) : "";
     const values = {
@@ -5688,65 +5753,400 @@ ${formattedCapabilities}`
 };
 // src/providers/character.ts
 import { addHeader as addHeader5, ChannelType as ChannelType4 } from "@elizaos/core";
+
+// src/providers/shared-cache.ts
+import { createUniqueUuid, getSalt as getSalt2, unsaltWorldSettings as unsaltWorldSettings2 } from "@elizaos/core";
+var CACHE_TTL_MS = 30000;
+var DB_TIMEOUT_MS = 5000;
+var NEGATIVE_CACHE_TTL_MS = 60000;
+var roomCache = new Map;
+var roomInFlight = new Map;
+var externalRoomCache = new Map;
+var worldCache = new Map;
+var worldInFlight = new Map;
+var externalWorldCache = new Map;
+var externalWorldInFlight = new Map;
+var noServerIdCache = new Map;
+var noSettingsCache = new Map;
+async function withTimeout(promise, ms, fallback) {
+  let timeoutId;
+  const timeoutPromise = new Promise((resolve) => {
+    timeoutId = setTimeout(() => resolve(fallback), ms);
+  });
+  try {
+    return await Promise.race([promise, timeoutPromise]);
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+function cleanupCache(cache, maxSize, ttl) {
+  if (cache.size <= maxSize)
+    return;
+  const now = Date.now();
+  for (const [key, entry] of cache) {
+    if (now - entry.timestamp > ttl * 2) {
+      cache.delete(key);
+    }
+  }
+}
+function getExternalRoomKey(room) {
+  if (!room.source || !room.channelId)
+    return null;
+  return `${room.source}:${room.channelId}`;
+}
+function cacheRoomByExternalId(room) {
+  const key = getExternalRoomKey(room);
+  if (!key)
+    return;
+  const externalData = {
+    name: room.name,
+    source: room.source,
+    type: room.type,
+    channelId: room.channelId,
+    messageServerId: room.messageServerId ?? room.serverId,
+    metadata: room.metadata
+  };
+  externalRoomCache.set(key, { data: externalData, timestamp: Date.now() });
+}
+async function getCachedRoom(runtime, roomId) {
+  const cacheKey = roomId;
+  const cached = roomCache.get(cacheKey);
+  const now = Date.now();
+  if (cached && now - cached.timestamp < CACHE_TTL_MS) {
+    return cached.data;
+  }
+  const inFlight = roomInFlight.get(cacheKey);
+  if (inFlight) {
+    return inFlight;
+  }
+  const fetchPromise = (async () => {
+    try {
+      const room = await withTimeout(runtime.getRoom(roomId), DB_TIMEOUT_MS, null);
+      roomCache.set(cacheKey, { data: room, timestamp: Date.now() });
+      if (room) {
+        cacheRoomByExternalId(room);
+      }
+      return room;
+    } finally {
+      roomInFlight.delete(cacheKey);
+    }
+  })();
+  roomInFlight.set(cacheKey, fetchPromise);
+  cleanupCache(roomCache, 500, CACHE_TTL_MS);
+  return fetchPromise;
+}
+function getCachedRoomByExternalId(source, channelId) {
+  const key = `${source}:${channelId}`;
+  const cached = externalRoomCache.get(key);
+  const now = Date.now();
+  if (cached && now - cached.timestamp < CACHE_TTL_MS) {
+    return cached.data;
+  }
+  return null;
+}
+function invalidateRoomCacheInternal(roomId) {
+  roomCache.delete(roomId);
+}
+function invalidateRoomCache(agentId, roomId) {
+  invalidateRoomCacheInternal(roomId);
+  invalidateEntitiesCache(agentId, roomId);
+}
+function invalidateRoomCacheByExternalId(source, channelId) {
+  externalRoomCache.delete(`${source}:${channelId}`);
+}
+function getExternalWorldKey(world) {
+  const serverId = world.messageServerId;
+  if (!serverId)
+    return null;
+  return `guild:${serverId}`;
+}
+function cacheWorldByExternalId(world) {
+  const key = getExternalWorldKey(world);
+  if (!key)
+    return;
+  const externalData = {
+    name: world.name,
+    messageServerId: world.messageServerId,
+    metadata: world.metadata
+  };
+  if (world.metadata?.settings) {
+    try {
+      const salt = getSalt2();
+      externalData.settings = unsaltWorldSettings2(world.metadata.settings, salt);
+    } catch {}
+  }
+  externalWorldCache.set(key, { data: externalData, timestamp: Date.now() });
+}
+async function getCachedWorld(runtime, worldId) {
+  const cacheKey = worldId;
+  const cached = worldCache.get(cacheKey);
+  const now = Date.now();
+  if (cached && now - cached.timestamp < CACHE_TTL_MS) {
+    return cached.data;
+  }
+  const inFlight = worldInFlight.get(cacheKey);
+  if (inFlight) {
+    return inFlight;
+  }
+  const fetchPromise = (async () => {
+    try {
+      const world = await withTimeout(runtime.getWorld(worldId), DB_TIMEOUT_MS, null);
+      worldCache.set(cacheKey, { data: world, timestamp: Date.now() });
+      if (world) {
+        cacheWorldByExternalId(world);
+      }
+      return world;
+    } finally {
+      worldInFlight.delete(cacheKey);
+    }
+  })();
+  worldInFlight.set(cacheKey, fetchPromise);
+  cleanupCache(worldCache, 200, CACHE_TTL_MS);
+  return fetchPromise;
+}
+function getCachedSettingsByServerId(serverId) {
+  const key = `guild:${serverId}`;
+  const cached = externalWorldCache.get(key);
+  const now = Date.now();
+  if (cached && now - cached.timestamp < CACHE_TTL_MS && cached.data?.settings) {
+    return cached.data.settings;
+  }
+  return null;
+}
+function hasNoSettings(serverId) {
+  const cached = noSettingsCache.get(serverId);
+  const now = Date.now();
+  if (cached && now - cached.timestamp < NEGATIVE_CACHE_TTL_MS) {
+    return cached.data;
+  }
+  return false;
+}
+function markNoSettings(serverId) {
+  noSettingsCache.set(serverId, { data: true, timestamp: Date.now() });
+}
+function invalidateWorldCache(worldId) {
+  worldCache.delete(worldId);
+  noServerIdCache.delete(worldId);
+}
+function invalidateWorldCacheByServerId(serverId) {
+  externalWorldCache.delete(`guild:${serverId}`);
+  noSettingsCache.delete(serverId);
+}
+function hasNoServerId(worldId) {
+  const cached = noServerIdCache.get(worldId);
+  const now = Date.now();
+  if (cached && now - cached.timestamp < NEGATIVE_CACHE_TTL_MS) {
+    return cached.data;
+  }
+  return false;
+}
+function markNoServerId(worldId) {
+  noServerIdCache.set(worldId, { data: true, timestamp: Date.now() });
+}
+var entitiesCache = new Map;
+var entitiesInFlight = new Map;
+async function getCachedEntitiesForRoom(runtime, roomId) {
+  const cacheKey = `${runtime.agentId}:${roomId}`;
+  const cached = entitiesCache.get(cacheKey);
+  const now = Date.now();
+  if (cached && now - cached.timestamp < CACHE_TTL_MS) {
+    return cached.data;
+  }
+  const inFlight = entitiesInFlight.get(cacheKey);
+  if (inFlight) {
+    return inFlight;
+  }
+  const fetchPromise = (async () => {
+    try {
+      const entities = await withTimeout(runtime.getEntitiesForRoom(roomId, true), DB_TIMEOUT_MS, []);
+      entitiesCache.set(cacheKey, { data: entities, timestamp: Date.now() });
+      return entities;
+    } finally {
+      entitiesInFlight.delete(cacheKey);
+    }
+  })();
+  entitiesInFlight.set(cacheKey, fetchPromise);
+  cleanupCache(entitiesCache, 500, CACHE_TTL_MS);
+  return fetchPromise;
+}
+function invalidateEntitiesCache(agentId, roomId) {
+  const cacheKey = `${agentId}:${roomId}`;
+  entitiesCache.delete(cacheKey);
+}
+var worldSettingsCache = new Map;
+var worldSettingsInFlight = new Map;
+function extractWorldSettings(world) {
+  if (!world) {
+    return null;
+  }
+  if (world.messageServerId) {
+    const cachedSettings = getCachedSettingsByServerId(world.messageServerId);
+    if (cachedSettings) {
+      return cachedSettings;
+    }
+  }
+  if (!world.metadata?.settings) {
+    if (world.messageServerId) {
+      markNoSettings(world.messageServerId);
+    }
+    return null;
+  }
+  const saltedSettings = world.metadata.settings;
+  const salt = getSalt2();
+  const settings = unsaltWorldSettings2(saltedSettings, salt);
+  if (world.messageServerId && settings) {
+    const key = `guild:${world.messageServerId}`;
+    const externalData = {
+      name: world.name,
+      messageServerId: world.messageServerId,
+      metadata: world.metadata,
+      settings
+    };
+    externalWorldCache.set(key, { data: externalData, timestamp: Date.now() });
+  }
+  return settings;
+}
+async function getCachedWorldSettings(runtime, serverId) {
+  const cacheKey = `${runtime.agentId}:${serverId}`;
+  const cached = worldSettingsCache.get(cacheKey);
+  const now = Date.now();
+  if (cached && now - cached.timestamp < CACHE_TTL_MS) {
+    return cached.data;
+  }
+  const inFlight = worldSettingsInFlight.get(cacheKey);
+  if (inFlight) {
+    return inFlight;
+  }
+  const fetchPromise = (async () => {
+    try {
+      const worldId = createUniqueUuid(runtime, serverId);
+      const world = await getCachedWorld(runtime, worldId);
+      const settings = extractWorldSettings(world);
+      worldSettingsCache.set(cacheKey, { data: settings, timestamp: Date.now() });
+      return settings;
+    } finally {
+      worldSettingsInFlight.delete(cacheKey);
+    }
+  })();
+  worldSettingsInFlight.set(cacheKey, fetchPromise);
+  cleanupCache(worldSettingsCache, 200, CACHE_TTL_MS);
+  return fetchPromise;
+}
+function getCacheStats() {
+  return {
+    rooms: roomCache.size,
+    roomsInFlight: roomInFlight.size,
+    worlds: worldCache.size,
+    worldsInFlight: worldInFlight.size,
+    entities: entitiesCache.size,
+    entitiesInFlight: entitiesInFlight.size,
+    worldSettings: worldSettingsCache.size,
+    worldSettingsInFlight: worldSettingsInFlight.size,
+    externalRooms: externalRoomCache.size,
+    externalWorlds: externalWorldCache.size,
+    externalWorldsInFlight: externalWorldInFlight.size,
+    noServerIds: noServerIdCache.size,
+    noSettings: noSettingsCache.size
+  };
+}
+
+// src/providers/character.ts
 var characterProvider = {
   name: "CHARACTER",
   description: "Character information",
-  get: async (runtime, message, state) => {
+  get: async (runtime, message, _state) => {
     const character = runtime.character;
+    const room = message.roomId ? await getCachedRoom(runtime, message.roomId) : null;
+    const isPostFormat = room?.type === ChannelType4.FEED || room?.type === ChannelType4.THREAD;
     const agentName = character.name;
     const bioText = Array.isArray(character.bio) ? character.bio.sort(() => 0.5 - Math.random()).slice(0, 10).join(" ") : character.bio || "";
     const bio = addHeader5(`# About ${character.name}`, bioText);
     const system = character.system ?? "";
     const topicString = character.topics && character.topics.length > 0 ? character.topics[Math.floor(Math.random() * character.topics.length)] : null;
     const topic = topicString || "";
-    const topics = character.topics && character.topics.length > 0 ? `${character.name} is also interested in ${character.topics.filter((topic2) => topic2 !== topicString).sort(() => 0.5 - Math.random()).slice(0, 5).map((topic2, index, array) => {
-      if (index === array.length - 2) {
-        return `${topic2} and `;
+    let topics = "";
+    if (character.topics && character.topics.length > 0) {
+      const filteredTopics = character.topics.filter((t) => t !== topicString);
+      for (let i = filteredTopics.length - 1;i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [filteredTopics[i], filteredTopics[j]] = [filteredTopics[j], filteredTopics[i]];
+      }
+      const selectedTopics = filteredTopics.slice(0, 5);
+      if (selectedTopics.length > 0) {
+        const topicsList = selectedTopics.map((t, index, array) => {
+          if (index === array.length - 2)
+            return `${t} and `;
+          if (index === array.length - 1)
+            return t;
+          return `${t}, `;
+        }).join("");
+        topics = `${character.name} is also interested in ${topicsList}`;
       }
-      if (index === array.length - 1) {
-        return topic2;
-      }
-      return `${topic2}, `;
-    }).join("")}` : "";
+    }
     const adjectiveString = character.adjectives && character.adjectives.length > 0 ? character.adjectives[Math.floor(Math.random() * character.adjectives.length)] : "";
     const adjective = adjectiveString || "";
-    const formattedCharacterPostExamples = !character.postExamples ? "" : character.postExamples.sort(() => 0.5 - Math.random()).map((post) => {
-      const messageString = `${post}`;
-      return messageString;
-    }).slice(0, 50).join(`
+    let characterPostExamples = "";
+    let characterMessageExamples = "";
+    if (isPostFormat) {
+      if (character.postExamples && character.postExamples.length > 0) {
+        const shuffledPosts = [...character.postExamples];
+        for (let i = shuffledPosts.length - 1;i > 0; i--) {
+          const j = Math.floor(Math.random() * (i + 1));
+          [shuffledPosts[i], shuffledPosts[j]] = [shuffledPosts[j], shuffledPosts[i]];
+        }
+        const formattedPosts = shuffledPosts.slice(0, 50).join(`
 `);
-    const characterPostExamples = formattedCharacterPostExamples && formattedCharacterPostExamples.replaceAll(`
-`, "").length > 0 ? addHeader5(`# Example Posts for ${character.name}`, formattedCharacterPostExamples) : "";
-    const formattedCharacterMessageExamples = !character.messageExamples ? "" : character.messageExamples.sort(() => 0.5 - Math.random()).slice(0, 5).map((example) => {
-      const exampleNames = Array.from({ length: 5 }, () => Math.random().toString(36).substring(2, 8));
-      return example.map((message2) => {
-        let messageString = `${message2.name}: ${message2.content.text}${message2.content.action || message2.content.actions ? ` (actions: ${message2.content.action || message2.content.actions?.join(", ")})` : ""}`;
-        exampleNames.forEach((name, index) => {
-          const placeholder = `{{name${index + 1}}}`;
-          messageString = messageString.replaceAll(placeholder, name);
-        });
-        return messageString;
-      }).join(`
+        if (formattedPosts.replaceAll(`
+`, "").length > 0) {
+          characterPostExamples = addHeader5(`# Example Posts for ${character.name}`, formattedPosts);
+        }
+      }
+    } else {
+      if (character.messageExamples && character.messageExamples.length > 0) {
+        const shuffledMessages = [...character.messageExamples];
+        for (let i = shuffledMessages.length - 1;i > 0; i--) {
+          const j = Math.floor(Math.random() * (i + 1));
+          [shuffledMessages[i], shuffledMessages[j]] = [shuffledMessages[j], shuffledMessages[i]];
+        }
+        const formattedMessages = shuffledMessages.slice(0, 5).map((example) => {
+          const exampleNames = Array.from({ length: 5 }, () => Math.random().toString(36).substring(2, 8));
+          return example.map((msg) => {
+            let messageString = `${msg.name}: ${msg.content.text}${msg.content.action || msg.content.actions ? ` (actions: ${msg.content.action || msg.content.actions?.join(", ")})` : ""}`;
+            exampleNames.forEach((name, index) => {
+              const placeholder = `{{name${index + 1}}}`;
+              messageString = messageString.replaceAll(placeholder, name);
+            });
+            return messageString;
+          }).join(`
 `);
-    }).join(`
+        }).join(`
 
 `);
-    const characterMessageExamples = formattedCharacterMessageExamples && formattedCharacterMessageExamples.replaceAll(`
-`, "").length > 0 ? addHeader5(`# Example Conversations for ${character.name}`, formattedCharacterMessageExamples) : "";
-    const room = state.data.room ?? await runtime.getRoom(message.roomId);
-    const isPostFormat = room?.type === ChannelType4.FEED || room?.type === ChannelType4.THREAD;
-    const postDirections = character?.style?.all?.length && character?.style?.all?.length > 0 || character?.style?.post?.length && character?.style?.post?.length > 0 ? addHeader5(`# Post Directions for ${character.name}`, (() => {
-      const all = character?.style?.all || [];
-      const post = character?.style?.post || [];
-      return [...all, ...post].join(`
-`);
-    })()) : "";
-    const messageDirections = character?.style?.all?.length && character?.style?.all?.length > 0 || character?.style?.chat?.length && character?.style?.chat?.length > 0 ? addHeader5(`# Message Directions for ${character.name}`, (() => {
-      const all = character?.style?.all || [];
-      const chat = character?.style?.chat || [];
-      return [...all, ...chat].join(`
-`);
-    })()) : "";
+        if (formattedMessages.replaceAll(`
+`, "").length > 0) {
+          characterMessageExamples = addHeader5(`# Example Conversations for ${character.name}`, formattedMessages);
+        }
+      }
+    }
+    let postDirections = "";
+    let messageDirections = "";
+    if (isPostFormat) {
+      const hasPostStyle = character?.style?.all?.length && character.style.all.length > 0 || character?.style?.post?.length && character.style.post.length > 0;
+      if (hasPostStyle) {
+        const all = character?.style?.all || [];
+        const post = character?.style?.post || [];
+        postDirections = addHeader5(`# Post Directions for ${character.name}`, [...all, ...post].join(`
+`));
+      }
+    } else {
+      const hasChatStyle = character?.style?.all?.length && character.style.all.length > 0 || character?.style?.chat?.length && character.style.chat.length > 0;
+      if (hasChatStyle) {
+        const all = character?.style?.all || [];
+        const chat = character?.style?.chat || [];
+        messageDirections = addHeader5(`# Message Directions for ${character.name}`, [...all, ...chat].join(`
+`));
+      }
+    }
     const directions = isPostFormat ? postDirections : messageDirections;
     const examples = isPostFormat ? characterPostExamples : characterMessageExamples;
     const values = {
@@ -5788,6 +6188,7 @@ var characterProvider = {
 // src/providers/choice.ts
 var choiceProvider = {
   name: "CHOICE",
+  dynamic: true,
   get: async (runtime, message, _state) => {
     try {
       const pendingTasks = await runtime.getTasks({
@@ -5878,23 +6279,68 @@ var choiceProvider = {
   }
 };
 // src/providers/entities.ts
-import { addHeader as addHeader6, formatEntities, getEntityDetails as getEntityDetails2 } from "@elizaos/core";
+import { addHeader as addHeader6, formatEntities } from "@elizaos/core";
+var getEntityDetailsOptimized = async (runtime, roomId, room, cachedEntities) => {
+  const roomEntities = cachedEntities ?? await getCachedEntitiesForRoom(runtime, roomId);
+  const uniqueEntities = new Map;
+  for (const entity of roomEntities) {
+    if (!entity.id || uniqueEntities.has(entity.id))
+      continue;
+    const allData = {};
+    for (const component of entity.components || []) {
+      Object.assign(allData, component.data);
+    }
+    const mergedData = {};
+    for (const [key, value] of Object.entries(allData)) {
+      if (!mergedData[key]) {
+        mergedData[key] = value;
+        continue;
+      }
+      if (Array.isArray(mergedData[key]) && Array.isArray(value)) {
+        mergedData[key] = [...new Set([...mergedData[key], ...value])];
+      } else if (typeof mergedData[key] === "object" && typeof value === "object") {
+        mergedData[key] = { ...mergedData[key], ...value };
+      }
+    }
+    uniqueEntities.set(entity.id, {
+      id: entity.id,
+      agentId: entity.agentId,
+      name: room?.source ? entity.metadata[room.source]?.name || entity.names[0] : entity.names[0],
+      names: entity.names,
+      metadata: { ...mergedData, ...entity.metadata }
+    });
+  }
+  return Array.from(uniqueEntities.values());
+};
 var entitiesProvider = {
   name: "ENTITIES",
   description: "People in the current conversation",
   dynamic: true,
-  get: async (runtime, message) => {
+  get: async (runtime, message, _state) => {
     const { roomId, entityId } = message;
-    const entitiesData = await getEntityDetails2({ runtime, roomId });
+    if (!roomId) {
+      return { data: {}, values: { entities: "", senderName: "" }, text: "" };
+    }
+    const room = await getCachedRoom(runtime, roomId);
+    const cachedEntities = await getCachedEntitiesForRoom(runtime, roomId);
+    const entitiesData = await getEntityDetailsOptimized(runtime, roomId, room, cachedEntities);
+    const entityMap = new Map;
+    for (const entity of entitiesData) {
+      if (entity.id) {
+        entityMap.set(entity.id, entity);
+      }
+    }
+    const senderName = entityMap.get(entityId)?.names[0];
     const formattedEntities = formatEntities({ entities: entitiesData ?? [] });
-    const senderName = entitiesData?.find((entity) => entity.id === entityId)?.names[0];
     const entities = formattedEntities && formattedEntities.length > 0 ? addHeader6("# People in the Room", formattedEntities) : "";
     const data = {
       entitiesData,
-      senderName
+      senderName,
+      room
     };
     const values = {
-      entities
+      entities,
+      senderName
     };
     return {
       data,
@@ -5905,39 +6351,61 @@ var entitiesProvider = {
 };
 // src/providers/evaluators.ts
 var import_unique_names_generator = __toESM(require_dist(), 1);
-import { addHeader as addHeader7 } from "@elizaos/core";
+import { addHeader as addHeader7, logger as logger13 } from "@elizaos/core";
 function formatEvaluatorNames(evaluators) {
   return evaluators.map((evaluator) => `'${evaluator.name}'`).join(`,
 `);
 }
 function formatEvaluatorExamples(evaluators) {
   return evaluators.map((evaluator) => {
-    return evaluator.examples.map((example) => {
+    const validExamples = (evaluator.examples || []).filter((example) => {
+      if (!example) {
+        logger13.error({ evaluator: evaluator.name }, "Evaluator has null/undefined example - check evaluator implementation");
+        return false;
+      }
+      if (!example.prompt) {
+        logger13.error({ evaluator: evaluator.name }, 'Evaluator example missing required "prompt" field - check evaluator implementation');
+        return false;
+      }
+      if (!example.messages) {
+        logger13.error({ evaluator: evaluator.name }, 'Evaluator example missing required "messages" field - check evaluator implementation');
+        return false;
+      }
+      return true;
+    });
+    return validExamples.map((example) => {
       const exampleNames = Array.from({ length: 5 }, () => import_unique_names_generator.uniqueNamesGenerator({ dictionaries: [import_unique_names_generator.names] }));
       let formattedPrompt = example.prompt;
-      let formattedOutcome = example.outcome;
+      let formattedOutcome = example.outcome || "";
       exampleNames.forEach((name, index) => {
         const placeholder = `{{name${index + 1}}}`;
         formattedPrompt = formattedPrompt.replaceAll(placeholder, name);
-        formattedOutcome = formattedOutcome.replaceAll(placeholder, name);
+        if (formattedOutcome) {
+          formattedOutcome = formattedOutcome.replaceAll(placeholder, name);
+        }
       });
-      const formattedMessages = example.messages.map((message) => {
+      const formattedMessages = (example.messages || []).map((message) => {
+        if (!message?.name || !message?.content?.text) {
+          logger13.error({ evaluator: evaluator.name }, 'Evaluator example message missing "name" or "content.text" - check evaluator implementation');
+          return null;
+        }
         let messageString = `${message.name}: ${message.content.text}`;
         exampleNames.forEach((name, index) => {
           const placeholder = `{{name${index + 1}}}`;
           messageString = messageString.replaceAll(placeholder, name);
         });
         return messageString + (message.content.action || message.content.actions ? ` (${message.content.action || message.content.actions?.join(", ")})` : "");
-      }).join(`
+      }).filter(Boolean).join(`
 `);
+      const outcomeSection = formattedOutcome ? `
+
+Outcome:
+${formattedOutcome}` : "";
       return `Prompt:
 ${formattedPrompt}
 
 Messages:
-${formattedMessages}
-
-Outcome:
-${formattedOutcome}`;
+${formattedMessages}${outcomeSection}`;
     }).join(`
 
 `);
@@ -5955,14 +6423,27 @@ var evaluatorsProvider = {
   private: true,
   get: async (runtime, message, state) => {
     const evaluatorPromises = runtime.evaluators.map(async (evaluator) => {
-      const result = await evaluator.validate(runtime, message, state);
-      if (result) {
-        return evaluator;
-      }
+      try {
+        const result = await evaluator.validate(runtime, message, state);
+        if (result) {
+          return evaluator;
+        }
+      } catch (e) {}
       return null;
     });
     const resolvedEvaluators = await Promise.all(evaluatorPromises);
-    const evaluatorsData = resolvedEvaluators.filter(Boolean);
+    const evaluatorsData = resolvedEvaluators.filter((e) => e !== null);
+    if (evaluatorsData.length === 0) {
+      return {
+        values: {
+          evaluatorsData: [],
+          evaluators: "",
+          evaluatorNames: "",
+          evaluatorExamples: ""
+        },
+        text: ""
+      };
+    }
     const evaluators = evaluatorsData.length > 0 ? addHeader7("# Available Evaluators", formatEvaluators(evaluatorsData)) : "";
     const evaluatorNames = evaluatorsData.length > 0 ? formatEvaluatorNames(evaluatorsData) : "";
     const evaluatorExamples = evaluatorsData.length > 0 ? addHeader7("# Evaluator Examples", formatEvaluatorExamples(evaluatorsData)) : "";
@@ -6070,7 +6551,7 @@ var providersProvider = {
   name: "PROVIDERS",
   description: "List of all data providers the agent can use to get additional information",
   get: async (runtime, _message, _state) => {
-    const allProviders = runtime.providers;
+    const allProviders = runtime.providers || [];
     const dynamicProviders = allProviders.filter((provider) => provider.dynamic === true);
     const dynamicDescriptions = dynamicProviders.map((provider) => {
       return `- **${provider.name}**: ${provider.description || "No description available"}`;
@@ -6112,8 +6593,8 @@ import {
   ChannelType as ChannelType5,
   formatMessages,
   formatPosts,
-  getEntityDetails as getEntityDetails3,
-  logger as logger12
+  parseBooleanFromText as parseBooleanFromText2,
+  logger as logger14
 } from "@elizaos/core";
 var getRecentInteractions = async (runtime, sourceEntityId, targetEntityId, excludeRoomId) => {
   const rooms = await runtime.getRoomsForParticipants([sourceEntityId, targetEntityId]);
@@ -6123,39 +6604,92 @@ var getRecentInteractions = async (runtime, sourceEntityId, targetEntityId, excl
     limit: 20
   });
 };
+var getEntityDetailsWithRoom = async (runtime, roomId, room) => {
+  const roomEntities = await runtime.getEntitiesForRoom(roomId, true);
+  const uniqueEntities = new Map;
+  for (const entity of roomEntities) {
+    if (!entity.id || uniqueEntities.has(entity.id))
+      continue;
+    const allData = {};
+    for (const component of entity.components || []) {
+      Object.assign(allData, component.data);
+    }
+    const mergedData = {};
+    for (const [key, value] of Object.entries(allData)) {
+      if (!mergedData[key]) {
+        mergedData[key] = value;
+        continue;
+      }
+      if (Array.isArray(mergedData[key]) && Array.isArray(value)) {
+        mergedData[key] = [...new Set([...mergedData[key], ...value])];
+      } else if (typeof mergedData[key] === "object" && typeof value === "object") {
+        mergedData[key] = { ...mergedData[key], ...value };
+      }
+    }
+    const entityId = entity.id;
+    uniqueEntities.set(entityId, {
+      id: entityId,
+      agentId: entity.agentId,
+      name: room?.source ? entity.metadata[room.source]?.name || entity.names[0] : entity.names[0],
+      names: entity.names,
+      metadata: { ...mergedData, ...entity.metadata }
+    });
+  }
+  return Array.from(uniqueEntities.values());
+};
 var recentMessagesProvider = {
   name: "RECENT_MESSAGES",
   description: "Recent messages, interactions and other memories",
   position: 100,
-  get: async (runtime, message) => {
+  get: async (runtime, message, state) => {
+    const { roomId } = message;
+    if (!roomId) {
+      logger14.warn({ src: "plugin:bootstrap:provider:recent-messages", agentId: runtime.agentId }, "No roomId in message");
+      return { data: {}, values: {}, text: "" };
+    }
     try {
-      const { roomId } = message;
       const conversationLength = runtime.getConversationLength();
-      const [entitiesData, room, recentMessagesData, recentInteractionsData] = await Promise.all([
-        getEntityDetails3({ runtime, roomId }),
-        runtime.getRoom(roomId),
+      const limitMessagesSetting = runtime.getSetting("LIMIT_TO_LAST_MESSAGE");
+      const limitToLastMessage = limitMessagesSetting === true || (typeof limitMessagesSetting === "string" ? parseBooleanFromText2(limitMessagesSetting) : limitMessagesSetting != null ? parseBooleanFromText2(String(limitMessagesSetting)) : false);
+      const effectiveConversationLength = limitToLastMessage ? 1 : conversationLength;
+      const entitiesProviderResult = state?.data?.providers?.ENTITIES;
+      const entitiesProviderData = entitiesProviderResult && typeof entitiesProviderResult === "object" && "data" in entitiesProviderResult ? entitiesProviderResult.data : undefined;
+      const cachedRoom = entitiesProviderData?.room;
+      const cachedEntities = Array.isArray(entitiesProviderData?.entitiesData) ? entitiesProviderData.entitiesData : undefined;
+      const [room, recentMessagesData, recentInteractionsData] = await Promise.all([
+        cachedRoom ? Promise.resolve(cachedRoom) : runtime.getRoom(roomId),
         runtime.getMemories({
           tableName: "messages",
           roomId,
-          count: conversationLength,
+          count: effectiveConversationLength,
           unique: false
         }),
         message.entityId !== runtime.agentId ? getRecentInteractions(runtime, message.entityId, runtime.agentId, roomId) : Promise.resolve([])
       ]);
+      const entitiesData = cachedEntities ?? await getEntityDetailsWithRoom(runtime, roomId, room);
+      const entityMap = new Map;
+      for (const entity of entitiesData) {
+        if (entity.id) {
+          entityMap.set(entity.id, entity);
+        }
+      }
       const actionResultMessages = recentMessagesData.filter((msg) => msg.content?.type === "action_result" && msg.metadata?.type === "action_result");
       const dialogueMessages = recentMessagesData.filter((msg) => !(msg.content?.type === "action_result" && msg.metadata?.type === "action_result"));
       const isPostFormat = room?.type ? room.type === ChannelType5.FEED || room.type === ChannelType5.THREAD : false;
-      const [formattedRecentMessages, formattedRecentPosts] = await Promise.all([
-        formatMessages({
-          messages: dialogueMessages,
-          entities: entitiesData
-        }),
-        formatPosts({
+      let formattedRecentMessages = "";
+      let formattedRecentPosts = "";
+      if (isPostFormat) {
+        formattedRecentPosts = formatPosts({
           messages: dialogueMessages,
           entities: entitiesData,
           conversationHeader: false
-        })
-      ]);
+        });
+      } else {
+        formattedRecentMessages = formatMessages({
+          messages: dialogueMessages,
+          entities: entitiesData
+        });
+      }
       let actionResultsText = "";
       if (actionResultMessages.length > 0) {
         const groupedByRun = new Map;
@@ -6179,9 +6713,8 @@ var recentMessagesProvider = {
             const text2 = mem.content?.text || "";
             const error = mem.content?.error || "";
             let memText = `  - ${actionName} (${status})`;
-            if (planStep) {
+            if (planStep)
               memText += ` [${planStep}]`;
-            }
             if (error) {
               memText += `: Error - ${error}`;
             } else if (text2 && text2 !== `Executed action: ${actionName}`) {
@@ -6220,39 +6753,36 @@ ${runText}`;
       let recentMessage = "No recent message available.";
       if (dialogueMessages.length > 0) {
         const mostRecentMessage = [...dialogueMessages].sort((a, b) => (b.createdAt || 0) - (a.createdAt || 0))[0];
-        const formattedSingleMessage = formatMessages({
-          messages: [mostRecentMessage],
-          entities: entitiesData
-        });
-        if (formattedSingleMessage) {
-          recentMessage = formattedSingleMessage;
+        const senderEntity = entityMap.get(mostRecentMessage.entityId);
+        const senderName = senderEntity?.names[0] || "Unknown User";
+        const messageText = mostRecentMessage.content?.text || "";
+        const messageThought = mostRecentMessage.content?.thought;
+        if (messageText || messageThought) {
+          const parts = [];
+          if (messageText)
+            parts.push(`${senderName}: ${messageText}`);
+          if (messageThought)
+            parts.push(`(${senderName}'s internal thought: ${messageThought})`);
+          recentMessage = parts.join(`
+`);
         }
       }
       const metaData = message.metadata;
-      const senderName = entitiesData.find((entity) => entity.id === message.entityId)?.names[0] || metaData?.entityName || "Unknown User";
+      const currentSenderName = entityMap.get(message.entityId)?.names[0] || metaData?.entityName || "Unknown User";
       const receivedMessageContent = message.content.text;
       const hasReceivedMessage = !!receivedMessageContent?.trim();
-      const receivedMessageHeader = hasReceivedMessage ? addHeader9("# Received Message", `${senderName}: ${receivedMessageContent}`) : "";
-      const focusHeader = hasReceivedMessage ? addHeader9("# Focus your response", `You are replying to the above message from **${senderName}**. Keep your answer relevant to that message. Do not repeat earlier replies unless the sender asks again.`) : "";
-      const interactionEntityMap = new Map;
+      const receivedMessageHeader = hasReceivedMessage ? addHeader9("# Received Message", `${currentSenderName}: ${receivedMessageContent}`) : "";
+      const focusHeader = hasReceivedMessage ? addHeader9("# Focus your response", `You are replying to the above message from **${currentSenderName}**. Keep your answer relevant to that message. Do not repeat earlier replies unless the sender asks again.`) : "";
+      const interactionEntityMap = new Map(entityMap);
       if (recentInteractionsData.length > 0) {
-        const uniqueEntityIds = [
-          ...new Set(recentInteractionsData.map((message2) => message2.entityId).filter((id) => id !== runtime.agentId))
+        const missingEntityIds = [
+          ...new Set(recentInteractionsData.map((msg) => msg.entityId).filter((id) => id !== runtime.agentId && !entityMap.has(id)))
         ];
-        const uniqueEntityIdSet = new Set(uniqueEntityIds);
-        const entitiesDataIdSet = new Set;
-        entitiesData.forEach((entity) => {
-          if (uniqueEntityIdSet.has(entity.id)) {
-            interactionEntityMap.set(entity.id, entity);
-            entitiesDataIdSet.add(entity.id);
-          }
-        });
-        const remainingEntityIds = uniqueEntityIds.filter((id) => !entitiesDataIdSet.has(id));
-        if (remainingEntityIds.length > 0) {
-          const entities = await Promise.all(remainingEntityIds.map((entityId) => runtime.getEntityById(entityId)));
+        if (missingEntityIds.length > 0) {
+          const entities = await Promise.all(missingEntityIds.map((entityId) => runtime.getEntityById(entityId)));
           entities.forEach((entity, index) => {
             if (entity) {
-              interactionEntityMap.set(remainingEntityIds[index], entity);
+              interactionEntityMap.set(missingEntityIds[index], entity);
             }
           });
         }
@@ -6318,11 +6848,7 @@ ${runText}`;
         text
       };
     } catch (error) {
-      logger12.error({
-        src: "plugin:bootstrap:provider:recent_messages",
-        agentId: runtime.agentId,
-        error: error instanceof Error ? error.message : String(error)
-      }, "Error in recentMessagesProvider");
+      logger14.error({ src: "plugin:bootstrap:provider:recent_messages", agentId: runtime.agentId, error: error instanceof Error ? error.message : String(error) }, "Error in recentMessagesProvider");
       return {
         data: {
           recentMessages: [],
@@ -6343,6 +6869,16 @@ ${runText}`;
   }
 };
 // src/providers/relationships.ts
+function csvEscape(value) {
+  if (value === null || value === undefined)
+    return "";
+  const str = String(value);
+  if (str.includes(",") || str.includes('"') || str.includes(`
+`)) {
+    return `"${str.replace(/"/g, '""')}"`;
+  }
+  return str;
+}
 async function formatRelationships(runtime, relationships) {
   const sortedRelationships = relationships.filter((rel) => rel.metadata?.interactions).sort((a, b) => (b.metadata?.interactions || 0) - (a.metadata?.interactions || 0)).slice(0, 30);
   if (sortedRelationships.length === 0) {
@@ -6356,23 +6892,18 @@ async function formatRelationships(runtime, relationships) {
       entityMap.set(uniqueEntityIds[index], entity);
     }
   });
-  const formatMetadata = (metadata) => {
-    return JSON.stringify(Object.entries(metadata).map(([key, value]) => `${key}: ${typeof value === "object" ? JSON.stringify(value) : value}`).join(`
-`));
-  };
-  const formattedRelationships = sortedRelationships.map((rel) => {
+  const rows = ["name,interactions,tags"];
+  for (const rel of sortedRelationships) {
     const targetEntityId = rel.targetEntityId;
     const entity = entityMap.get(targetEntityId);
-    if (!entity) {
-      return null;
-    }
-    const names2 = entity.names.join(" aka ");
-    return `${names2}
-${rel.tags ? rel.tags.join(", ") : ""}
-${formatMetadata(entity.metadata)}
-`;
-  }).filter(Boolean);
-  return formattedRelationships.join(`
+    if (!entity)
+      continue;
+    const name = entity.names[0] || "Unknown";
+    const interactions = rel.metadata?.interactions || 0;
+    const tags = rel.tags?.join(";") || "";
+    rows.push(`${csvEscape(name)},${interactions},${csvEscape(tags)}`);
+  }
+  return rows.join(`
 `);
 }
 var relationshipsProvider = {
@@ -6406,6 +6937,8 @@ var relationshipsProvider = {
         text: "No relationships found."
       };
     }
+    const senderName = message.content.senderName || message.content.name || "user";
+    const header = `# Relationships (${relationships.length}) - ${senderName}'s connections`;
     return {
       data: {
         relationships: formattedRelationships
@@ -6413,7 +6946,7 @@ var relationshipsProvider = {
       values: {
         relationships: formattedRelationships
       },
-      text: `# ${runtime.character.name} has observed ${message.content.senderName || message.content.name} interacting with these people:
+      text: `${header}
 ${formattedRelationships}`
     };
   }
@@ -6421,167 +6954,151 @@ ${formattedRelationships}`
 // src/providers/roles.ts
 import {
   ChannelType as ChannelType6,
-  logger as logger13
+  createUniqueUuid as createUniqueUuid2,
+  logger as logger15
 } from "@elizaos/core";
+var NO_ROLES_RESULT = {
+  data: { roles: [] },
+  values: { roles: "No role information available for this server." },
+  text: "No role information available for this server."
+};
 var roleProvider = {
   name: "ROLES",
   description: "Roles in the server, default are OWNER, ADMIN and MEMBER (as well as NONE)",
-  get: async (runtime, message, state) => {
-    const room = state.data.room ?? await runtime.getRoom(message.roomId);
+  get: async (runtime, message, _state) => {
+    if (!message.roomId) {
+      return NO_ROLES_RESULT;
+    }
+    const room = await getCachedRoom(runtime, message.roomId);
     if (!room) {
       throw new Error("No room found");
     }
     if (room.type !== ChannelType6.GROUP) {
       return {
-        data: {
-          roles: []
-        },
+        data: { roles: [] },
         values: {
           roles: "No access to role information in DMs, the role provider is only available in group scenarios."
         },
         text: "No access to role information in DMs, the role provider is only available in group scenarios."
       };
     }
-    const worldId = room.worldId;
-    if (!worldId) {
-      throw new Error("No world ID found for room");
-    }
-    logger13.info({ src: "plugin:bootstrap:provider:roles", agentId: runtime.agentId, worldId }, "Using world ID");
-    const world = await runtime.getWorld(worldId);
-    if (!world || !world.metadata?.ownership?.ownerId) {
-      logger13.info({ src: "plugin:bootstrap:provider:roles", agentId: runtime.agentId, worldId }, "No ownership data found for world, initializing empty role hierarchy");
+    const serverId = room.serverId ?? room.messageServerId;
+    if (!serverId) {
+      logger15.warn({ src: "plugin:bootstrap:provider:roles", agentId: runtime.agentId, roomId: room.id }, "No server ID found for room");
       return {
-        data: {
-          roles: []
-        },
-        values: {
-          roles: "No role information available for this server."
-        },
-        text: "No role information available for this server."
+        data: { roles: [] },
+        values: { roles: "No role information available - server ID not found." },
+        text: "No role information available - server ID not found."
       };
     }
+    logger15.info({ src: "plugin:bootstrap:provider:roles", agentId: runtime.agentId, serverId }, "Using server ID");
+    const worldId = createUniqueUuid2(runtime, serverId);
+    const world = await getCachedWorld(runtime, worldId);
+    if (!world || !world.metadata?.ownership?.ownerId) {
+      logger15.info({ src: "plugin:bootstrap:provider:roles", agentId: runtime.agentId, serverId }, "No ownership data found for server, initializing empty role hierarchy");
+      return NO_ROLES_RESULT;
+    }
     const roles = world.metadata.roles || {};
-    if (Object.keys(roles).length === 0) {
-      logger13.info({ src: "plugin:bootstrap:provider:roles", agentId: runtime.agentId, worldId }, "No roles found for world");
-      return {
-        data: {
-          roles: []
-        },
-        values: {
-          roles: "No role information available for this server."
-        },
-        text: "No role information available for this server."
-      };
+    const entityIds = Object.keys(roles);
+    if (entityIds.length === 0) {
+      logger15.info({ src: "plugin:bootstrap:provider:roles", agentId: runtime.agentId, serverId }, "No roles found for server");
+      return NO_ROLES_RESULT;
     }
-    logger13.info({
-      src: "plugin:bootstrap:provider:roles",
-      agentId: runtime.agentId,
-      roleCount: Object.keys(roles).length
-    }, "Found roles");
+    logger15.info({ src: "plugin:bootstrap:provider:roles", agentId: runtime.agentId, roleCount: entityIds.length }, "Found roles");
+    const entities = await runtime.getEntitiesByIds(entityIds);
+    const entityMap = new Map;
+    if (entities) {
+      for (const entity of entities) {
+        if (entity.id) {
+          entityMap.set(entity.id, entity);
+        }
+      }
+    }
+    const seenUsernames = new Set;
     const owners = [];
     const admins = [];
     const members = [];
-    for (const entityId of Object.keys(roles)) {
+    for (const entityId of entityIds) {
       const userRole = roles[entityId];
-      const user = await runtime.getEntityById(entityId);
+      const user = entityMap.get(entityId);
       const name = user?.metadata?.name;
       const username = user?.metadata?.username;
-      const names2 = user?.names;
-      if (owners.some((owner) => owner.username === username) || admins.some((admin) => admin.username === username) || members.some((member) => member.username === username)) {
+      const userNames = user?.names;
+      if (!name || !username || !userNames) {
+        logger15.warn({ src: "plugin:bootstrap:provider:roles", agentId: runtime.agentId, entityId }, "User has no name or username, skipping");
         continue;
       }
-      if (!name || !username || !names2) {
-        logger13.warn({ src: "plugin:bootstrap:provider:roles", agentId: runtime.agentId, entityId }, "User has no name or username, skipping");
+      if (seenUsernames.has(username)) {
         continue;
       }
+      seenUsernames.add(username);
+      const userData = { name, username, names: userNames };
       switch (userRole) {
         case "OWNER":
-          owners.push({ name, username, names: names2 });
+          owners.push(userData);
           break;
         case "ADMIN":
-          admins.push({ name, username, names: names2 });
+          admins.push(userData);
           break;
         default:
-          members.push({ name, username, names: names2 });
+          members.push(userData);
           break;
       }
     }
-    let response = `# Server Role Hierarchy
-
-`;
+    if (owners.length === 0 && admins.length === 0 && members.length === 0) {
+      return NO_ROLES_RESULT;
+    }
+    const parts = [`# Server Role Hierarchy
+`];
     if (owners.length > 0) {
-      response += `## Owners
-`;
-      owners.forEach((owner) => {
-        response += `${owner.name} (${owner.names.join(", ")})
-`;
-      });
-      response += `
-`;
+      parts.push("## Owners");
+      for (const owner of owners) {
+        parts.push(`${owner.name} (${owner.names.join(", ")})`);
+      }
+      parts.push("");
     }
     if (admins.length > 0) {
-      response += `## Administrators
-`;
-      admins.forEach((admin) => {
-        response += `${admin.name} (${admin.names.join(", ")}) (${admin.username})
-`;
-      });
-      response += `
-`;
+      parts.push("## Administrators");
+      for (const admin of admins) {
+        parts.push(`${admin.name} (${admin.names.join(", ")}) (${admin.username})`);
+      }
+      parts.push("");
     }
     if (members.length > 0) {
-      response += `## Members
-`;
-      members.forEach((member) => {
-        response += `${member.name} (${member.names.join(", ")}) (${member.username})
-`;
-      });
-    }
-    if (owners.length === 0 && admins.length === 0 && members.length === 0) {
-      return {
-        data: {
-          roles: []
-        },
-        values: {
-          roles: "No role information available for this server."
-        },
-        text: "No role information available for this server."
-      };
+      parts.push("## Members");
+      for (const member of members) {
+        parts.push(`${member.name} (${member.names.join(", ")}) (${member.username})`);
+      }
     }
+    const response = parts.join(`
+`);
     return {
-      data: {
-        roles: response
-      },
-      values: {
-        roles: response
-      },
+      data: { roles: response },
+      values: { roles: response },
       text: response
     };
   }
 };
 // src/providers/settings.ts
 import {
+  asUUID as asUUID2,
   ChannelType as ChannelType7,
   findWorldsForOwner as findWorldsForOwner2,
-  getSalt as getSalt2,
-  logger as logger14,
-  unsaltWorldSettings as unsaltWorldSettings2
+  logger as logger16
 } from "@elizaos/core";
+var DB_TIMEOUT_MS2 = 5000;
 var formatSettingValue = (setting, isOnboarding) => {
-  if (setting.value === null) {
+  if (setting.value === null)
     return "Not set";
-  }
-  if (setting.secret && !isOnboarding) {
+  if (setting.secret && !isOnboarding)
     return "****************";
-  }
   return String(setting.value);
 };
 function generateStatusMessage(runtime, worldSettings, isOnboarding, state) {
   try {
     const formattedSettings = Object.entries(worldSettings).map(([key, setting]) => {
-      if (typeof setting !== "object" || !setting.name) {
+      if (typeof setting !== "object" || !setting.name)
         return null;
-      }
       const description = setting.description || "";
       const usageDescription = setting.usageDescription || "";
       if (setting.visibleIf && !setting.visibleIf(worldSettings)) {
@@ -6646,11 +7163,7 @@ ${requiredUnconfigured > 0 ? `IMPORTANT!: ${requiredUnconfigured} required setti
 
 `)}`;
   } catch (error) {
-    logger14.error({
-      src: "plugin:bootstrap:provider:settings",
-      agentId: runtime.agentId,
-      error: error instanceof Error ? error.message : String(error)
-    }, "Error generating status message");
+    logger16.error({ src: "plugin:bootstrap:provider:settings", agentId: runtime.agentId, error: error instanceof Error ? error.message : String(error) }, "Error generating status message");
     return "Error generating configuration status.";
   }
 }
@@ -6658,20 +7171,17 @@ var settingsProvider = {
   name: "SETTINGS",
   description: "Current settings for the server",
   get: async (runtime, message, state) => {
+    if (!message.roomId) {
+      return {
+        data: { settings: [] },
+        values: { settings: "Error: No room ID in message" },
+        text: "Error: No room ID in message"
+      };
+    }
     try {
-      const [room, userWorlds] = await Promise.all([
-        runtime.getRoom(message.roomId),
-        findWorldsForOwner2(runtime, message.entityId)
-      ]).catch((error) => {
-        logger14.error({
-          src: "plugin:bootstrap:provider:settings",
-          agentId: runtime.agentId,
-          error: error instanceof Error ? error.message : String(error)
-        }, "Error fetching initial data");
-        throw new Error("Failed to retrieve room or user world information");
-      });
+      const room = await getCachedRoom(runtime, message.roomId);
       if (!room) {
-        logger14.error({ src: "plugin:bootstrap:provider:settings", agentId: runtime.agentId }, "No room found for settings provider");
+        logger16.error({ src: "plugin:bootstrap:provider:settings", agentId: runtime.agentId }, "No room found for settings provider");
         return {
           data: {
             settings: []
@@ -6683,7 +7193,7 @@ var settingsProvider = {
         };
       }
       if (!room.worldId) {
-        logger14.debug({ src: "plugin:bootstrap:provider:settings", agentId: runtime.agentId }, "No world found for settings provider -- settings provider will be skipped");
+        logger16.debug({ src: "plugin:bootstrap:provider:settings", agentId: runtime.agentId }, "No world found for settings provider -- settings provider will be skipped");
         return {
           data: {
             settings: []
@@ -6694,13 +7204,13 @@ var settingsProvider = {
           text: "Room does not have a worldId -- settings provider will be skipped"
         };
       }
-      const type = room.type;
-      const isOnboarding = type === ChannelType7.DM;
+      const isOnboarding = room.type === ChannelType7.DM;
       let world = null;
       let serverId = undefined;
       let worldSettings = null;
       if (isOnboarding) {
-        world = userWorlds?.find((world2) => world2.metadata?.settings !== undefined);
+        const userWorlds = await withTimeout(findWorldsForOwner2(runtime, message.entityId), DB_TIMEOUT_MS2, null);
+        world = userWorlds?.find((w) => w.metadata?.settings !== undefined);
         if (!world && userWorlds && userWorlds.length > 0) {
           world = userWorlds[0];
           if (!world.metadata) {
@@ -6708,58 +7218,68 @@ var settingsProvider = {
           }
           world.metadata.settings = {};
           await runtime.updateWorld(world);
-          logger14.info({
-            src: "plugin:bootstrap:provider:settings",
-            agentId: runtime.agentId,
-            worldId: world.id
-          }, "Initialized settings for user world");
+          logger16.info({ src: "plugin:bootstrap:provider:settings", agentId: runtime.agentId, worldId: world.id }, "Initialized settings for user world");
         }
         if (!world) {
-          logger14.error({ src: "plugin:bootstrap:provider:settings", agentId: runtime.agentId }, "No world found for user during onboarding");
+          logger16.error({ src: "plugin:bootstrap:provider:settings", agentId: runtime.agentId }, "No world found for user during onboarding");
           throw new Error("No server ownership found for onboarding");
         }
         serverId = world.messageServerId;
-        if (world.metadata?.settings) {
-          const salt = getSalt2();
-          worldSettings = unsaltWorldSettings2(world.metadata.settings, salt);
+        if (serverId) {
+          worldSettings = extractWorldSettings(world);
         }
       } else {
-        try {
-          world = await runtime.getWorld(room.worldId);
-          if (!world) {
-            logger14.error({
-              src: "plugin:bootstrap:provider:settings",
-              agentId: runtime.agentId,
-              worldId: room.worldId
-            }, "No world found for room");
-            throw new Error(`No world found for room ${room.worldId}`);
+        const worldIdTyped = asUUID2(room.worldId);
+        if (hasNoServerId(worldIdTyped)) {
+          logger16.debug({ src: "plugin:bootstrap:provider:settings", agentId: runtime.agentId, worldId: room.worldId }, "Skipping world with known no serverId (cached)");
+          return {
+            data: { settings: [] },
+            values: { settings: "Error: No configuration access" },
+            text: "Error: No configuration access"
+          };
+        }
+        const roomServerId = room.messageServerId ?? room.serverId;
+        if (roomServerId) {
+          if (hasNoSettings(roomServerId)) {
+            logger16.debug({ src: "plugin:bootstrap:provider:settings", agentId: runtime.agentId, serverId: roomServerId }, "Skipping server with known no settings (cross-agent cache)");
+            return {
+              data: { settings: [] },
+              values: { settings: "Configuration has not been completed yet." },
+              text: "Configuration has not been completed yet."
+            };
           }
-          serverId = world.messageServerId;
-          if (world.metadata?.settings) {
-            const salt = getSalt2();
-            worldSettings = unsaltWorldSettings2(world.metadata.settings, salt);
-          } else if (!serverId) {
-            logger14.debug({
-              src: "plugin:bootstrap:provider:settings",
-              agentId: runtime.agentId,
-              worldId: room.worldId
-            }, "No server ID or settings found for world");
+          const cachedSettings = getCachedSettingsByServerId(roomServerId);
+          if (cachedSettings) {
+            logger16.debug({ src: "plugin:bootstrap:provider:settings", agentId: runtime.agentId, serverId: roomServerId }, "Using cross-agent cached settings");
+            serverId = roomServerId;
+            worldSettings = cachedSettings;
+          }
+        }
+        if (!worldSettings) {
+          try {
+            world = await getCachedWorld(runtime, worldIdTyped);
+            if (!world) {
+              logger16.error({ src: "plugin:bootstrap:provider:settings", agentId: runtime.agentId, worldId: room.worldId }, "No world found for room");
+              throw new Error(`No world found for room ${room.worldId}`);
+            }
+            serverId = world.messageServerId;
+            if (serverId) {
+              worldSettings = extractWorldSettings(world);
+              if (!worldSettings) {
+                markNoSettings(serverId);
+              }
+            } else {
+              markNoServerId(worldIdTyped);
+              logger16.debug({ src: "plugin:bootstrap:provider:settings", agentId: runtime.agentId, worldId: room.worldId }, "No server ID found for world (marked for cache)");
+            }
+          } catch (error) {
+            logger16.error({ src: "plugin:bootstrap:provider:settings", agentId: runtime.agentId, error: error instanceof Error ? error.message : String(error) }, "Error processing world data");
+            throw new Error("Failed to process world information");
           }
-        } catch (error) {
-          logger14.error({
-            src: "plugin:bootstrap:provider:settings",
-            agentId: runtime.agentId,
-            error: error instanceof Error ? error.message : String(error)
-          }, "Error processing world data");
-          throw new Error("Failed to process world information");
         }
       }
       if (!serverId) {
-        logger14.info({
-          src: "plugin:bootstrap:provider:settings",
-          agentId: runtime.agentId,
-          entityId: message.entityId
-        }, "No server ownership found for user after recovery attempt");
+        logger16.info({ src: "plugin:bootstrap:provider:settings", agentId: runtime.agentId, entityId: message.entityId }, "No server ownership found for user after recovery attempt");
         return isOnboarding ? {
           data: {
             settings: []
@@ -6779,11 +7299,7 @@ var settingsProvider = {
         };
       }
       if (!worldSettings) {
-        logger14.info({
-          src: "plugin:bootstrap:provider:settings",
-          agentId: runtime.agentId,
-          messageServerId: serverId
-        }, "No settings state found for server");
+        logger16.info({ src: "plugin:bootstrap:provider:settings", agentId: runtime.agentId, serverId }, "No settings state found for server");
         return isOnboarding ? {
           data: {
             settings: []
@@ -6813,11 +7329,7 @@ var settingsProvider = {
         text: output
       };
     } catch (error) {
-      logger14.error({
-        src: "plugin:bootstrap:provider:settings",
-        agentId: runtime.agentId,
-        error: error instanceof Error ? error.message : String(error)
-      }, "Critical error in settings provider");
+      logger16.error({ src: "plugin:bootstrap:provider:settings", agentId: runtime.agentId, error: error instanceof Error ? error.message : String(error) }, "Critical error in settings provider");
       return {
         data: {
           settings: []
@@ -6854,7 +7366,7 @@ var timeProvider = {
 };
 // src/providers/world.ts
 import {
-  logger as logger15,
+  logger as logger17,
   addHeader as addHeader10,
   ChannelType as ChannelType8
 } from "@elizaos/core";
@@ -6864,14 +7376,14 @@ var worldProvider = {
   dynamic: true,
   get: async (runtime, message) => {
     try {
-      logger15.debug({
+      logger17.debug({
         src: "plugin:bootstrap:provider:world",
         agentId: runtime.agentId,
         roomId: message.roomId
       }, "World provider activated");
       const currentRoom = await runtime.getRoom(message.roomId);
       if (!currentRoom) {
-        logger15.warn({
+        logger17.warn({
           src: "plugin:bootstrap:provider:world",
           agentId: runtime.agentId,
           roomId: message.roomId
@@ -6885,7 +7397,7 @@ var worldProvider = {
           text: "Unable to retrieve world information - room not found"
         };
       }
-      logger15.debug({
+      logger17.debug({
         src: "plugin:bootstrap:provider:world",
         agentId: runtime.agentId,
         roomName: currentRoom.name,
@@ -6893,7 +7405,7 @@ var worldProvider = {
       }, "Found room");
       const worldId = currentRoom.worldId;
       if (!worldId) {
-        logger15.warn({
+        logger17.warn({
           src: "plugin:bootstrap:provider:world",
           agentId: runtime.agentId,
           roomId: message.roomId
@@ -6909,7 +7421,7 @@ var worldProvider = {
       }
       const world = await runtime.getWorld(worldId);
       if (!world) {
-        logger15.warn({ src: "plugin:bootstrap:provider:world", agentId: runtime.agentId, worldId }, "World not found");
+        logger17.warn({ src: "plugin:bootstrap:provider:world", agentId: runtime.agentId, worldId }, "World not found");
         return {
           data: {
             world: {
@@ -6919,21 +7431,23 @@ var worldProvider = {
           text: "Unable to retrieve world information - world not found"
         };
       }
-      logger15.debug({
+      logger17.debug({
         src: "plugin:bootstrap:provider:world",
         agentId: runtime.agentId,
         worldName: world.name,
         worldId: world.id
       }, "Found world");
-      const worldRooms = await runtime.getRooms(worldId);
-      logger15.debug({
+      const [worldRooms, participants] = await Promise.all([
+        runtime.getRooms(worldId),
+        runtime.getParticipantsForRoom(message.roomId)
+      ]);
+      logger17.debug({
         src: "plugin:bootstrap:provider:world",
         agentId: runtime.agentId,
         roomCount: worldRooms.length,
         worldName: world.name
       }, "Found rooms in world");
-      const participants = await runtime.getParticipantsForRoom(message.roomId);
-      logger15.debug({
+      logger17.debug({
         src: "plugin:bootstrap:provider:world",
         agentId: runtime.agentId,
         participantCount: participants.length,
@@ -6949,7 +7463,7 @@ var worldProvider = {
       };
       for (const room of worldRooms) {
         if (!room?.id || !room.name) {
-          logger15.warn({ src: "plugin:bootstrap:provider:world", agentId: runtime.agentId, roomId: room?.id }, "Room ID or name is missing");
+          logger17.warn({ src: "plugin:bootstrap:provider:world", agentId: runtime.agentId, roomId: room?.id }, "Room ID or name is missing");
           continue;
         }
         const roomInfo = {
@@ -7019,14 +7533,14 @@ var worldProvider = {
         worldInfo: worldInfoText
       };
       const formattedText = addHeader10("# World Information", worldInfoText);
-      logger15.debug({ src: "plugin:bootstrap:provider:world", agentId: runtime.agentId }, "World provider completed successfully");
+      logger17.debug({ src: "plugin:bootstrap:provider:world", agentId: runtime.agentId }, "World provider completed successfully");
       return {
         data,
         values,
         text: formattedText
       };
     } catch (error) {
-      logger15.error({
+      logger17.error({
         src: "plugin:bootstrap:provider:world",
         agentId: runtime.agentId,
         error: error instanceof Error ? error.message : String(error)
@@ -7043,6 +7557,120 @@ var worldProvider = {
     }
   }
 };
+// src/providers/plugin-info.ts
+var bootstrapInstructionsProvider = {
+  name: "bootstrapInstructions",
+  description: "Instructions and capabilities for the bootstrap (core) plugin",
+  dynamic: true,
+  get: async (_runtime, _message, _state) => {
+    const instructions = `
+# Bootstrap Plugin Capabilities
+
+## What This Plugin Does
+
+The bootstrap plugin provides essential agent capabilities. It's the foundation that enables basic agent functionality.
+
+## Core Actions
+
+### Communication
+- **REPLY**: Respond to messages (primary communication action)
+- **SEND_MESSAGE**: Send a message to a specific room/channel
+- **IGNORE**: Explicitly ignore a message (no response)
+- **NONE**: Take no action
+
+### Room Management
+- **FOLLOW_ROOM**: Start following a room's messages
+- **UNFOLLOW_ROOM**: Stop following a room
+- **MUTE_ROOM**: Temporarily mute notifications from a room
+- **UNMUTE_ROOM**: Restore notifications for a room
+
+### Entity & Role Management
+- **UPDATE_ENTITY**: Update information about an entity/user
+- **UPDATE_ROLE**: Change role/permissions for an entity
+- **UPDATE_SETTINGS**: Modify configuration settings
+
+### Content
+- **GENERATE_IMAGE**: Create images using AI models
+- **CHOICE**: Present options for user selection
+
+## Core Providers
+
+The bootstrap plugin provides essential context:
+- **TIME**: Current date and time
+- **ENTITIES**: Information about participants
+- **RELATIONSHIPS**: Connection between entities
+- **FACTS**: Known facts about the conversation
+- **RECENT_MESSAGES**: Recent conversation history
+- **CHARACTER**: Agent's personality and traits
+- **ACTIONS**: Available actions
+- **PROVIDERS**: Available data providers
+
+## Event Handling
+
+Bootstrap handles key events:
+- Message received/sent
+- Reactions
+- Entity joins/leaves
+- World connections
+- Action lifecycle (start/complete)
+- Run lifecycle (start/end/timeout)
+
+## Best Practices
+
+1. **REPLY for conversations**: Use REPLY for normal responses
+2. **IGNORE intentionally**: Use IGNORE when staying silent is appropriate
+3. **Room awareness**: Follow relevant rooms, mute noisy ones
+4. **Entity context**: Use entity info for personalization
+`;
+    return {
+      text: instructions.trim(),
+      data: {
+        pluginName: "bootstrap",
+        isCore: true
+      }
+    };
+  }
+};
+var bootstrapSettingsProvider = {
+  name: "bootstrapSettings",
+  description: "Current bootstrap plugin configuration (non-sensitive)",
+  dynamic: true,
+  get: async (runtime, _message, _state) => {
+    const alwaysRespondChannels = runtime.getSetting("ALWAYS_RESPOND_CHANNELS") || "";
+    const alwaysRespondSources = runtime.getSetting("ALWAYS_RESPOND_SOURCES") || "";
+    const settings = {
+      pluginEnabled: true,
+      agentName: runtime.character?.name || "Agent",
+      hasCustomRespondChannels: !!alwaysRespondChannels,
+      hasCustomRespondSources: !!alwaysRespondSources
+    };
+    const text = `
+# Bootstrap Plugin Settings
+
+## Plugin Status
+- **Status**: Enabled (Core Plugin)
+- **Agent**: ${settings.agentName}
+
+## Response Configuration
+- **Custom Respond Channels**: ${settings.hasCustomRespondChannels ? "Configured" : "Using defaults"}
+- **Custom Respond Sources**: ${settings.hasCustomRespondSources ? "Configured" : "Using defaults"}
+
+## Default Behavior
+- Always responds in DMs and API calls
+- Responds when mentioned or replied to
+- Uses LLM evaluation for other messages
+`;
+    return {
+      text: text.trim(),
+      data: settings,
+      values: {
+        pluginEnabled: "true",
+        isCore: "true"
+      }
+    };
+  }
+};
+
 // src/services/task.ts
 import {
   Service,
@@ -7594,10 +8222,177 @@ class EmbeddingGenerationService extends Service2 {
     }, "Cleared queue");
   }
 }
+// src/banner.ts
+var ANSI = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  teal: "\x1B[31m",
+  tealBright: "\x1B[37m",
+  mint: "\x1B[37m",
+  brightGreen: "\x1B[92m",
+  brightYellow: "\x1B[93m",
+  brightMagenta: "\x1B[95m",
+  brightWhite: "\x1B[97m",
+  brightRed: "\x1B[91m",
+  brightBlue: "\x1B[94m"
+};
+function mask(v) {
+  if (!v || v.length < 8)
+    return "••••••••";
+  return `${v.slice(0, 4)}${"•".repeat(Math.min(12, v.length - 8))}${v.slice(-4)}`;
+}
+function fmtVal(value, sensitive, maxLen) {
+  let s;
+  if (value === undefined || value === null || value === "") {
+    s = "(not set)";
+  } else if (sensitive) {
+    s = mask(String(value));
+  } else {
+    s = String(value);
+  }
+  if (s.length > maxLen)
+    s = s.slice(0, maxLen - 3) + "...";
+  return s;
+}
+function isDef(v, d) {
+  if (v === undefined || v === null || v === "")
+    return true;
+  return d !== undefined && v === d;
+}
+function pad(s, n) {
+  const len = s.replace(/\x1b\[[0-9;]*m/g, "").length;
+  if (len >= n)
+    return s;
+  return s + " ".repeat(n - len);
+}
+function line(content) {
+  const stripped = content.replace(/\x1b\[[0-9;]*m/g, "");
+  const len = stripped.length;
+  if (len > 78)
+    return content.slice(0, 78);
+  return content + " ".repeat(78 - len);
+}
+function printBanner(options) {
+  const { settings = [], runtime } = options;
+  const { reset: R, dim: D, bold: B } = ANSI;
+  const { teal: C, tealBright: c2, mint: M } = ANSI;
+  const { brightGreen: G, brightYellow: Y } = ANSI;
+  const top = `${C}╔${"═".repeat(78)}╗${R}`;
+  const mid = `${C}╠${"═".repeat(78)}╣${R}`;
+  const bot = `${C}╚${"═".repeat(78)}╝${R}`;
+  const row = (s) => `${C}║${R}${line(s)}${C}║${R}`;
+  const lines = [""];
+  lines.push(top);
+  lines.push(row(` ${B}Character: ${runtime.character.name}${R}`));
+  lines.push(mid);
+  lines.push(row(`${c2}    ____                    __          __                    ${M}    ▲${R}`));
+  lines.push(row(`${c2}   / __ ) ____   ____  ____/ /_ _____  / /_ _____ ____ _ ____ ${M}   /▲\\${R}`));
+  lines.push(row(`${c2}  / __  |/ __ \\ / __ \\/ __  __// ___/ / __// ___// __ '// __ \\${M}  / ▲ \\${R}`));
+  lines.push(row(`${c2} / /_/ // /_/ // /_/ / /_/ /_ (__  ) / /_ / /   / /_/ // /_/ /${M} /  ▲  \\${R}`));
+  lines.push(row(`${c2}/_____/ \\____/ \\____/\\__,___//____/  \\__//_/    \\__,_// .___/ ${M}/___▲___\\${R}`));
+  lines.push(row(`${D}                                                     ${c2}/_/${R}`));
+  lines.push(row(``));
+  lines.push(row(`${M}         Agent Foundation  •  Actions  •  Evaluators  •  Providers${R}`));
+  lines.push(mid);
+  if (settings.length > 0) {
+    const NW = 32, VW = 28, SW = 8;
+    lines.push(row(` ${B}${pad("ENV VARIABLE", NW)} ${pad("VALUE", VW)} ${pad("STATUS", SW)}${R}`));
+    lines.push(row(` ${D}${"-".repeat(NW)} ${"-".repeat(VW)} ${"-".repeat(SW)}${R}`));
+    for (const s of settings) {
+      const def = isDef(s.value, s.defaultValue);
+      const set = s.value !== undefined && s.value !== null && s.value !== "";
+      let ico, st;
+      if (!set && s.required) {
+        ico = `${ANSI.brightRed}◆${R}`;
+        st = `${ANSI.brightRed}REQUIRED${R}`;
+      } else if (!set) {
+        ico = `${D}○${R}`;
+        st = `${D}default${R}`;
+      } else if (def) {
+        ico = `${ANSI.brightBlue}●${R}`;
+        st = `${ANSI.brightBlue}default${R}`;
+      } else {
+        ico = `${G}✓${R}`;
+        st = `${G}custom${R}`;
+      }
+      const name = pad(s.name, NW - 2);
+      const val = pad(fmtVal(s.value ?? s.defaultValue, s.sensitive ?? false, VW), VW);
+      const status = pad(st, SW);
+      lines.push(row(` ${ico} ${c2}${name}${R} ${val} ${status}`));
+    }
+    lines.push(mid);
+    lines.push(row(` ${D}${G}✓${D} custom  ${ANSI.brightBlue}●${D} default  ○ unset  ${ANSI.brightRed}◆${D} required      → Set in .env${R}`));
+  } else {
+    lines.push(row(` ${G}▸${R} ${Y}Actions${R}      reply, sendMessage, followRoom, muteRoom, generateImage...`));
+    lines.push(row(` ${G}▸${R} ${Y}Evaluators${R}   reflection, memory consolidation, learning`));
+    lines.push(row(` ${G}▸${R} ${Y}Providers${R}    time, entities, facts, relationships, attachments...`));
+    lines.push(row(` ${G}▸${R} ${Y}Services${R}     TaskService, EmbeddingGenerationService`));
+    lines.push(mid);
+    lines.push(row(` ${D}The foundation that gives every elizaOS agent its core capabilities${R}`));
+  }
+  lines.push(bot);
+  lines.push("");
+  runtime.logger.info(lines.join(`
+`));
+}
 
 // src/index.ts
+var isMemoryCreationDisabled = (runtime) => {
+  const setting = runtime.getSetting("DISABLE_MEMORY_CREATION");
+  if (typeof setting === "boolean") {
+    return setting;
+  }
+  if (typeof setting === "string") {
+    return parseBooleanFromText3(setting);
+  }
+  if (setting != null) {
+    return parseBooleanFromText3(String(setting));
+  }
+  return false;
+};
+var getAllowedMemorySources = (runtime) => {
+  const setting = runtime.getSetting("ALLOW_MEMORY_SOURCE_IDS");
+  if (Array.isArray(setting)) {
+    return setting.map((value) => String(value).trim()).filter(Boolean);
+  }
+  if (typeof setting === "string") {
+    const trimmed = setting.trim();
+    if (!trimmed) {
+      return null;
+    }
+    if (trimmed.startsWith("[")) {
+      try {
+        const parsed = JSON.parse(trimmed);
+        if (Array.isArray(parsed)) {
+          return parsed.map((value) => String(value).trim()).filter(Boolean);
+        }
+        runtime.logger.warn({ src: "plugin:bootstrap", parsed }, "ALLOW_MEMORY_SOURCE_IDS JSON did not parse to an array; ignoring setting");
+        return null;
+      } catch (error) {
+        runtime.logger.warn({ src: "plugin:bootstrap", error, setting: trimmed }, "Failed to parse ALLOW_MEMORY_SOURCE_IDS JSON; ignoring setting");
+        return null;
+      }
+    }
+    return trimmed.split(",").map((value) => value.trim()).filter(Boolean);
+  }
+  if (setting != null) {
+    return [String(setting).trim()].filter(Boolean);
+  }
+  return null;
+};
 async function fetchMediaData(attachments) {
   return Promise.all(attachments.map(async (attachment) => {
+    if (attachment.url.startsWith("data:")) {
+      const match = attachment.url.match(/^data:([^;]+);base64,(.+)$/);
+      if (match) {
+        const mediaType = match[1];
+        const base64Data = match[2];
+        const mediaBuffer = Buffer.from(base64Data, "base64");
+        return { data: mediaBuffer, mediaType };
+      }
+      throw new Error(`Invalid data URL format: ${attachment.url.substring(0, 50)}...`);
+    }
     if (/^(http|https):\/\//.test(attachment.url)) {
       const response = await fetch(attachment.url);
       if (!response.ok) {
@@ -7619,12 +8414,13 @@ async function processAttachments(attachments, runtime) {
   for (const attachment of attachments) {
     try {
       const processedAttachment = { ...attachment };
+      const isDataUrl = attachment.url.startsWith("data:");
       const isRemote = /^(http|https):\/\//.test(attachment.url);
-      const url = isRemote ? attachment.url : getLocalServerUrl(attachment.url);
+      const url = isRemote ? attachment.url : isDataUrl ? attachment.url : getLocalServerUrl(attachment.url);
       if (attachment.contentType === ContentType2.IMAGE && !attachment.description) {
-        runtime.logger.debug({ src: "plugin:bootstrap", agentId: runtime.agentId, url: attachment.url }, "Generating description for image");
+        runtime.logger.debug({ src: "plugin:bootstrap", agentId: runtime.agentId, url: attachment.url?.substring(0, 100) }, "Generating description for image");
         let imageUrl = url;
-        if (!isRemote) {
+        if (!isRemote && !isDataUrl) {
           const res = await fetch(url);
           if (!res.ok) {
             throw new Error(`Failed to fetch image: ${res.statusText}`);
@@ -7767,18 +8563,42 @@ var reactionReceivedHandler = async ({
   message
 }) => {
   try {
+    const disableMemoryCreation = isMemoryCreationDisabled(runtime);
+    const allowedSources = getAllowedMemorySources(runtime);
+    const reactionSourceId = message.metadata?.sourceId;
+    const sourceAllowed = !allowedSources || typeof reactionSourceId === "string" && allowedSources.includes(reactionSourceId);
+    if (disableMemoryCreation) {
+      runtime.logger.debug({
+        src: "plugin:bootstrap",
+        agentId: runtime.agentId,
+        messageId: message.id,
+        sourceId: reactionSourceId ?? null
+      }, "DISABLE_MEMORY_CREATION enabled; skipping reaction memory creation");
+      return;
+    }
+    if (!sourceAllowed) {
+      runtime.logger.info({
+        src: "plugin:bootstrap",
+        agentId: runtime.agentId,
+        messageId: message.id,
+        sourceId: reactionSourceId ?? null,
+        allowedSources
+      }, "Reaction source not whitelisted; skipping reaction memory creation");
+      return;
+    }
     await runtime.createMemory(message, "messages");
+    runtime.logger.debug({
+      src: "plugin:bootstrap",
+      agentId: runtime.agentId,
+      messageId: message.id,
+      sourceId: reactionSourceId ?? null
+    }, "Stored reaction memory");
   } catch (error) {
-    const isDuplicateKeyError = error instanceof Error && "code" in error && error.code === "23505";
-    if (isDuplicateKeyError) {
+    if (error.code === "23505") {
       runtime.logger.warn({ src: "plugin:bootstrap", agentId: runtime.agentId }, "Duplicate reaction memory, skipping");
       return;
     }
-    runtime.logger.error({
-      src: "plugin:bootstrap",
-      agentId: runtime.agentId,
-      error: error instanceof Error ? error.message : String(error)
-    }, "Error in reaction handler");
+    runtime.logger.error({ src: "plugin:bootstrap", agentId: runtime.agentId, error: error instanceof Error ? error.message : String(error) }, "Error in reaction handler");
   }
 };
 var postGeneratedHandler = async ({
@@ -7806,7 +8626,7 @@ var postGeneratedHandler = async ({
     worldId
   });
   const message = {
-    id: createUniqueUuid(runtime, `tweet-${Date.now()}`),
+    id: createUniqueUuid3(runtime, `tweet-${Date.now()}`),
     entityId: runtime.agentId,
     agentId: runtime.agentId,
     roomId,
@@ -7825,7 +8645,7 @@ var postGeneratedHandler = async ({
   const entity = await runtime.getEntityById(runtime.agentId);
   const metadata = entity?.metadata;
   if (metadata?.twitter?.userName || metadata?.userName) {
-    state.values.twitterUserName = metadata.twitter?.userName || metadata.userName;
+    state.values.twitterUserName = metadata.twitter?.userName ?? metadata.userName;
   }
   const prompt = composePromptFromState10({
     state,
@@ -7947,8 +8767,8 @@ var syncSingleUser = async (entityId, runtime, messageServerId, channelId, type,
       runtime.logger.warn({ src: "plugin:bootstrap", agentId: runtime.agentId, entityId: entity?.id }, "Cannot sync user without a valid channelId");
       return;
     }
-    const roomId = createUniqueUuid(runtime, channelId);
-    const worldId = createUniqueUuid(runtime, messageServerId);
+    const roomId = createUniqueUuid3(runtime, channelId);
+    const worldId = createUniqueUuid3(runtime, messageServerId);
     const worldMetadata = type === ChannelType9.DM ? {
       ownership: {
         ownerId: entityId
@@ -8026,14 +8846,9 @@ var handleServerSync = async ({
     }, "Error processing standardized server data");
   }
 };
-var controlMessageHandler = async ({ runtime, message }) => {
+var controlMessageHandler = async ({ runtime, message, source: _source }) => {
   try {
-    runtime.logger.debug({
-      src: "plugin:bootstrap",
-      agentId: runtime.agentId,
-      action: message.payload.action,
-      roomId: message.roomId
-    }, "Processing control message");
+    runtime.logger.debug({ src: "plugin:bootstrap", agentId: runtime.agentId, action: message.payload.action, roomId: message.roomId }, "Processing control message");
     const serviceNames = Array.from(runtime.getAllServices().keys());
     const websocketServiceName = serviceNames.find((name) => name.toLowerCase().includes("websocket") || name.toLowerCase().includes("socket"));
     if (websocketServiceName) {
@@ -8055,11 +8870,7 @@ var controlMessageHandler = async ({ runtime, message }) => {
       runtime.logger.error({ src: "plugin:bootstrap", agentId: runtime.agentId }, "No WebSocket service found to send control message");
     }
   } catch (error) {
-    runtime.logger.error({
-      src: "plugin:bootstrap",
-      agentId: runtime.agentId,
-      error: error instanceof Error ? error.message : String(error)
-    }, "Error processing control message");
+    runtime.logger.error({ src: "plugin:bootstrap", agentId: runtime.agentId, error: error instanceof Error ? error.message : String(error) }, "Error processing control message");
   }
 };
 var events = {
@@ -8109,7 +8920,7 @@ var events = {
       }
       const channelType = payload.metadata?.type;
       if (typeof channelType !== "string") {
-        payload.runtime.logger.warn("Missing channel type in entity payload");
+        payload.runtime.logger.warn({ src: "plugin:bootstrap", agentId: payload.runtime.agentId }, "Missing channel type in entity payload");
         return;
       }
       await syncSingleUser(payload.entityId, payload.runtime, payload.worldId, payload.roomId, channelType, payload.source);
@@ -8152,7 +8963,7 @@ var events = {
           }
         }
       } catch (error) {
-        logger16.error({
+        logger18.error({
           src: "plugin:bootstrap",
           agentId: payload.runtime.agentId,
           error: error instanceof Error ? error.message : String(error)
@@ -8176,13 +8987,13 @@ var events = {
             source: "actionHandler"
           }
         });
-        logger16.debug({
+        logger18.debug({
           src: "plugin:bootstrap",
           agentId: payload.runtime.agentId,
           actionName: payload.content?.actions?.[0]
         }, "Logged ACTION_STARTED event");
       } catch (error) {
-        logger16.error({
+        logger18.error({
           src: "plugin:bootstrap",
           agentId: payload.runtime.agentId,
           error: error instanceof Error ? error.message : String(error)
@@ -8200,7 +9011,7 @@ var events = {
           }
         }
       } catch (error) {
-        logger16.error({
+        logger18.error({
           src: "plugin:bootstrap",
           agentId: payload.runtime.agentId,
           error: error instanceof Error ? error.message : String(error)
@@ -8210,7 +9021,7 @@ var events = {
   ],
   [EventType2.EVALUATOR_STARTED]: [
     async (payload) => {
-      logger16.debug({
+      logger18.debug({
         src: "plugin:bootstrap:evaluator",
         agentId: payload.runtime.agentId,
         evaluatorName: payload.evaluatorName,
@@ -8221,7 +9032,7 @@ var events = {
   [EventType2.EVALUATOR_COMPLETED]: [
     async (payload) => {
       const status = payload.error ? "failed" : "completed";
-      logger16.debug({
+      logger18.debug({
         src: "plugin:bootstrap:evaluator",
         agentId: payload.runtime.agentId,
         status,
@@ -8248,9 +9059,9 @@ var events = {
             source: payload.source || "unknown"
           }
         });
-        logger16.debug({ src: "plugin:bootstrap", agentId: payload.runtime.agentId, runId: payload.runId }, "Logged RUN_STARTED event");
+        logger18.debug({ src: "plugin:bootstrap", agentId: payload.runtime.agentId, runId: payload.runId }, "Logged RUN_STARTED event");
       } catch (error) {
-        logger16.error({
+        logger18.error({
           src: "plugin:bootstrap",
           agentId: payload.runtime.agentId,
           error: error instanceof Error ? error.message : String(error)
@@ -8278,14 +9089,14 @@ var events = {
             source: payload.source || "unknown"
           }
         });
-        logger16.debug({
+        logger18.debug({
           src: "plugin:bootstrap",
           agentId: payload.runtime.agentId,
           runId: payload.runId,
           status: payload.status
         }, "Logged RUN_ENDED event");
       } catch (error) {
-        logger16.error({
+        logger18.error({
           src: "plugin:bootstrap",
           agentId: payload.runtime.agentId,
           error: error instanceof Error ? error.message : String(error)
@@ -8313,9 +9124,9 @@ var events = {
             source: payload.source || "unknown"
           }
         });
-        logger16.debug({ src: "plugin:bootstrap", agentId: payload.runtime.agentId, runId: payload.runId }, "Logged RUN_TIMEOUT event");
+        logger18.debug({ src: "plugin:bootstrap", agentId: payload.runtime.agentId, runId: payload.runId }, "Logged RUN_TIMEOUT event");
       } catch (error) {
-        logger16.error({
+        logger18.error({
           src: "plugin:bootstrap",
           agentId: payload.runtime.agentId,
           error: error instanceof Error ? error.message : String(error)
@@ -8325,10 +9136,6 @@ var events = {
   ],
   [EventType2.CONTROL_MESSAGE]: [
     async (payload) => {
-      if (!payload.message) {
-        payload.runtime.logger.warn({ src: "plugin:bootstrap" }, "CONTROL_MESSAGE received without message property");
-        return;
-      }
       await controlMessageHandler(payload);
     }
   ]
@@ -8336,6 +9143,31 @@ var events = {
 var bootstrapPlugin = {
   name: "bootstrap",
   description: "Agent bootstrap with basic actions and evaluators",
+  init: async (_config, runtime) => {
+    const settings = [
+      {
+        name: "DISABLE_MEMORY_CREATION",
+        value: runtime.getSetting("DISABLE_MEMORY_CREATION"),
+        defaultValue: false
+      },
+      {
+        name: "ALLOW_MEMORY_SOURCE_IDS",
+        value: runtime.getSetting("ALLOW_MEMORY_SOURCE_IDS"),
+        defaultValue: undefined
+      },
+      {
+        name: "ALWAYS_RESPOND_CHANNELS",
+        value: runtime.getSetting("ALWAYS_RESPOND_CHANNELS"),
+        defaultValue: undefined
+      },
+      {
+        name: "ALWAYS_RESPOND_SOURCES",
+        value: runtime.getSetting("ALWAYS_RESPOND_SOURCES"),
+        defaultValue: undefined
+      }
+    ];
+    printBanner({ runtime, settings });
+  },
   actions: [
     replyAction,
     followRoomAction,
@@ -8369,13 +9201,16 @@ var bootstrapPlugin = {
     actionStateProvider,
     characterProvider,
     recentMessagesProvider,
-    worldProvider
+    worldProvider,
+    bootstrapInstructionsProvider,
+    bootstrapSettingsProvider
   ],
   services: [TaskService, EmbeddingGenerationService]
 };
 var src_default = bootstrapPlugin;
 export {
   worldProvider,
+  withTimeout,
   updateSettingsAction,
   updateRoleAction,
   updateEntityAction,
@@ -8394,11 +9229,28 @@ export {
   processAttachments,
   noneAction,
   muteRoomAction,
+  markNoSettings,
+  markNoServerId,
+  invalidateWorldCacheByServerId,
+  invalidateWorldCache,
+  invalidateRoomCacheByExternalId,
+  invalidateRoomCache,
+  invalidateEntitiesCache,
   ignoreAction,
+  hasNoSettings,
+  hasNoServerId,
+  getCachedWorldSettings,
+  getCachedWorld,
+  getCachedSettingsByServerId,
+  getCachedRoomByExternalId,
+  getCachedRoom,
+  getCachedEntitiesForRoom,
+  getCacheStats,
   generateImageAction,
   followRoomAction,
   fetchMediaData,
   factsProvider,
+  extractWorldSettings,
   evaluatorsProvider,
   entitiesProvider,
   src_default as default,
@@ -8413,5 +9265,5 @@ export {
   actionStateProvider
 };
 
-//# debugId=33481F5084CEC20E64756E2164756E21
+//# debugId=6015D97D31F852B564756E2164756E21
 //# sourceMappingURL=index.js.map