@elizaos/plugin-bootstrap 1.0.0-beta.50 → 1.0.0-beta.52

package/dist/index.js

@@ -1307,6 +1307,25 @@ Response format should be formatted in a valid JSON block like this:
 \`\`\`
 
 Your response should include the valid JSON block and nothing else.`;
+function getFirstAvailableField(obj, fields) {
+  for (const field of fields) {
+    if (typeof obj[field] === "string" && obj[field].trim() !== "") {
+      return obj[field];
+    }
+  }
+  return null;
+}
+function extractReplyContent(response, replyFieldKeys) {
+  const hasReplyAction = response.content.actions?.includes("REPLY");
+  const text = getFirstAvailableField(response.content, replyFieldKeys);
+  if (!hasReplyAction || !text) return null;
+  return {
+    ...response.content,
+    thought: response.content.thought,
+    text,
+    actions: ["REPLY"]
+  };
+}
 var replyAction = {
   name: "REPLY",
   similes: ["GREET", "REPLY_TO_MESSAGE", "SEND_REPLY", "RESPOND", "RESPONSE"],
@@ -1315,17 +1334,11 @@ var replyAction = {
     return true;
   },
   handler: async (runtime, message, state, _options, callback, responses) => {
-    const existingResponses = responses?.filter(
-      (response2) => response2.content.actions?.includes("REPLY") && response2.content.message
-    );
-    if (existingResponses && existingResponses.length > 0) {
-      for (const response2 of existingResponses) {
-        const responseContent2 = {
-          thought: response2.content.thought || "Using provided text for reply",
-          text: response2.content.message,
-          actions: ["REPLY"]
-        };
-        await callback(responseContent2);
+    const replyFieldKeys = ["message", "text"];
+    const existingReplies = responses?.map((r) => extractReplyContent(r, replyFieldKeys)).filter((reply) => reply !== null) ?? [];
+    if (existingReplies.length > 0) {
+      for (const reply of existingReplies) {
+        await callback(reply);
       }
       return;
     }
@@ -1337,7 +1350,7 @@ var replyAction = {
       state,
       template: replyTemplate
     });
-    const response = await runtime.useModel(ModelType4.OBJECT_SMALL, {
+    const response = await runtime.useModel(ModelType4.OBJECT_LARGE, {
       prompt
     });
     const responseContent = {
@@ -5665,237 +5678,244 @@ var messageReceivedHandler = async ({
   callback,
   onComplete
 }) => {
-  logger19.info(`[Bootstrap] Message received from ${message.entityId} in room ${message.roomId}`);
-  const responseId = v4_default();
-  if (!latestResponseIds.has(runtime.agentId)) {
-    latestResponseIds.set(runtime.agentId, /* @__PURE__ */ new Map());
-  }
-  const agentResponses = latestResponseIds.get(runtime.agentId);
-  if (!agentResponses) {
-    throw new Error("Agent responses map not found");
-  }
-  agentResponses.set(message.roomId, responseId);
-  const runId = asUUID(v4_default());
-  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"
-  });
   const timeoutDuration = 60 * 60 * 1e3;
   let timeoutId = void 0;
-  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) {
-        logger19.debug(`[Bootstrap] Skipping message from self (${runtime.agentId})`);
-        throw new Error("Message is from the agent itself");
-      }
-      logger19.debug(
-        `[Bootstrap] Processing message: ${truncateToCompleteSentence(message.content.text || "", 50)}...`
-      );
-      logger19.debug("[Bootstrap] Saving message to memory and embeddings");
-      await Promise.all([
-        runtime.addEmbeddingToMemory(message),
-        runtime.createMemory(message, "messages")
-      ]);
-      const agentUserState = await runtime.getParticipantUserState(message.roomId, runtime.agentId);
-      if (agentUserState === "MUTED" && !message.content.text?.toLowerCase().includes(runtime.character.name.toLowerCase())) {
-        logger19.debug(`[Bootstrap] Ignoring muted room ${message.roomId}`);
-        return;
-      }
-      let state = await runtime.composeState(message, [
-        "ANXIETY",
-        "SHOULD_RESPOND",
-        "ENTITIES",
-        "CHARACTER",
-        "RECENT_MESSAGES"
-      ]);
-      const room = await runtime.getRoom(message.roomId);
-      const shouldSkipShouldRespond = room?.type === ChannelType10.DM || room?.type === ChannelType10.VOICE_DM || room?.type === ChannelType10.SELF || room?.type === ChannelType10.API;
-      let shouldRespond = true;
-      if (!shouldSkipShouldRespond) {
-        const shouldRespondPrompt = composePromptFromState9({
-          state,
-          template: runtime.character.templates?.shouldRespondTemplate || shouldRespondTemplate
+  try {
+    logger19.info(`[Bootstrap] Message received from ${message.entityId} in room ${message.roomId}`);
+    const responseId = v4_default();
+    if (!latestResponseIds.has(runtime.agentId)) {
+      latestResponseIds.set(runtime.agentId, /* @__PURE__ */ new Map());
+    }
+    const agentResponses = latestResponseIds.get(runtime.agentId);
+    if (!agentResponses) {
+      throw new Error("Agent responses map not found");
+    }
+    agentResponses.set(message.roomId, responseId);
+    const runId = asUUID(v4_default());
+    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"
+    });
+    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) {
+          logger19.debug(`[Bootstrap] Skipping message from self (${runtime.agentId})`);
+          throw new Error("Message is from the agent itself");
+        }
         logger19.debug(
-          `[Bootstrap] Evaluating response for ${runtime.character.name}
-Prompt: ${shouldRespondPrompt}`
+          `[Bootstrap] Processing message: ${truncateToCompleteSentence(message.content.text || "", 50)}...`
         );
-        const response = await runtime.useModel(ModelType13.TEXT_SMALL, {
-          prompt: shouldRespondPrompt
-        });
-        logger19.debug(`[Bootstrap] Response evaluation for ${runtime.character.name}:
-${response}`);
-        logger19.debug(`[Bootstrap] Response type: ${typeof response}`);
-        const responseObject = parseKeyValueXml(response);
-        logger19.debug("[Bootstrap] Parsed response:", responseObject);
-        shouldRespond = responseObject?.action && responseObject.action === "RESPOND";
-      } else {
-        shouldRespond = true;
-      }
-      let responseMessages = [];
-      if (shouldRespond) {
-        state = await runtime.composeState(message);
-        const prompt = composePromptFromState9({
-          state,
-          template: runtime.character.templates?.messageHandlerTemplate || messageHandlerTemplate
-        });
-        let responseContent = null;
-        let retries = 0;
-        const maxRetries = 3;
-        while (retries < maxRetries && (!responseContent?.thought || !responseContent?.actions)) {
-          let response = await runtime.useModel(ModelType13.TEXT_LARGE, {
-            prompt
+        logger19.debug("[Bootstrap] Saving message to memory and embeddings");
+        await Promise.all([
+          runtime.addEmbeddingToMemory(message),
+          runtime.createMemory(message, "messages")
+        ]);
+        const agentUserState = await runtime.getParticipantUserState(
+          message.roomId,
+          runtime.agentId
+        );
+        if (agentUserState === "MUTED" && !message.content.text?.toLowerCase().includes(runtime.character.name.toLowerCase())) {
+          logger19.debug(`[Bootstrap] Ignoring muted room ${message.roomId}`);
+          return;
+        }
+        let state = await runtime.composeState(
+          message,
+          ["ANXIETY", "SHOULD_RESPOND", "ENTITIES", "CHARACTER", "RECENT_MESSAGES"],
+          true
+        );
+        const room = await runtime.getRoom(message.roomId);
+        const shouldSkipShouldRespond = room?.type === ChannelType10.DM || room?.type === ChannelType10.VOICE_DM || room?.type === ChannelType10.SELF || room?.type === ChannelType10.API || room?.source === "client_chat";
+        logger19.debug(
+          `[Bootstrap] Skipping shouldRespond check for ${runtime.character.name} because ${room?.type} ${room?.source}`
+        );
+        let shouldRespond = true;
+        if (!shouldSkipShouldRespond) {
+          const shouldRespondPrompt = composePromptFromState9({
+            state,
+            template: runtime.character.templates?.shouldRespondTemplate || shouldRespondTemplate
+          });
+          logger19.debug(
+            `[Bootstrap] Evaluating response for ${runtime.character.name}
+Prompt: ${shouldRespondPrompt}`
+          );
+          const response = await runtime.useModel(ModelType13.TEXT_SMALL, {
+            prompt: shouldRespondPrompt
+          });
+          logger19.debug(
+            `[Bootstrap] Response evaluation for ${runtime.character.name}:
+${response}`
+          );
+          logger19.debug(`[Bootstrap] Response type: ${typeof response}`);
+          const responseObject = parseKeyValueXml(response);
+          logger19.debug("[Bootstrap] Parsed response:", responseObject);
+          shouldRespond = responseObject?.action && responseObject.action === "RESPOND";
+        } else {
+          shouldRespond = true;
+        }
+        let responseMessages = [];
+        if (shouldRespond) {
+          state = await runtime.composeState(message);
+          const prompt = composePromptFromState9({
+            state,
+            template: runtime.character.templates?.messageHandlerTemplate || messageHandlerTemplate
           });
-          logger19.debug("[Bootstrap] *** Raw LLM Response ***\n", response);
-          const parsedXml = parseKeyValueXml(response);
-          logger19.debug("[Bootstrap] *** Parsed XML Content ***\n", parsedXml);
-          if (parsedXml) {
-            responseContent = {
-              ...parsedXml,
-              thought: parsedXml.thought || "",
-              actions: parsedXml.actions || ["IGNORE"],
-              providers: parsedXml.providers || [],
-              text: parsedXml.text || "",
-              simple: parsedXml.simple || false
+          let responseContent = null;
+          let retries = 0;
+          const maxRetries = 3;
+          while (retries < maxRetries && (!responseContent?.thought || !responseContent?.actions)) {
+            let response = await runtime.useModel(ModelType13.TEXT_LARGE, {
+              prompt
+            });
+            logger19.debug("[Bootstrap] *** Raw LLM Response ***\n", response);
+            const parsedXml = parseKeyValueXml(response);
+            logger19.debug("[Bootstrap] *** Parsed XML Content ***\n", parsedXml);
+            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) {
+              logger19.warn(
+                "[Bootstrap] *** Missing required fields (thought or actions), retrying... ***"
+              );
+            }
+          }
+          const currentResponseId = agentResponses.get(message.roomId);
+          if (currentResponseId !== responseId) {
+            logger19.info(
+              `Response discarded - newer message being processed for agent: ${runtime.agentId}, room: ${message.roomId}`
+            );
+            return;
+          }
+          if (responseContent && message.id) {
+            responseContent.inReplyTo = createUniqueUuid4(runtime, message.id);
+            const responseMesssage = {
+              id: asUUID(v4_default()),
+              entityId: runtime.agentId,
+              agentId: runtime.agentId,
+              content: responseContent,
+              roomId: message.roomId,
+              createdAt: Date.now()
             };
+            responseMessages = [responseMesssage];
+          }
+          agentResponses.delete(message.roomId);
+          if (agentResponses.size === 0) {
+            latestResponseIds.delete(runtime.agentId);
+          }
+          if (responseContent?.providers?.length && responseContent?.providers?.length > 0) {
+            state = await runtime.composeState(message, responseContent?.providers || []);
+          }
+          if (responseContent && responseContent.simple && responseContent.text && (responseContent.actions?.length === 0 || responseContent.actions?.length === 1 && responseContent.actions[0].toUpperCase() === "REPLY")) {
+            await callback(responseContent);
           } else {
-            responseContent = null;
+            await runtime.processActions(message, responseMessages, state, callback);
           }
-          retries++;
-          if (!responseContent?.thought || !responseContent?.actions) {
-            logger19.warn(
-              "[Bootstrap] *** Missing required fields (thought or actions), retrying... ***"
+          await runtime.evaluate(message, state, shouldRespond, callback, responseMessages);
+        } else {
+          logger19.debug("[Bootstrap] Agent decided not to respond (shouldRespond is false).");
+          const currentResponseId = agentResponses.get(message.roomId);
+          if (currentResponseId !== responseId) {
+            logger19.info(
+              `Ignore response discarded - newer message being processed for agent: ${runtime.agentId}, room: ${message.roomId}`
             );
+            return;
           }
-        }
-        const currentResponseId = agentResponses.get(message.roomId);
-        if (currentResponseId !== responseId) {
-          logger19.info(
-            `Response discarded - newer message being processed for agent: ${runtime.agentId}, room: ${message.roomId}`
-          );
-          return;
-        }
-        if (responseContent && message.id) {
-          responseContent.inReplyTo = createUniqueUuid4(runtime, message.id);
-          const responseMesssage = {
+          if (!message.id) {
+            logger19.error("[Bootstrap] Message ID is missing, cannot create ignore response.");
+            return;
+          }
+          const ignoreContent = {
+            thought: "Agent decided not to respond to this message.",
+            actions: ["IGNORE"],
+            simple: true,
+            // Treat it as simple for callback purposes
+            inReplyTo: createUniqueUuid4(runtime, message.id)
+            // Reference original message
+          };
+          await callback(ignoreContent);
+          const ignoreMemory = {
             id: asUUID(v4_default()),
             entityId: runtime.agentId,
             agentId: runtime.agentId,
-            content: responseContent,
+            content: ignoreContent,
             roomId: message.roomId,
             createdAt: Date.now()
           };
-          responseMessages = [responseMesssage];
-        }
-        agentResponses.delete(message.roomId);
-        if (agentResponses.size === 0) {
-          latestResponseIds.delete(runtime.agentId);
-        }
-        if (responseContent?.providers?.length && responseContent?.providers?.length > 0) {
-          state = await runtime.composeState(message, responseContent?.providers || []);
-        }
-        if (responseContent && responseContent.simple && responseContent.text && (responseContent.actions?.length === 0 || responseContent.actions?.length === 1 && responseContent.actions[0].toUpperCase() === "REPLY")) {
-          await callback(responseContent);
-        } else {
-          await runtime.processActions(message, responseMessages, state, callback);
-        }
-        await runtime.evaluate(message, state, shouldRespond, callback, responseMessages);
-      } else {
-        logger19.debug("[Bootstrap] Agent decided not to respond (shouldRespond is false).");
-        const currentResponseId = agentResponses.get(message.roomId);
-        if (currentResponseId !== responseId) {
-          logger19.info(
-            `Ignore response discarded - newer message being processed for agent: ${runtime.agentId}, room: ${message.roomId}`
-          );
-          return;
-        }
-        if (!message.id) {
-          logger19.error("[Bootstrap] Message ID is missing, cannot create ignore response.");
-          return;
+          await runtime.createMemory(ignoreMemory, "messages");
+          logger19.debug("[Bootstrap] Saved ignore response to memory", {
+            memoryId: ignoreMemory.id
+          });
+          agentResponses.delete(message.roomId);
+          if (agentResponses.size === 0) {
+            latestResponseIds.delete(runtime.agentId);
+          }
         }
-        const ignoreContent = {
-          thought: "Agent decided not to respond to this message.",
-          actions: ["IGNORE"],
-          simple: true,
-          // Treat it as simple for callback purposes
-          inReplyTo: createUniqueUuid4(runtime, message.id)
-          // Reference original message
-        };
-        await callback(ignoreContent);
-        const ignoreMemory = {
-          id: asUUID(v4_default()),
-          entityId: runtime.agentId,
-          agentId: runtime.agentId,
-          content: ignoreContent,
+        await runtime.emitEvent(EventType2.RUN_ENDED, {
+          runtime,
+          runId,
+          messageId: message.id,
           roomId: message.roomId,
-          createdAt: Date.now()
-        };
-        await runtime.createMemory(ignoreMemory, "messages");
-        logger19.debug("[Bootstrap] Saved ignore response to memory", { memoryId: ignoreMemory.id });
-        agentResponses.delete(message.roomId);
-        if (agentResponses.size === 0) {
-          latestResponseIds.delete(runtime.agentId);
-        }
+          entityId: message.entityId,
+          startTime,
+          status: "completed",
+          endTime: Date.now(),
+          duration: Date.now() - startTime,
+          source: "messageHandler"
+        });
+      } catch (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"
+        });
       }
-      onComplete?.();
-      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"
-      });
-    } catch (error) {
-      onComplete?.();
-      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"
-      });
-    }
-  })();
-  try {
+    })();
     await Promise.race([processingPromise, timeoutPromise]);
   } finally {
     clearTimeout(timeoutId);
+    onComplete?.();
   }
 };
 var reactionReceivedHandler = async ({
@@ -6229,7 +6249,8 @@ var events = {
       await messageReceivedHandler({
         runtime: payload.runtime,
         message: payload.message,
-        callback: payload.callback
+        callback: payload.callback,
+        onComplete: payload.onComplete
       });
     }
   ],