@elizaos/core 2.0.0-alpha.111 → 2.0.0-alpha.113

package/dist/node/index.node.js

@@ -54840,12 +54840,16 @@ rules[8]:
 - think briefly, then respond
 - actions execute in listed order
 - if replying, REPLY goes first
-- use IGNORE only by itself
+- use IGNORE or STOP only by themselves
 - include providers only when needed
 - use provider_hints from context when present instead of restating the same rules
 - if an action needs inputs, include a <params> block with the required fields
 - if a required param is unknown, ask for clarification in <text>
 
+control_actions:
+- STOP means the task is done and the agent should end the run without executing more actions
+- STOP is a terminal control action even if it is not listed in available actions
+
 fields[5]{name,meaning}:
 - thought | short plan
 - actions | ordered XML <action> elements
@@ -55026,6 +55030,46 @@ Here are the actions taken by the assistant to fulfill the request:
 </response>
 </output>
 `;
+var postActionDecisionTemplate = `<task>
+Continue helping the user after reviewing the latest action results.
+</task>
+
+context:
+{{providers}}
+
+recent conversation:
+{{recentMessages}}
+
+recent action results:
+{{actionResults}}
+
+rules[9]:
+- think briefly, then continue the task from the latest action results
+- actions execute in listed order
+- if replying, REPLY goes first
+- use IGNORE or STOP only by themselves
+- include providers only when needed
+- use provider_hints from context when present instead of restating the same rules
+- if an action needs inputs, include a <params> block with the required fields
+- if a required param is unknown, ask for clarification in <text>
+- if the task is complete, either reply to the user or use STOP to end the run
+- STOP is a terminal control action even if it is not listed in available actions
+
+<output>
+XML only. Return exactly one <response> block. No prose before or after it. No <think>.
+
+<response>
+  <thought>Your thought here</thought>
+  <actions>
+    <action>
+      <name>ACTION</name>
+    </action>
+  </actions>
+  <providers></providers>
+  <text>Your message here</text>
+  <simple>true</simple>
+</response>
+</output>`;
 var replyTemplate = `# Task: Generate dialog for the character {{agentName}}.
 
 {{providers}}
@@ -55873,7 +55917,8 @@ async function runAutonomyPostResponse(runtime2, autonomousMessage, fields, call
     await runtime2.createMemory(responseMemory, "messages");
   }
   const isSimple = responseContent.actions?.length === 1 && String(responseContent.actions[0]).toUpperCase() === "REPLY" && (!responseContent.providers || responseContent.providers.length === 0);
-  const mode = isSimple && responseContent.text ? "simple" : "actions";
+  const isStop = responseContent.actions?.length === 1 && String(responseContent.actions[0]).toUpperCase() === "STOP";
+  const mode = isStop ? "none" : isSimple && responseContent.text ? "simple" : "actions";
   if (mode === "simple" && callback) {
     if (responseContent.text) {
       responseContent.text = runtime2.redactSecrets(responseContent.text);
@@ -55888,7 +55933,7 @@ async function runAutonomyPostResponse(runtime2, autonomousMessage, fields, call
       return [];
     }, {});
   }
