@elizaos/plugin-bootstrap 1.6.2-alpha.24 → 1.6.2-alpha.25

package/dist/index.js

@@ -80,7 +80,6 @@ Length provided: ${this.length}. Number of dictionaries provided: ${this.diction
 
 // src/index.ts
 import {
-  asUUID as asUUID2,
   ChannelType as ChannelType9,
   composePromptFromState as composePromptFromState10,
   ContentType as ContentType2,
@@ -92,13 +91,8 @@ import {
   ModelType as ModelType15,
   parseKeyValueXml as parseKeyValueXml9,
   postCreationTemplate,
-  parseBooleanFromText as parseBooleanFromText2,
   Role as Role2,
-  shouldRespondTemplate,
-  truncateToCompleteSentence,
-  getLocalServerUrl,
-  multiStepDecisionTemplate,
-  multiStepSummaryTemplate
+  getLocalServerUrl
 } from "@elizaos/core";
 
 // ../../node_modules/uuid/dist-node/stringify.js
@@ -6930,18 +6924,34 @@ class EmbeddingGenerationService extends Service2 {
   maxQueueSize = 1000;
   batchSize = 10;
   processingIntervalMs = 100;
+  isDisabled = false;
   static async start(runtime) {
     logger21.info("[EmbeddingService] Starting embedding generation service");
+    const embeddingModel = runtime.getModel(ModelType14.TEXT_EMBEDDING);
+    if (!embeddingModel) {
+      logger21.warn("[EmbeddingService] No TEXT_EMBEDDING model registered. Embedding service will not be initialized.");
+      const noOpService = new EmbeddingGenerationService(runtime);
+      noOpService.isDisabled = true;
+      return noOpService;
+    }
     const service = new EmbeddingGenerationService(runtime);
     await service.initialize();
     return service;
   }
   async initialize() {
+    if (this.isDisabled) {
+      logger21.debug("[EmbeddingService] Service is disabled, skipping initialization");
+      return;
+    }
     logger21.info("[EmbeddingService] Initializing embedding generation service");
     this.runtime.registerEvent(EventType.EMBEDDING_GENERATION_REQUESTED, this.handleEmbeddingRequest.bind(this));
     this.startProcessing();
   }
   async handleEmbeddingRequest(payload) {
+    if (this.isDisabled) {
+      logger21.debug("[EmbeddingService] Service is disabled, skipping embedding request");
+      return;
+    }
     const { memory, priority = "normal", retryCount = 0, maxRetries = 3, runId } = payload;
     if (memory.embedding) {
       logger21.debug("[EmbeddingService] Memory already has embeddings, skipping");
@@ -7010,6 +7020,10 @@ class EmbeddingGenerationService extends Service2 {
     }
   }
   startProcessing() {
+    if (this.isDisabled) {
+      logger21.debug("[EmbeddingService] Service is disabled, not starting processing loop");
+      return;
+    }
     if (this.processingInterval) {
       return;
     }
@@ -7107,6 +7121,10 @@ class EmbeddingGenerationService extends Service2 {
   }
   async stop() {
     logger21.info("[EmbeddingService] Stopping embedding generation service");
+    if (this.isDisabled) {
+      logger21.debug("[EmbeddingService] Service is disabled, nothing to stop");
+      return;
+    }
     if (this.processingInterval) {
       clearInterval(this.processingInterval);
       this.processingInterval = null;
@@ -7147,7 +7165,6 @@ class EmbeddingGenerationService extends Service2 {
 }
 
 // src/index.ts
-var latestResponseIds = new Map;
 async function fetchMediaData(attachments) {
   return Promise.all(attachments.map(async (attachment) => {
     if (/^(http|https):\/\//.test(attachment.url)) {
@@ -7253,7 +7270,7 @@ function shouldRespond(runtime, message, room, mentionContext) {
   function normalizeEnvList(value) {
     if (!value || typeof value !== "string")
       return [];
-    const cleaned = value.trim().replace(/^\[|\]$/g, "");
+    const cleaned = value.trim().replace(/^[\[]|[\]]$/g, "");
     return cleaned.split(",").map((v) => v.trim()).filter(Boolean);
   }
   const alwaysRespondChannels = [
@@ -7286,567 +7303,6 @@ function shouldRespond(runtime, message, room, mentionContext) {
   }
   return { shouldRespond: false, skipEvaluation: false, reason: "needs LLM evaluation" };
 }
-var messageReceivedHandler = async ({
-  runtime,
-  message,
-  callback,
-  onComplete
-}) => {
-  const useMultiStep = runtime.getSetting("USE_MULTI_STEP");
-  const timeoutDuration = 60 * 60 * 1000;
-  let timeoutId = undefined;
-  try {
-    runtime.logger.info(`[Bootstrap] Message received from ${message.entityId} in room ${message.roomId}`);
-    const responseId = v4_default();
-    if (!latestResponseIds.has(runtime.agentId)) {
-      latestResponseIds.set(runtime.agentId, new Map);
-    }
-    const agentResponses = latestResponseIds.get(runtime.agentId);
-    if (!agentResponses)
-      throw new Error("Agent responses map not found");
-    const previousResponseId = agentResponses.get(message.roomId);
-    if (previousResponseId) {
-      logger22.warn(`[Bootstrap] Updating response ID for room ${message.roomId} from ${previousResponseId} to ${responseId} - this may discard in-progress responses`);
-    }
-    agentResponses.set(message.roomId, responseId);
-    const runId = runtime.startRun();
-    const startTime = Date.now();
-    await runtime.emitEvent(EventType2.RUN_STARTED, {
-      runtime,
-      runId,
-      messageId: message.id,
-      roomId: message.roomId,
-      entityId: message.entityId,
-      startTime,
-      status: "started",
-      source: "messageHandler",
-      metadata: message.content
-    });
-    const timeoutPromise = new Promise((_, reject) => {
-      timeoutId = setTimeout(async () => {
-        await runtime.emitEvent(EventType2.RUN_TIMEOUT, {
-          runtime,
-          runId,
-          messageId: message.id,
-          roomId: message.roomId,
-          entityId: message.entityId,
-          startTime,
-          status: "timeout",
-          endTime: Date.now(),
-          duration: Date.now() - startTime,
-          error: "Run exceeded 60 minute timeout",
-          source: "messageHandler"
-        });
-        reject(new Error("Run exceeded 60 minute timeout"));
-      }, timeoutDuration);
-    });
-    const processingPromise = (async () => {
-      try {
-        if (message.entityId === runtime.agentId) {
-          runtime.logger.debug(`[Bootstrap] Skipping message from self (${runtime.agentId})`);
-          throw new Error("Message is from the agent itself");
-        }
-        runtime.logger.debug(`[Bootstrap] Processing message: ${truncateToCompleteSentence(message.content.text || "", 50)}...`);
-        runtime.logger.debug("[Bootstrap] Saving message to memory and queueing embeddings");
-        let memoryToQueue;
-        if (message.id) {
-          const existingMemory = await runtime.getMemoryById(message.id);
-          if (existingMemory) {
-            runtime.logger.debug("[Bootstrap] Memory already exists, skipping creation");
-            memoryToQueue = existingMemory;
-          } else {
-            const createdMemoryId = await runtime.createMemory(message, "messages");
-            memoryToQueue = { ...message, id: createdMemoryId };
-          }
-          await runtime.queueEmbeddingGeneration(memoryToQueue, "high");
-        } else {
-          const memoryId = await runtime.createMemory(message, "messages");
-          message.id = memoryId;
-          memoryToQueue = { ...message, id: memoryId };
-          await runtime.queueEmbeddingGeneration(memoryToQueue, "normal");
-        }
-        const agentUserState = await runtime.getParticipantUserState(message.roomId, runtime.agentId);
-        const defLllmOff = parseBooleanFromText2(runtime.getSetting("BOOTSTRAP_DEFLLMOFF"));
-        if (defLllmOff && agentUserState === null) {
-          runtime.logger.debug("bootstrap - LLM is off by default");
-          await runtime.emitEvent(EventType2.RUN_ENDED, {
-            runtime,
-            runId,
-            messageId: message.id,
-            roomId: message.roomId,
-            entityId: message.entityId,
-            startTime,
-            status: "off",
-            endTime: Date.now(),
-            duration: Date.now() - startTime,
-            source: "messageHandler"
-          });
-          return;
-        }
-        if (agentUserState === "MUTED" && !message.content.text?.toLowerCase().includes(runtime.character.name.toLowerCase())) {
-          runtime.logger.debug(`[Bootstrap] Ignoring muted room ${message.roomId}`);
-          await runtime.emitEvent(EventType2.RUN_ENDED, {
-            runtime,
-            runId,
-            messageId: message.id,
-            roomId: message.roomId,
-            entityId: message.entityId,
-            startTime,
-            status: "muted",
-            endTime: Date.now(),
-            duration: Date.now() - startTime,
-            source: "messageHandler"
-          });
-          return;
-        }
-        let state = await runtime.composeState(message, ["ANXIETY", "ENTITIES", "CHARACTER", "RECENT_MESSAGES", "ACTIONS"], true);
-        const mentionContext = message.content.mentionContext;
-        const room = await runtime.getRoom(message.roomId);
-        if (message.content.attachments && message.content.attachments.length > 0) {
-          message.content.attachments = await processAttachments(message.content.attachments, runtime);
-          if (message.id) {
-            await runtime.updateMemory({ id: message.id, content: message.content });
-          }
-        }
-        const responseDecision = shouldRespond(runtime, message, room ?? undefined, mentionContext);
-        runtime.logger.debug(`[Bootstrap] Response decision: ${JSON.stringify(responseDecision)}`);
-        let shouldRespondToMessage = true;
-        if (responseDecision.skipEvaluation) {
-          runtime.logger.debug(`[Bootstrap] Skipping evaluation for ${runtime.character.name} (${responseDecision.reason})`);
-          shouldRespondToMessage = responseDecision.shouldRespond;
-        } else {
-          const shouldRespondPrompt = composePromptFromState10({
-            state,
-            template: runtime.character.templates?.shouldRespondTemplate || shouldRespondTemplate
-          });
-          runtime.logger.debug(`[Bootstrap] Using LLM evaluation for ${runtime.character.name} (${responseDecision.reason})`);
-          const response = await runtime.useModel(ModelType15.TEXT_SMALL, {
-            prompt: shouldRespondPrompt
-          });
-          runtime.logger.debug(`[Bootstrap] LLM evaluation result:
-${response}`);
-          const responseObject = parseKeyValueXml9(response);
-          runtime.logger.debug({ responseObject }, "[Bootstrap] Parsed evaluation result:");
-          const nonResponseActions = ["IGNORE", "NONE"];
-          shouldRespondToMessage = responseObject?.action && !nonResponseActions.includes(responseObject.action.toUpperCase());
-        }
-        let responseContent = null;
-        let responseMessages = [];
-        const keepResp = parseBooleanFromText2(runtime.getSetting("BOOTSTRAP_KEEP_RESP"));
-        if (shouldRespondToMessage) {
-          const result = useMultiStep ? await runMultiStepCore({ runtime, message, state, callback }) : await runSingleShotCore({ runtime, message, state });
-          responseContent = result.responseContent;
-          responseMessages = result.responseMessages;
-          state = result.state;
-          const currentResponseId = agentResponses.get(message.roomId);
-          if (currentResponseId !== responseId && !keepResp) {
-            runtime.logger.info(`Response discarded - newer message being processed for agent: ${runtime.agentId}, room: ${message.roomId}`);
-            return;
-          }
-          if (responseContent && message.id) {
-            responseContent.inReplyTo = createUniqueUuid3(runtime, message.id);
-          }
-          if (responseContent?.providers?.length && responseContent.providers.length > 0) {
-            state = await runtime.composeState(message, responseContent.providers || []);
-          }
-          if (responseContent) {
-            const mode = result.mode ?? "actions";
-            if (mode === "simple") {
-              if (responseContent.providers && responseContent.providers.length > 0) {
-                runtime.logger.debug({ providers: responseContent.providers }, "[Bootstrap] Simple response used providers");
-              }
-              if (callback) {
-                await callback(responseContent);
-              }
-            } else if (mode === "actions") {
-              await runtime.processActions(message, responseMessages, state, async (content) => {
-                runtime.logger.debug({ content }, "action callback");
-                responseContent.actionCallbacks = content;
-                if (callback) {
-                  return callback(content);
-                }
-                return [];
-              });
-            }
-          }
-        } else {
-          runtime.logger.debug("[Bootstrap] Agent decided not to respond (shouldRespond is false).");
-          const currentResponseId = agentResponses.get(message.roomId);
-          if (currentResponseId !== responseId && !keepResp) {
-            runtime.logger.info(`Ignore response discarded - newer message being processed for agent: ${runtime.agentId}, room: ${message.roomId}`);
-            await runtime.emitEvent(EventType2.RUN_ENDED, {
-              runtime,
-              runId,
-              messageId: message.id,
-              roomId: message.roomId,
-              entityId: message.entityId,
-              startTime,
-              status: "replaced",
-              endTime: Date.now(),
-              duration: Date.now() - startTime,
-              source: "messageHandler"
-            });
-            return;
-          }
-          if (!message.id) {
-            runtime.logger.error("[Bootstrap] Message ID is missing, cannot create ignore response.");
-            await runtime.emitEvent(EventType2.RUN_ENDED, {
-              runtime,
-              runId,
-              messageId: message.id,
-              roomId: message.roomId,
-              entityId: message.entityId,
-              startTime,
-              status: "noMessageId",
-              endTime: Date.now(),
-              duration: Date.now() - startTime,
-              source: "messageHandler"
-            });
-            return;
-          }
-          const ignoreContent = {
-            thought: "Agent decided not to respond to this message.",
-            actions: ["IGNORE"],
-            simple: true,
-            inReplyTo: createUniqueUuid3(runtime, message.id)
-          };
-          if (callback) {
-            await callback(ignoreContent);
-          }
-          const ignoreMemory = {
-            id: asUUID2(v4_default()),
-            entityId: runtime.agentId,
-            agentId: runtime.agentId,
-            content: ignoreContent,
-            roomId: message.roomId,
-            createdAt: Date.now()
-          };
-          await runtime.createMemory(ignoreMemory, "messages");
-          runtime.logger.debug("[Bootstrap] Saved ignore response to memory", `memoryId: ${ignoreMemory.id}`);
-        }
-        agentResponses.delete(message.roomId);
-        if (agentResponses.size === 0) {
-          latestResponseIds.delete(runtime.agentId);
-        }
-        runtime.evaluate(message, state, shouldRespondToMessage, async (content) => {
-          runtime.logger.debug({ content }, "evaluate callback");
-          if (responseContent) {
-            responseContent.evalCallbacks = content;
-          }
-          if (callback) {
-            return callback(content);
-          }
-          return [];
-        }, responseMessages).catch((error) => {
-          runtime.logger.error({ error, messageId: message.id, roomId: message.roomId }, "[Bootstrap] Error in background evaluator execution");
-        });
-        let entityName = "noname";
-        if (message.metadata && "entityName" in message.metadata) {
-          entityName = message.metadata.entityName;
-        }
-        const isDM = message.content?.channelType === ChannelType9.DM;
-        let roomName = entityName;
-        if (!isDM) {
-          const roomDatas = await runtime.getRoomsByIds([message.roomId]);
-          if (roomDatas?.length) {
-            const roomData = roomDatas[0];
-            if (roomData.name) {
-              roomName = roomData.name;
-            }
-            if (roomData.worldId) {
-              const worldData = await runtime.getWorld(roomData.worldId);
-              if (worldData) {
-                roomName = worldData.name + "-" + roomName;
-              }
-            }
-          }
-        }
-        const date = new Date;
-        const availableActions = state.data?.providers?.ACTIONS?.data?.actionsData?.map((a) => a.name) || [-1];
-        const logData = {
-          at: date.toString(),
-          timestamp: parseInt("" + date.getTime() / 1000),
-          messageId: message.id,
-          userEntityId: message.entityId,
-          input: message.content.text,
-          thought: responseContent?.thought,
-          simple: responseContent?.simple,
-          availableActions,
-          actions: responseContent?.actions,
-          providers: responseContent?.providers,
-          irt: responseContent?.inReplyTo,
-          output: responseContent?.text,
-          entityName,
-          source: message.content.source,
-          channelType: message.content.channelType,
-          roomName
-        };
-        await runtime.emitEvent(EventType2.RUN_ENDED, {
-          runtime,
-          runId,
-          messageId: message.id,
-          roomId: message.roomId,
-          entityId: message.entityId,
-          startTime,
-          status: "completed",
-          endTime: Date.now(),
-          duration: Date.now() - startTime,
-          source: "messageHandler",
-          entityName,
-          responseContent,
-          metadata: logData
-        });
-      } catch (error) {
-        console.error("error is", error);
-        await runtime.emitEvent(EventType2.RUN_ENDED, {
-          runtime,
-          runId,
-          messageId: message.id,
-          roomId: message.roomId,
-          entityId: message.entityId,
-          startTime,
-          status: "error",
-          endTime: Date.now(),
-          duration: Date.now() - startTime,
-          error: error.message,
-          source: "messageHandler"
-        });
-      }
-    })();
-    await Promise.race([processingPromise, timeoutPromise]);
-  } finally {
-    clearTimeout(timeoutId);
-    onComplete?.();
-  }
-};
-async function runSingleShotCore({
-  runtime,
-  message,
-  state
-}) {
-  state = await runtime.composeState(message, ["ACTIONS"]);
-  if (!state.values?.actionNames) {
-    runtime.logger.warn("actionNames data missing from state, even though it was requested");
-  }
-  const prompt = composePromptFromState10({
-    state,
-    template: runtime.character.templates?.messageHandlerTemplate || messageHandlerTemplate
-  });
-  let responseContent = null;
-  let retries = 0;
-  const maxRetries = 3;
-  while (retries < maxRetries && (!responseContent?.thought || !responseContent?.actions)) {
-    const response = await runtime.useModel(ModelType15.TEXT_LARGE, { prompt });
-    runtime.logger.debug({ response }, "[Bootstrap] *** Raw LLM Response ***");
-    const parsedXml = parseKeyValueXml9(response);
-    runtime.logger.debug({ parsedXml }, "[Bootstrap] *** Parsed XML Content ***");
-    if (parsedXml) {
-      responseContent = {
-        ...parsedXml,
-        thought: parsedXml.thought || "",
-        actions: parsedXml.actions || ["IGNORE"],
-        providers: parsedXml.providers || [],
-        text: parsedXml.text || "",
-        simple: parsedXml.simple || false
-      };
-    } else {
-      responseContent = null;
-    }
-    retries++;
-    if (!responseContent?.thought || !responseContent?.actions) {
-      runtime.logger.warn({ response, parsedXml, responseContent }, "[Bootstrap] *** Missing required fields (thought or actions), retrying... ***");
-    }
-  }
-  if (!responseContent) {
-    return { responseContent: null, responseMessages: [], state, mode: "none" };
-  }
-  if (responseContent.actions && responseContent.actions.length > 1) {
-    const isIgnore = (a) => typeof a === "string" && a.toUpperCase() === "IGNORE";
-    const hasIgnore = responseContent.actions.some(isIgnore);
-    if (hasIgnore) {
-      if (!responseContent.text || responseContent.text.trim() === "") {
-        responseContent.actions = ["IGNORE"];
-      } else {
-        const filtered = responseContent.actions.filter((a) => !isIgnore(a));
-        responseContent.actions = filtered.length ? filtered : ["REPLY"];
-      }
-    }
-  }
-  const isSimple = responseContent.actions?.length === 1 && typeof responseContent.actions[0] === "string" && responseContent.actions[0].toUpperCase() === "REPLY" && (!responseContent.providers || responseContent.providers.length === 0);
-  responseContent.simple = isSimple;
-  const responseMessages = [
-    {
-      id: asUUID2(v4_default()),
-      entityId: runtime.agentId,
-      agentId: runtime.agentId,
-      content: responseContent,
-      roomId: message.roomId,
-      createdAt: Date.now()
-    }
-  ];
-  return {
-    responseContent,
-    responseMessages,
-    state,
-    mode: isSimple && responseContent.text ? "simple" : "actions"
-  };
-}
-async function runMultiStepCore({
-  runtime,
-  message,
-  state,
-  callback
-}) {
-  const traceActionResult = [];
-  let accumulatedState = state;
-  const maxIterations = parseInt(runtime.getSetting("MAX_MULTISTEP_ITERATIONS") || "6");
-  let iterationCount = 0;
-  while (iterationCount < maxIterations) {
-    iterationCount++;
-    runtime.logger.debug(`[MultiStep] Starting iteration ${iterationCount}/${maxIterations}`);
-    accumulatedState = await runtime.composeState(message, ["RECENT_MESSAGES", "ACTION_STATE"]);
-    accumulatedState.data.actionResults = traceActionResult;
-    const prompt = composePromptFromState10({
-      state: accumulatedState,
-      template: runtime.character.templates?.multiStepDecisionTemplate || multiStepDecisionTemplate
-    });
-    const stepResultRaw = await runtime.useModel(ModelType15.TEXT_LARGE, { prompt });
-    const parsedStep = parseKeyValueXml9(stepResultRaw);
-    if (!parsedStep) {
-      runtime.logger.warn(`[MultiStep] Failed to parse step result at iteration ${iterationCount}`);
-      traceActionResult.push({
-        data: { actionName: "parse_error" },
-        success: false,
-        error: "Failed to parse step result"
-      });
-      break;
-    }
-    const { thought, providers: providers2 = [], action, isFinish } = parsedStep;
-    if (isFinish === "true" || isFinish === true) {
-      runtime.logger.info(`[MultiStep] Task marked as complete at iteration ${iterationCount}`);
-      if (callback) {
-        await callback({
-          text: "",
-          thought: thought ?? ""
-        });
-      }
-      break;
-    }
-    if ((!providers2 || providers2.length === 0) && !action) {
-      runtime.logger.warn(`[MultiStep] No providers or action specified at iteration ${iterationCount}, forcing completion`);
-      break;
-    }
-    try {
-      for (const providerName of providers2) {
-        const provider = runtime.providers.find((p) => p.name === providerName);
-        if (!provider) {
-          runtime.logger.warn(`[MultiStep] Provider not found: ${providerName}`);
-          traceActionResult.push({
-            data: { actionName: providerName },
-            success: false,
-            error: `Provider not found: ${providerName}`
-          });
-          continue;
-        }
-        const providerResult = await provider.get(runtime, message, state);
-        if (!providerResult) {
-          runtime.logger.warn(`[MultiStep] Provider returned no result: ${providerName}`);
-          traceActionResult.push({
-            data: { actionName: providerName },
-            success: false,
-            error: `Provider returned no result`
-          });
-          continue;
-        }
-        const success = !!providerResult.text;
-        traceActionResult.push({
-          data: { actionName: providerName },
-          success,
-          text: success ? providerResult.text : undefined,
-          error: success ? undefined : providerResult?.text
-        });
-        if (callback) {
-          await callback({
-            text: `\uD83D\uDD0E Provider executed: ${providerName}`,
-            actions: [providerName],
-            thought: thought ?? ""
-          });
-        }
-      }
-      if (action) {
-        const actionContent = {
-          text: `\uD83D\uDD0E Executing action: ${action}`,
-          actions: [action],
-          thought: thought ?? ""
-        };
-        await runtime.processActions(message, [
-          {
-            id: v4_default(),
-            entityId: runtime.agentId,
-            roomId: message.roomId,
-            createdAt: Date.now(),
-            content: actionContent
-          }
-        ], state, async () => {
-          return [];
-        });
-        const cachedState = runtime.stateCache.get(`${message.id}_action_results`);
-        const actionResults = cachedState?.values?.actionResults || [];
-        const result = actionResults.length > 0 ? actionResults[0] : null;
-        const success = result?.success ?? false;
-        traceActionResult.push({
-          data: { actionName: action },
-          success,
-          text: result?.text,
-          values: result?.values,
-          error: success ? undefined : result?.text
-        });
-      }
-    } catch (err) {
-      runtime.logger.error({ err }, "[MultiStep] Error executing step");
-      traceActionResult.push({
-        data: { actionName: action || "unknown" },
-        success: false,
-        error: err instanceof Error ? err.message : String(err)
-      });
-    }
-  }
-  if (iterationCount >= maxIterations) {
-    runtime.logger.warn(`[MultiStep] Reached maximum iterations (${maxIterations}), forcing completion`);
-  }
-  accumulatedState = await runtime.composeState(message, ["RECENT_MESSAGES", "ACTION_STATE"]);
-  const summaryPrompt = composePromptFromState10({
-    state: accumulatedState,
-    template: runtime.character.templates?.multiStepSummaryTemplate || multiStepSummaryTemplate
-  });
-  const finalOutput = await runtime.useModel(ModelType15.TEXT_LARGE, { prompt: summaryPrompt });
-  const summary = parseKeyValueXml9(finalOutput);
-  let responseContent = null;
-  if (summary?.text) {
-    responseContent = {
-      actions: ["MULTI_STEP_SUMMARY"],
-      text: summary.text,
-      thought: summary.thought || "Final user-facing message after task completion.",
-      simple: true
-    };
-  }
-  const responseMessages = responseContent ? [
-    {
-      id: asUUID2(v4_default()),
-      entityId: runtime.agentId,
-      agentId: runtime.agentId,
-      content: responseContent,
-      roomId: message.roomId,
-      createdAt: Date.now()
-    }
-  ] : [];
-  return {
-    responseContent,
-    responseMessages,
-    state: accumulatedState,
-    mode: responseContent ? "simple" : "none"
-  };
-}
 var reactionReceivedHandler = async ({
   runtime,
   message
@@ -7861,50 +7317,6 @@ var reactionReceivedHandler = async ({
     runtime.logger.error({ error }, "[Bootstrap] Error in reaction handler:");
   }
 };
-var messageDeletedHandler = async ({
-  runtime,
-  message
-}) => {
-  try {
-    if (!message.id) {
-      runtime.logger.error("[Bootstrap] Cannot delete memory: message ID is missing");
-      return;
-    }
-    runtime.logger.info("[Bootstrap] Deleting memory for message", message.id, "from room", message.roomId);
-    await runtime.deleteMemory(message.id);
-    runtime.logger.debug({ messageId: message.id }, "[Bootstrap] Successfully deleted memory for message");
-  } catch (error) {
-    runtime.logger.error({ error }, "[Bootstrap] Error in message deleted handler:");
-  }
-};
-var channelClearedHandler = async ({
-  runtime,
-  roomId,
-  channelId,
-  memoryCount
-}) => {
-  try {
-    runtime.logger.info(`[Bootstrap] Clearing ${memoryCount} message memories from channel ${channelId} -> room ${roomId}`);
-    const memories = await runtime.getMemoriesByRoomIds({
-      tableName: "messages",
-      roomIds: [roomId]
-    });
-    let deletedCount = 0;
-    for (const memory of memories) {
-      if (memory.id) {
-        try {
-          await runtime.deleteMemory(memory.id);
-          deletedCount++;
-        } catch (error) {
-          runtime.logger.warn({ error, memoryId: memory.id }, `[Bootstrap] Failed to delete message memory ${memory.id}:`);
-        }
-      }
-    }
-    runtime.logger.info(`[Bootstrap] Successfully cleared ${deletedCount}/${memories.length} message memories from channel ${channelId}`);
-  } catch (error) {
-    runtime.logger.error({ error }, "[Bootstrap] Error in channel cleared handler:");
-  }
-};
 var postGeneratedHandler = async ({
   runtime,
   callback,
@@ -8146,24 +7558,6 @@ var controlMessageHandler = async ({
   }
 };
 var events = {
-  [EventType2.MESSAGE_RECEIVED]: [
-    async (payload) => {
-      if (!payload.callback) {
-        payload.runtime.logger.error("No callback provided for message");
-        return;
-      }
-      await messageReceivedHandler(payload);
-    }
-  ],
-  [EventType2.VOICE_MESSAGE_RECEIVED]: [
-    async (payload) => {
-      if (!payload.callback) {
-        payload.runtime.logger.error("No callback provided for voice message");
-        return;
-      }
-      await messageReceivedHandler(payload);
-    }
-  ],
   [EventType2.REACTION_RECEIVED]: [
     async (payload) => {
       await reactionReceivedHandler(payload);
@@ -8179,21 +7573,6 @@ var events = {
       payload.runtime.logger.debug(`[Bootstrap] Message sent: ${payload.message.content.text}`);
     }
   ],
-  [EventType2.MESSAGE_DELETED]: [
-    async (payload) => {
-      await messageDeletedHandler(payload);
-    }
-  ],
-  [EventType2.CHANNEL_CLEARED]: [
-    async (payload) => {
-      await channelClearedHandler({
-        runtime: payload.runtime,
-        roomId: payload.roomId,
-        channelId: payload.channelId,
-        memoryCount: payload.memoryCount
-      });
-    }
-  ],
   [EventType2.WORLD_JOINED]: [
     async (payload) => {
       await handleServerSync(payload);
@@ -8458,5 +7837,5 @@ export {
   actionStateProvider
 };
 
-//# debugId=0D5C974CD619FF2264756E2164756E21
+//# debugId=AFB990BB999AB3A964756E2164756E21
 //# sourceMappingURL=index.js.map