@elizaos/plugin-bootstrap 1.0.0-beta.37 → 1.0.0-beta.40

package/dist/index.js

@@ -79,11 +79,10 @@ import {
   logger as logger17,
   messageHandlerTemplate,
   ModelType as ModelType13,
-  parseJSONObjectFromText as parseJSONObjectFromText4,
   postCreationTemplate,
-  providersTemplate,
   shouldRespondTemplate,
-  truncateToCompleteSentence
+  truncateToCompleteSentence,
+  parseKeyValueXml
 } from "@elizaos/core";
 
 // ../../node_modules/uuid/dist/esm/stringify.js
@@ -723,7 +722,10 @@ var ignoreAction = {
     return true;
   },
   description: "Call this action if ignoring the user. If the user is aggressive, creepy or is finished with the conversation, use this action. Or, if both you and the user have already said goodbye, use this action instead of saying bye again. Use IGNORE any time the conversation has naturally ended. Do not use IGNORE if the user has engaged directly, or if something went wrong an you need to tell them. Only ignore if the user should be ignored.",
-  handler: async (_runtime, _message) => {
+  handler: async (_runtime, _message, _state, _options, callback, responses) => {
+    if (callback && responses?.[0]?.content) {
+      await callback(responses[0].content);
+    }
     return true;
   },
   examples: [
@@ -3649,7 +3651,6 @@ import { addHeader as addHeader2, ChannelType as ChannelType3 } from "@elizaos/c
 var anxietyProvider = {
   name: "ANXIETY",
   description: "Social directions for the AI to follow based on the channel type",
-  dynamic: true,
   get: async (_runtime, message) => {
     const channelType = message.content.channelType;
     const groupAnxietyExamples = [
@@ -3842,7 +3843,7 @@ var characterProvider = {
     const bio = addHeader4(`# 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 ? `${character.name} is currently interested in ${topicString}` : "";
+    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 `;
@@ -3853,7 +3854,7 @@ var characterProvider = {
       return `${topic2}, `;
     }).join("")}` : "";
     const adjectiveString = character.adjectives && character.adjectives.length > 0 ? character.adjectives[Math.floor(Math.random() * character.adjectives.length)] : "";
-    const adjective = adjectiveString ? `${character.name} is ${adjectiveString}` : "";
+    const adjective = adjectiveString || "";
     const formattedCharacterPostExamples = !character.postExamples ? "" : character.postExamples.sort(() => 0.5 - Math.random()).map((post) => {
       const messageString = `${post}`;
       return messageString;
@@ -3921,7 +3922,9 @@ var characterProvider = {
       examples,
       system
     };
-    const text = [bio, adjective, topic, topics, adjective, directions, examples, system].filter(Boolean).join("\n\n");
+    const topicSentence = topicString ? `${character.name} is currently interested in ${topicString}` : "";
+    const adjectiveSentence = adjectiveString ? `${character.name} is ${adjectiveString}` : "";
+    const text = [bio, adjectiveSentence, topicSentence, topics, directions, examples, system].filter(Boolean).join("\n\n");
     return {
       values,
       data,
@@ -4184,14 +4187,17 @@ var factsProvider = {
         tableName: "facts",
         embedding,
         roomId: message.roomId,
-        count: 10
+        worldId: message.worldId,
+        count: 6,
+        query: message.content.text
       }),
-      runtime.getMemories({
+      runtime.searchMemories({
+        embedding,
+        query: message.content.text,
         tableName: "facts",
         roomId: message.roomId,
-        count: 10,
-        start: 0,
-        end: Date.now()
+        entityId: message.entityId,
+        count: 6
       })
     ]);
     const allFacts = [...relevantFacts, ...recentFactsData].filter(
@@ -4226,14 +4232,19 @@ var factsProvider = {
 import { addHeader as addHeader7 } from "@elizaos/core";
 var knowledgeProvider = {
   name: "KNOWLEDGE",
-  description: "Knowledge from the knowledge base that the agent knows",
+  description: "Knowledge from the knowledge base that the agent knows, retrieved whenever the agent needs to answer a question about their expertise.",
   dynamic: true,
   get: async (runtime, message) => {
     const knowledgeData = await runtime.getKnowledge(message);
-    const knowledge = knowledgeData && knowledgeData.length > 0 ? addHeader7(
+    const firstFiveKnowledgeItems = knowledgeData?.slice(0, 5);
+    let knowledge = (firstFiveKnowledgeItems && firstFiveKnowledgeItems.length > 0 ? addHeader7(
       "# Knowledge",
-      knowledgeData.map((knowledge2) => `- ${knowledge2.content.text}`).join("\n")
-    ) : "";
+      firstFiveKnowledgeItems.map((knowledge2) => `- ${knowledge2.content.text}`).join("\n")
+    ) : "") + "\n";
+    const tokenLength = 3.5;
+    if (knowledge.length > 4e3 * tokenLength) {
+      knowledge = knowledge.slice(0, 4e3 * tokenLength);
+    }
     return {
       data: {
         knowledge
@@ -5035,7 +5046,7 @@ var ScenarioService = class _ScenarioService extends Service {
     this.setupEventListeners();
   }
   static serviceType = "scenario";
-  capabilityDescription = "The agent is currently in a scenario testing environment. It can create rooms, send messages, and talk to other agents in a live interactive testing environment.";
+  capabilityDescription = "The agent is currently in a scenario testing environment. It can Create groups, send messages, and talk to other agents in a live interactive testing environment.";
   messageHandlers = /* @__PURE__ */ new Map();
   worlds = /* @__PURE__ */ new Map();
   activeActions = /* @__PURE__ */ new Map();
@@ -5387,6 +5398,10 @@ var TaskService = class _TaskService extends Service2 {
       const now = Date.now();
       for (const task of tasks) {
         let taskStartTime;
+        if (!task.tags?.includes("repeat")) {
+          await this.executeTask(task);
+          continue;
+        }
         if (typeof task.updatedAt === "number") {
           taskStartTime = task.updatedAt;
         } else if (task.metadata?.updatedAt && typeof task.metadata.updatedAt === "number") {
@@ -5401,6 +5416,13 @@ var TaskService = class _TaskService extends Service2 {
           await this.executeTask(task);
           continue;
         }
+        if (task.metadata.updatedAt === task.metadata.createdAt) {
+          if (task.tags?.includes("immediate")) {
+            logger16.debug("immediately running task", task.name);
+            await this.executeTask(task);
+            continue;
+          }
+        }
         if (now - taskStartTime >= updateIntervalMs) {
           logger16.debug(
             `Executing task ${task.name} - interval of ${updateIntervalMs}ms has elapsed`
@@ -5428,9 +5450,6 @@ var TaskService = class _TaskService extends Service2 {
         logger16.debug(`No worker found for task type: ${task.name}`);
         return;
       }
-      logger16.debug(`Executing task ${task.name} (${task.id})`);
-      await worker.execute(this.runtime, task.metadata || {}, task);
-      logger16.debug("task.tags are", task.tags);
       if (task.tags?.includes("repeat")) {
         await this.runtime.updateTask(task.id, {
           metadata: {
@@ -5439,7 +5458,10 @@ var TaskService = class _TaskService extends Service2 {
           }
         });
         logger16.debug(`Updated repeating task ${task.name} (${task.id}) with new timestamp`);
-      } else {
+      }
+      logger16.debug(`Executing task ${task.name} (${task.id})`);
+      await worker.execute(this.runtime, task.metadata || {}, task);
+      if (!task.tags?.includes("repeat")) {
         await this.runtime.deleteTask(task.id);
         logger16.debug(`Deleted non-repeating task ${task.name} (${task.id}) after execution`);
       }
@@ -5550,16 +5572,15 @@ var messageReceivedHandler = async ({
         return;
       }
       let state = await runtime.composeState(message, [
-        "PROVIDERS",
+        "ANXIETY",
         "SHOULD_RESPOND",
+        "ENTITIES",
         "CHARACTER",
-        "RECENT_MESSAGES",
-        "ENTITIES"
+        "RECENT_MESSAGES"
       ]);
       const room = await runtime.getRoom(message.roomId);
       const shouldSkipShouldRespond = room?.type === ChannelType10.DM || room?.type === ChannelType10.VOICE_DM || room?.type === ChannelType10.SELF;
       let shouldRespond = true;
-      let providers = [];
       if (!shouldSkipShouldRespond) {
         const shouldRespondPrompt = composePromptFromState9({
           state,
@@ -5576,32 +5597,15 @@ var messageReceivedHandler = async ({
         logger17.debug(`*** Should Respond Response for ${runtime.character.name} ***
 `, response);
         logger17.debug(`*** Raw Response Type: ${typeof response} ***`);
-        let processedResponse = response;
-        if (typeof response === "string" && response.includes("```")) {
-          logger17.debug("*** Response contains code block markers, attempting to clean up ***");
-          processedResponse = response.replace(/```json\n|\n```|```/g, "");
-          logger17.debug("*** Processed Response ***\n", processedResponse);
-        }
-        const responseObject = parseJSONObjectFromText4(processedResponse);
-        logger17.debug("*** Parsed Response Object ***", responseObject);
+        const responseObject = parseKeyValueXml(response);
+        logger17.debug("*** Parsed XML Response Object ***", responseObject);
         shouldRespond = responseObject?.action && responseObject.action === "RESPOND";
-        providers = responseObject?.providers || [];
       } else {
-        const providersPrompt = composePromptFromState9({
-          state,
-          template: runtime.character.templates?.providersTemplate || providersTemplate
-        });
-        const response = await runtime.useModel(ModelType13.TEXT_SMALL, {
-          prompt: providersPrompt
-        });
-        const responseObject = parseJSONObjectFromText4(response);
-        providers = responseObject?.providers || [];
+        shouldRespond = true;
       }
-      logger17.debug("*** Should Respond ***", shouldRespond);
-      logger17.debug("*** Providers Value ***", providers);
-      state = await runtime.composeState(message, null, providers);
       let responseMessages = [];
       if (shouldRespond) {
+        state = await runtime.composeState(message);
         const prompt = composePromptFromState9({
           state,
           template: runtime.character.templates?.messageHandlerTemplate || messageHandlerTemplate
@@ -5610,13 +5614,26 @@ var messageReceivedHandler = async ({
         let retries = 0;
         const maxRetries = 3;
         while (retries < maxRetries && (!responseContent?.thought || !responseContent?.actions)) {
-          const response = await runtime.useModel(ModelType13.TEXT_LARGE, {
+          let response = await runtime.useModel(ModelType13.TEXT_LARGE, {
             prompt
           });
-          responseContent = parseJSONObjectFromText4(response);
+          logger17.debug("*** Raw LLM Response ***\n", response);
+          const parsedXml = parseKeyValueXml(response);
+          logger17.debug("*** Parsed XML Content ***\n", parsedXml);
+          if (parsedXml) {
+            responseContent = {
+              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) {
-            logger17.warn("*** Missing required fields, retrying... ***");
+          if (!responseContent?.thought || !responseContent?.actions) {
+            logger17.warn("*** Missing required fields (thought or actions), retrying... ***");
           }
         }
         const currentResponseId = agentResponses.get(message.roomId);
@@ -5628,26 +5645,63 @@ var messageReceivedHandler = async ({
         }
         if (responseContent) {
           responseContent.inReplyTo = createUniqueUuid4(runtime, message.id);
-          responseMessages = [
-            {
-              id: asUUID(v4_default()),
-              entityId: runtime.agentId,
-              agentId: runtime.agentId,
-              content: responseContent,
-              roomId: message.roomId,
-              createdAt: Date.now()
-            }
-          ];
-          callback(responseContent);
+          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 > 0) {
+          state = await runtime.composeState(message, null, [...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 {
+        logger17.debug("Agent decided not to respond (shouldRespond is false).");
+        const currentResponseId = agentResponses.get(message.roomId);
+        if (currentResponseId !== responseId) {
+          logger17.info(
+            `Ignore response discarded - newer message being processed for agent: ${runtime.agentId}, room: ${message.roomId}`
+          );
+          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: ignoreContent,
+          roomId: message.roomId,
+          createdAt: Date.now()
+        };
+        await runtime.createMemory(ignoreMemory, "messages");
+        logger17.debug("Saved ignore response to memory", { memoryId: ignoreMemory.id });
         agentResponses.delete(message.roomId);
         if (agentResponses.size === 0) {
           latestResponseIds.delete(runtime.agentId);
         }
-        await runtime.processActions(message, responseMessages, state, callback);
       }
       onComplete?.();
-      await runtime.evaluate(message, state, shouldRespond, callback, responseMessages);
       await runtime.emitEvent(EventType2.RUN_ENDED, {
         runtime,
         runId,
@@ -5727,21 +5781,63 @@ var postGeneratedHandler = async ({
     entityId: runtime.agentId,
     agentId: runtime.agentId,
     roomId,
-    content: {}
+    content: {},
+    metadata: {
+      entityName: runtime.character.name,
+      type: "message"
+    }
   };
-  const state = await runtime.composeState(message, null, [
+  let state = await runtime.composeState(message, null, [
+    "PROVIDERS",
     "CHARACTER",
-    "RECENT_MESSAGES",
+    //'RECENT_MESSAGES',
     "ENTITIES"
   ]);
+  const entity = await runtime.getEntityById(runtime.agentId);
+  if (entity?.metadata?.twitter?.userName) {
+    state.values.twitterUserName = entity?.metadata?.twitter?.userName;
+  }
+  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)) {
+    const response = await runtime.useModel(ModelType13.TEXT_SMALL, {
+      prompt
+    });
+    const parsedXml = parseKeyValueXml(response);
+    if (parsedXml) {
+      responseContent = {
+        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) {
+      logger17.warn("*** Missing required fields, retrying... ***");
+    }
+  }
+  state = await runtime.composeState(message, responseContent.providers);
   const postPrompt = composePromptFromState9({
     state,
     template: runtime.character.templates?.postCreationTemplate || postCreationTemplate
   });
-  const jsonResponse = await runtime.useModel(ModelType13.OBJECT_LARGE, {
-    prompt: postPrompt,
-    output: "no-schema"
+  const xmlResponseText = await runtime.useModel(ModelType13.TEXT_LARGE, {
+    prompt: postPrompt
   });
+  const parsedXmlResponse = parseKeyValueXml(xmlResponseText);
+  if (!parsedXmlResponse) {
+    logger17.error("Failed to parse XML response for post creation. Raw response:", xmlResponseText);
+    return;
+  }
   function cleanupPostText(text) {
     let cleanedText2 = text.replace(/^['"](.*)['"]$/, "$1");
     cleanedText2 = cleanedText2.replaceAll(/\\n/g, "\n\n");
@@ -5750,7 +5846,40 @@ var postGeneratedHandler = async ({
     }
     return cleanedText2;
   }
-  const cleanedText = cleanupPostText(jsonResponse.post);
+  const cleanedText = cleanupPostText(parsedXmlResponse.post || "");
+  const RM = state.providerData?.find((pd) => pd.providerName === "RECENT_MESSAGES");
+  if (RM) {
+    for (const m of RM.data.recentMessages) {
+      if (cleanedText === m.content.text) {
+        logger17.log("we've already recently posted that, retrying", cleanedText);
+        postGeneratedHandler({
+          runtime,
+          callback,
+          worldId,
+          userId,
+          roomId,
+          source
+        });
+        return;
+      }
+    }
+  }
+  const oaiRefusalRegex = /((i\s+do\s+not|i'm\s+not)\s+(feel\s+)?comfortable\s+generating\s+that\s+type\s+of\s+content)|(inappropriate|explicit|respectful|offensive|guidelines|aim\s+to\s+(be\s+)?helpful|communicate\s+respectfully)/i;
+  const anthropicRefusalRegex = /(i'?m\s+unable\s+to\s+help\s+with\s+that\s+request|due\s+to\s+safety\s+concerns|that\s+may\s+violate\s+(our\s+)?guidelines|provide\s+helpful\s+and\s+safe\s+responses|let'?s\s+try\s+a\s+different\s+direction|goes\s+against\s+(our\s+)?use\s+case\s+policies|ensure\s+safe\s+and\s+responsible\s+use)/i;
+  const googleRefusalRegex = /(i\s+can'?t\s+help\s+with\s+that|that\s+goes\s+against\s+(our\s+)?(policy|policies)|i'?m\s+still\s+learning|response\s+must\s+follow\s+(usage|safety)\s+policies|i'?ve\s+been\s+designed\s+to\s+avoid\s+that)/i;
+  const generalRefusalRegex = /(response\s+was\s+withheld|content\s+was\s+filtered|this\s+request\s+cannot\s+be\s+completed|violates\s+our\s+safety\s+policy|content\s+is\s+not\s+available)/i;
+  if (oaiRefusalRegex.test(cleanedText) || anthropicRefusalRegex.test(cleanedText) || googleRefusalRegex.test(cleanedText) || generalRefusalRegex.test(cleanedText)) {
+    logger17.log("got prompt moderation refusal, retrying", cleanedText);
+    postGeneratedHandler({
+      runtime,
+      callback,
+      worldId,
+      userId,
+      roomId,
+      source
+    });
+    return;
+  }
   const responseMessages = [
     {
       id: v4_default(),
@@ -5760,7 +5889,7 @@ var postGeneratedHandler = async ({
         text: cleanedText,
         source,
         channelType: ChannelType10.FEED,
-        thought: jsonResponse.thought || "",
+        thought: parsedXmlResponse.thought || "",
         type: "post"
       },
       roomId: message.roomId,
@@ -5772,11 +5901,11 @@ var postGeneratedHandler = async ({
   }
 };
 var syncSingleUser = async (entityId, runtime, serverId, channelId, type, source) => {
-  const entity = await runtime.getEntityById(entityId);
-  logger17.info(`Syncing user: ${entity.metadata[source].username || entity.id}`);
   try {
+    const entity = await runtime.getEntityById(entityId);
+    logger17.info(`Syncing user: ${entity?.metadata[source]?.username || entityId}`);
     if (!channelId) {
-      logger17.warn(`Cannot sync user ${entity.id} without a valid channelId`);
+      logger17.warn(`Cannot sync user ${entity?.id} without a valid channelId`);
       return;
     }
     const roomId = createUniqueUuid4(runtime, channelId);
@@ -5784,15 +5913,15 @@ var syncSingleUser = async (entityId, runtime, serverId, channelId, type, source
     await runtime.ensureConnection({
       entityId,
       roomId,
-      userName: entity.metadata[source].username || entity.id,
-      name: entity.metadata[source].name || entity.metadata[source].username || `User${entity.id}`,
+      userName: entity?.metadata[source].username || entityId,
+      name: entity?.metadata[source].name || entity?.metadata[source].username || `User${entityId}`,
       source,
       channelId,
       serverId,
       type,
       worldId
     });
-    logger17.success(`Successfully synced user: ${entity.id}`);
+    logger17.success(`Successfully synced user: ${entity?.id}`);
   } catch (error) {
     logger17.error(`Error syncing user: ${error instanceof Error ? error.message : String(error)}`);
   }