-  const didRespond = typeof responseContent.text === "string" && responseContent.text.trim().length > 0 || responseContent.actions && responseContent.actions.length > 0 && responseContent.actions[0]?.toUpperCase() !== "IGNORE";
+  const didRespond = typeof responseContent.text === "string" && responseContent.text.trim().length > 0 || responseContent.actions && responseContent.actions.length > 0 && responseContent.actions[0]?.toUpperCase() !== "IGNORE" && responseContent.actions[0]?.toUpperCase() !== "STOP";
   await runtime2.evaluate(autonomousMessage, state2, didRespond, async (content) => {
     runtime2.logger.debug({ src: "autonomy:facade", content }, "Autonomy evaluate callback");
     if (callback && content.text) {
@@ -79498,6 +79543,56 @@ var latestResponseIds = new Map;
 function isSimpleReplyResponse(responseContent) {
   return !!(responseContent?.actions && responseContent.actions.length === 1 && typeof responseContent.actions[0] === "string" && responseContent.actions[0].toUpperCase() === "REPLY");
 }
+function isStopResponse(responseContent) {
+  return !!(responseContent?.actions && responseContent.actions.length === 1 && typeof responseContent.actions[0] === "string" && responseContent.actions[0].toUpperCase() === "STOP");
+}
+function shouldContinueAfterActions(responseContent) {
+  return !!responseContent?.actions?.some((action) => {
+    if (typeof action !== "string")
+      return false;
+    const normalized = action.trim().toUpperCase();
+    return normalized !== "REPLY" && normalized !== "IGNORE" && normalized !== "STOP";
+  });
+}
+function formatActionResultsForPrompt(actionResults) {
+  if (actionResults.length === 0) {
+    return "No action results available.";
+  }
+  return [
+    "# Action Results",
+    ...actionResults.map((result, index) => {
+      const actionNameValue = result.data?.actionName;
+      const actionName = typeof actionNameValue === "string" ? actionNameValue : "Unknown Action";
+      const lines = [
+        `${index + 1}. ${actionName} - ${result.success === false ? "failed" : "succeeded"}`
+      ];
+      if (typeof result.text === "string" && result.text.trim()) {
+        lines.push(`Output: ${result.text.trim().slice(0, 2000)}`);
+      }
+      if (result.error) {
+        const errorText = result.error instanceof Error ? result.error.message : String(result.error);
+        lines.push(`Error: ${errorText.slice(0, 1000)}`);
+      }
+      return lines.join(`
+`);
+    })
+  ].join(`
+
+`);
+}
+function withActionResults(state2, actionResults) {
+  return {
+    ...state2,
+    values: {
+      ...state2.values,
+      actionResults: formatActionResultsForPrompt(actionResults)
+    },
+    data: {
+      ...state2.data,
+      actionResults
+    }
+  };
+}
 
 class DefaultMessageService {
   async handleMessage(runtime2, message2, callback, options) {
@@ -79510,6 +79605,7 @@ class DefaultMessageService {
         timeoutDuration: options?.timeoutDuration ?? 60 * 60 * 1000,
         useMultiStep: options?.useMultiStep ?? parseBooleanFromText2(String(runtime2.getSetting("USE_MULTI_STEP") ?? "")),
         maxMultiStepIterations: options?.maxMultiStepIterations ?? parseInt(String(runtime2.getSetting("MAX_MULTISTEP_ITERATIONS") ?? "6"), 10),
+        continueAfterActions: options?.continueAfterActions ?? parseBooleanFromText2(String(runtime2.getSetting("CONTINUE_AFTER_ACTIONS") ?? "true")),
         onStreamChunk: options?.onStreamChunk,
         shouldRespondModel: resolvedShouldRespondModel
       };
@@ -79787,6 +79883,7 @@ class DefaultMessageService {
       }
     }
     let shouldRespondToMessage = true;
+    let terminalDecision = null;
     const metadata = typeof message2.content.metadata === "object" && message2.content.metadata !== null ? message2.content.metadata : null;
     const isAutonomous = metadata?.isAutonomous === true;
     const autonomyMode = typeof metadata?.autonomyMode === "string" ? metadata.autonomyMode : null;
@@ -79851,8 +79948,11 @@ class DefaultMessageService {
           }
         });
         runtime2.logger.debug({ src: "service:message", responseObject }, "Parsed evaluation result");
-        const nonResponseActions = ["IGNORE", "NONE"];
+        const nonResponseActions = ["IGNORE", "NONE", "STOP"];
         const actionValue = responseObject?.action;
+        if (typeof actionValue === "string" && (actionValue.toUpperCase() === "IGNORE" || actionValue.toUpperCase() === "STOP")) {
+          terminalDecision = actionValue.toUpperCase();
+        }
         shouldRespondToMessage = typeof actionValue === "string" && !nonResponseActions.includes(actionValue.toUpperCase());
       }
     }
@@ -79925,6 +80025,20 @@ class DefaultMessageService {
             }
             return [];
           }, { onStreamChunk: opts.onStreamChunk });
+          if (opts.continueAfterActions && message2.id && shouldContinueAfterActions(responseContent)) {
+            const continuation = await this.runPostActionContinuation(runtime2, message2, state2, callback, opts, runtime2.getActionResults(message2.id));
+            if (continuation.responseMessages.length > 0) {
+              responseMessages = [
+                ...responseMessages,
+                ...continuation.responseMessages
+              ];
+            }
+            if (continuation.responseContent) {
+              responseContent = continuation.responseContent;
+              mode = continuation.mode;
+            }
+            state2 = continuation.state;
+          }
         }
       }
     } else {
@@ -79957,31 +80071,33 @@ class DefaultMessageService {
           mode: "none"
         };
       }
-      const ignoreContent = {
-        thought: "Agent decided not to respond to this message.",
-        actions: ["IGNORE"],
+      const terminalAction = terminalDecision ?? "IGNORE";
+      const terminalContent = {
+        thought: terminalAction === "STOP" ? "Agent decided to stop and end the run." : "Agent decided not to respond to this message.",
+        actions: [terminalAction],
         simple: true,
         inReplyTo: createUniqueUuid(runtime2, message2.id)
       };
       if (callback) {
-        await callback(ignoreContent);
+        await callback(terminalContent);
       }
-      const ignoreMemory = {
+      const terminalMemory = {
         id: asUUID(v4_default()),
         entityId: runtime2.agentId,
         agentId: runtime2.agentId,
-        content: ignoreContent,
+        content: terminalContent,
         roomId: message2.roomId,
         createdAt: Date.now()
       };
-      await runtime2.createMemory(ignoreMemory, "messages");
-      runtime2.logger.debug({ src: "service:message", memoryId: ignoreMemory.id }, "Saved ignore response to memory");
+      await runtime2.createMemory(terminalMemory, "messages");
+      runtime2.logger.debug({ src: "service:message", memoryId: terminalMemory.id }, "Saved terminal response to memory");
     }
     agentResponses.delete(message2.roomId);
     if (agentResponses.size === 0) {
       latestResponseIds.delete(runtime2.agentId);
     }
-    const runEvaluate = () => runtime2.evaluate(message2, state2, shouldRespondToMessage, async (content) => {
+    const didRespond = shouldRespondToMessage && !isStopResponse(responseContent);
+    const runEvaluate = () => runtime2.evaluate(message2, state2, didRespond, async (content) => {
       runtime2.logger.debug({ src: "service:message", content }, "Evaluate callback");
       if (responseContent) {
         responseContent.evalCallbacks = content;
@@ -80061,7 +80177,7 @@ class DefaultMessageService {
       duration: Date.now() - startTime
     });
     return {
-      didRespond: shouldRespondToMessage,
+      didRespond,
       responseContent,
       responseMessages,
       state: state2,
@@ -80270,15 +80386,99 @@ class DefaultMessageService {
     }));
     return processedAttachments;
   }
-  async runSingleShotCore(runtime2, message2, state2, opts, responseId) {
-    state2 = await runtime2.composeState(message2, ["ACTIONS"], false, false);
+  async runPostActionContinuation(runtime2, message2, state2, callback, opts, initialActionResults) {
+    if (!message2.id || initialActionResults.length === 0) {
+      return {
+        responseContent: null,
+        responseMessages: [],
+        state: state2,
+        mode: "none"
+      };
+    }
+    const traceActionResults = [...initialActionResults];
+    const responseMessages = [];
+    let accumulatedState = state2;
+    let responseContent = null;
+    for (let iterationCount = 0;iterationCount < opts.maxMultiStepIterations; iterationCount++) {
+      accumulatedState = withActionResults(await runtime2.composeState(message2, ["ACTIONS"], false, false), traceActionResults);
+      const continuation = await this.runSingleShotCore(runtime2, message2, accumulatedState, opts, asUUID(v4_default()), {
+        prompt: runtime2.character.templates?.postActionDecisionTemplate || postActionDecisionTemplate,
+        precomposedState: accumulatedState
+      });
+      if (!continuation.responseContent) {
+        runtime2.logger.debug({ src: "service:message", iteration: iterationCount + 1 }, "Post-action continuation produced no response");
+        break;
+      }
+      responseContent = continuation.responseContent;
+      if (message2.id) {
+        responseContent.inReplyTo = createUniqueUuid(runtime2, message2.id);
+      }
+      if (responseContent.providers && responseContent.providers.length > 0) {
+        accumulatedState = withActionResults(await runtime2.composeState(message2, responseContent.providers, false, false), traceActionResults);
+      } else {
+        accumulatedState = withActionResults(continuation.state, traceActionResults);
+      }
+      if (continuation.responseMessages.length > 0) {
+        for (const responseMemory of continuation.responseMessages) {
+          responseMemory.content = responseContent;
+          await runtime2.createMemory(responseMemory, "messages");
+          await runtime2.emitEvent("MESSAGE_SENT" /* MESSAGE_SENT */, {
+            runtime: runtime2,
+            message: responseMemory,
+            source: message2.content.source ?? "messageHandler"
+          });
+        }
+        responseMessages.push(...continuation.responseMessages);
+      }
+      if (continuation.mode === "simple") {
+        if (callback) {
+          if (responseContent.text) {
+            responseContent.text = runtime2.redactSecrets(responseContent.text);
+          }
+          await callback(responseContent);
+        }
+        break;
+      }
+      if (continuation.mode !== "actions") {
+        break;
+      }
+      await runtime2.processActions(message2, continuation.responseMessages, accumulatedState, async (content) => {
+        runtime2.logger.debug({ src: "service:message", content }, "Post-action callback");
+        if (responseContent) {
+          responseContent.actionCallbacks = content;
+        }
+        if (callback) {
+          return callback(content);
+        }
+        return [];
+      }, { onStreamChunk: opts.onStreamChunk });
+      if (!shouldContinueAfterActions(responseContent)) {
+        break;
+      }
+      const latestActionResults = runtime2.getActionResults(message2.id);
+      if (latestActionResults.length === 0) {
+        runtime2.logger.warn({ src: "service:message", iteration: iterationCount + 1 }, "Post-action continuation produced no new action results");
+        break;
+      }
+      traceActionResults.push(...latestActionResults);
+    }
+    accumulatedState = withActionResults(accumulatedState, traceActionResults);
+    return {
+      responseContent,
+      responseMessages,
+      state: accumulatedState,
+      mode: responseContent ? "simple" : "none"
+    };
+  }
+  async runSingleShotCore(runtime2, message2, state2, opts, responseId, overrides) {
+    state2 = overrides?.precomposedState ?? await runtime2.composeState(message2, ["ACTIONS"], false, false);
     if (!state2.values || !state2.values.actionNames) {
       runtime2.logger.warn({ src: "service:message" }, "actionNames data missing from state");
     }
     let responseContent = null;
     const streamingExtractor = opts.onStreamChunk ? new MarkableExtractor : undefined;
     const streamingCtx = streamingExtractor && opts.onStreamChunk ? createStreamingContext(streamingExtractor, opts.onStreamChunk, responseId) : undefined;
-    const prompt = runtime2.character.templates?.messageHandlerTemplate || messageHandlerTemplate;
+    const prompt = overrides?.prompt || runtime2.character.templates?.messageHandlerTemplate || messageHandlerTemplate;
     const parsedXml = await runtime2.dynamicPromptExecFromState({
       state: state2,
       params: {
@@ -80517,7 +80717,9 @@ Output ONLY the continuation, starting immediately after the last character abov
     }
     if (responseContent.actions && responseContent.actions.length > 1) {
       const isIgnore = (a) => typeof a === "string" && a.toUpperCase() === "IGNORE";
+      const isStop2 = (a) => typeof a === "string" && a.toUpperCase() === "STOP";
       const hasIgnore = responseContent.actions.some(isIgnore);
+      const hasStop = responseContent.actions.some(isStop2);
       if (hasIgnore) {
         if (!responseContent.text || responseContent.text.trim() === "") {
           responseContent.actions = ["IGNORE"];
@@ -80526,8 +80728,13 @@ Output ONLY the continuation, starting immediately after the last character abov
           responseContent.actions = filtered.length ? filtered : ["REPLY"];
         }
       }
+      if (hasStop) {
+        const filtered = responseContent.actions.filter((a) => !isStop2(a));
+        responseContent.actions = filtered.length ? filtered : ["STOP"];
+      }
     }
     const isSimple = isSimpleReplyResponse(responseContent);
+    const isStop = isStopResponse(responseContent);
     responseContent.simple = isSimple;
     responseContent.responseId = responseId;
     const responseMessages = [
@@ -80544,7 +80751,7 @@ Output ONLY the continuation, starting immediately after the last character abov
       responseContent,
       responseMessages,
       state: state2,
-      mode: isSimple && responseContent.text ? "simple" : "actions"
+      mode: isStop ? "none" : isSimple && responseContent.text ? "simple" : "actions"
     };
   }
   async runMultiStepCore(runtime2, message2, state2, callback, opts, responseId) {
@@ -90777,6 +90984,7 @@ export {
   processAttachments,
   prewarmUuidCache,
   postCreationTemplate,
+  postActionDecisionTemplate,
   pingServer,
   participantSchema,
   parseKeyValueXml,
@@ -91259,5 +91467,5 @@ export {
   ADD_CONTACT_TEMPLATE
 };
 
-//# debugId=263B3CD9FD646BA964756E2164756E21
+//# debugId=9450800FDA6F17B664756E2164756E21
 //# sourceMappingURL=index.node.js.map