@elizaos/ui 2.0.0-alpha.197 → 2.0.0-alpha.201

package/packages/typescript/src/services/message.js

@@ -147,21 +147,43 @@ export function extractStandaloneActionParams(actionNames, parsedXml) {
     }
     return fragments.join("\n");
 }
-function normalizePlannerActions(parsedXml, runtime) {
-    const normalizedActions = (() => {
+function unwrapPlannerIdentifier(value) {
+    const trimmed = value.trim().replace(/^["'`]+|["'`]+$/g, "");
+    if (!trimmed) {
+        return "";
+    }
+    const nameMatch = trimmed.match(/^<name\b[^>]*>([\s\S]*?)<\/name>$/i);
+    if (nameMatch) {
+        return nameMatch[1].trim();
+    }
+    const actionMatch = trimmed.match(/^<action\b[^>]*>([\s\S]*?)<\/action>$/i);
+    if (!actionMatch) {
+        return trimmed;
+    }
+    const inner = actionMatch[1].trim();
+    if (!inner) {
+        return "";
+    }
+    const nestedNameMatch = inner.match(/<name\b[^>]*>([\s\S]*?)<\/name>/i);
+    if (nestedNameMatch) {
+        return nestedNameMatch[1].trim();
+    }
+    return /<[A-Za-z][^>]*>/.test(inner) ? trimmed : inner;
+}
+export function extractPlannerActionNames(parsedXml) {
+    return (() => {
         if (typeof parsedXml.actions === "string") {
             const actionsXml = parsedXml.actions;
-            if (actionsXml.includes("<action>") || actionsXml.includes("<action ")) {
+            if (/<action\b[^>]*>/i.test(actionsXml)) {
                 const actionEntries = [];
-                for (const match of actionsXml.matchAll(/<action>([\s\S]*?)<\/action>/g)) {
+                for (const match of actionsXml.matchAll(/<action\b[^>]*>([\s\S]*?)<\/action>/gi)) {
                     const inner = match[1];
-                    const nameMatch = inner.match(/<name>([\s\S]*?)<\/name>/);
-                    const paramsMatch = inner.match(/<params>([\s\S]*?)<\/params>/);
-                    if (nameMatch) {
-                        const name = nameMatch[1].trim();
-                        const paramsXml = paramsMatch ? paramsMatch[1].trim() : undefined;
-                        if (name)
-                            actionEntries.push({ name, paramsXml });
+                    const nameMatch = inner.match(/<name\b[^>]*>([\s\S]*?)<\/name>/i);
+                    const paramsMatch = inner.match(/<params\b[^>]*>([\s\S]*?)<\/params>/i);
+                    const name = unwrapPlannerIdentifier(nameMatch ? nameMatch[1] : match[0]);
+                    const paramsXml = paramsMatch ? paramsMatch[1].trim() : undefined;
+                    if (name) {
+                        actionEntries.push({ name, paramsXml });
                     }
                 }
                 if (actionEntries.length > 0) {
@@ -178,7 +200,7 @@ function normalizePlannerActions(parsedXml, runtime) {
             }
             const commaSplitActions = actionsXml
                 .split(",")
-                .map((action) => String(action).trim())
+                .map((action) => unwrapPlannerIdentifier(String(action)))
                 .filter((action) => action.length > 0);
             if (!parsedXml.params || parsedXml.params === "") {
                 const assembled = extractStandaloneActionParams(commaSplitActions, parsedXml);
@@ -190,32 +212,47 @@ function normalizePlannerActions(parsedXml, runtime) {
         }
         if (Array.isArray(parsedXml.actions)) {
             return parsedXml.actions
-                .map((action) => String(action).trim())
+                .map((action) => unwrapPlannerIdentifier(String(action)))
                 .filter((action) => action.length > 0);
         }
         return [];
     })();
+}
+function normalizePlannerActions(parsedXml, runtime) {
+    const normalizedActions = extractPlannerActionNames(parsedXml);
     const finalActions = !runtime.isActionPlanningEnabled() && normalizedActions.length > 1
         ? [normalizedActions[0]]
         : normalizedActions;
     const actionLookup = buildRuntimeActionLookup(runtime);
-    const validActions = finalActions.filter((actionName) => {
+    const validActions = finalActions.flatMap((actionName) => {
         const normalized = normalizeActionIdentifier(actionName);
         if (!normalized) {
-            return false;
+            return [];
         }
         if (PLANNER_CONTROL_ACTIONS.has(normalized)) {
-            return true;
+            return [actionName];
         }
         const resolvedAction = resolveRuntimeAction(actionLookup, actionName);
         if (resolvedAction) {
-            return true;
+            return [resolvedAction.name];
+        }
+        const aliasedActionName = PLANNER_ACTION_ALIASES.get(normalized);
+        if (aliasedActionName) {
+            const resolvedAlias = resolveRuntimeAction(actionLookup, aliasedActionName);
+            if (resolvedAlias) {
+                runtime.logger.info({
+                    src: "service:message",
+                    actionName,
+                    aliasedActionName: resolvedAlias.name,
+                }, "Repaired planner action alias");
+                return [resolvedAlias.name];
+            }
         }
         runtime.logger.warn({
             src: "service:message",
             actionName,
         }, "Dropping unknown planner action");
-        return false;
+        return [];
     });
     if (validActions.length > 0) {
         return validActions;
@@ -284,7 +321,15 @@ function normalizePlannerProviders(parsedXml, runtime) {
     }
     const normalizedProviders = providerNames
         .map((providerName) => {
-        const canonicalProvider = providerLookup.get(normalizeActionIdentifier(providerName));
+        const normalizedProviderName = normalizeActionIdentifier(providerName);
+        const canonicalProvider = providerLookup.get(normalizedProviderName) ??
+            (() => {
+                const aliasedProvider = PLANNER_PROVIDER_ALIASES.get(normalizedProviderName);
+                if (!aliasedProvider) {
+                    return undefined;
+                }
+                return providerLookup.get(normalizeActionIdentifier(aliasedProvider));
+            })();
         if (canonicalProvider) {
             return canonicalProvider;
         }
@@ -478,8 +523,39 @@ function isStopResponse(responseContent) {
         responseContent.actions[0].toUpperCase() === "STOP");
 }
 function normalizeActionIdentifier(actionName) {
-    return actionName.trim().toUpperCase().replace(/_/g, "");
+    return unwrapPlannerIdentifier(actionName).toUpperCase().replace(/_/g, "");
 }
+const PLANNER_ACTION_ALIASES = new Map([
+    ["BULK_RESCHEDULE_MEETINGS", "PROPOSE_MEETING_TIMES"],
+    ["SCHEDULE_MEETING", "CALENDAR_ACTION"],
+    ["RESCHEDULE_MEETINGS", "CALENDAR_ACTION"],
+    ["CREATE_EVENT", "CALENDAR_ACTION"],
+    ["CREATE_RECURRING_EVENT", "CALENDAR_ACTION"],
+    ["CALENDAR_CREATE_RECURRING_EVENT", "CALENDAR_ACTION"],
+    ["SCHEDULE_RECURRING_EVENT", "CALENDAR_ACTION"],
+    ["SCHEDULE_RECURRING_MEETING", "CALENDAR_ACTION"],
+    ["SCHEDULE_RECURRING", "CALENDAR_ACTION"],
+    ["BOOK_TRAVEL", "CALL_EXTERNAL"],
+    ["CAPTURE_TRAVEL_PREFERENCES", "UPDATE_OWNER_PROFILE"],
+    ["CAPTURE_BOOKING_PREFERENCES", "UPDATE_OWNER_PROFILE"],
+    ["SET_PREFERENCES", "UPDATE_OWNER_PROFILE"],
+    ["SET_TRAVEL_PREFERENCES", "UPDATE_OWNER_PROFILE"],
+    ["CREATE_FOLLOWUP", "INBOX"],
+    ["GET_PENDING_ASSETS", "INBOX"],
+    ["GET_PENDING_ITEMS", "INBOX"],
+    ["PROPOSE_GROUP_CHAT_HANDOFF", "INBOX"],
+    ["SET_MULTI_DEVICE_MEETING_REMINDER", "PUBLISH_DEVICE_INTENT"],
+    ["HANDLE_CANCELLATION_FEE", "PUBLISH_DEVICE_INTENT"],
+    ["GET_ID_STATUS", "PUBLISH_DEVICE_INTENT"],
+    ["REQUEST_UPLOAD", "LIFEOPS_COMPUTER_USE"],
+].map(([from, to]) => [
+    normalizeActionIdentifier(from),
+    to,
+]));
+const PLANNER_PROVIDER_ALIASES = new Map([
+    ["DOCUMENT_LOOKUP", "ATTACHMENTS"],
+    ["INBOX_TRIAGE", "inboxTriage"],
+].map(([from, to]) => [normalizeActionIdentifier(from), to]));
 const PROVIDER_FOLLOWUP_PASSIVE_ACTIONS = new Set(["REPLY", "RESPOND", "NONE"].map(normalizeActionIdentifier));
 function shouldRunProviderFollowup(responseContent) {
     if (!responseContent?.providers?.length) {
@@ -735,7 +811,7 @@ function suppressesPostActionContinuation(runtime, responseContent) {
  * text), IGNORE (no user-visible response), or STOP (terminal). Also skipped
  * when `text` is empty.
  */
-export function shouldEmitPlannerPreamble(responseContent) {
+export function shouldEmitPlannerPreamble(runtime, responseContent) {
     if (!responseContent)
         return false;
     const text = typeof responseContent.text === "string" ? responseContent.text.trim() : "";
@@ -746,6 +822,11 @@ export function shouldEmitPlannerPreamble(responseContent) {
         : "";
     if (firstAction.length === 0)
         return false;
+    const resolvedAction = (runtime.actions ?? []).find((action) => normalizeActionIdentifier(action.name) === firstAction &&
+        action.suppressPostActionContinuation === true);
+    if (resolvedAction) {
+        return false;
+    }
     return (firstAction !== normalizeActionIdentifier("REPLY") &&
         firstAction !== normalizeActionIdentifier("IGNORE") &&
         firstAction !== normalizeActionIdentifier("STOP"));
@@ -1883,7 +1964,9 @@ export class DefaultMessageService {
                     // Surface the planner's text before action handlers run, so the
                     // user sees the agent's plan rather than silence. The full
                     // responseContent is already persisted as a memory above.
-                    if (callback && shouldEmitPlannerPreamble(responseContent)) {
+                    if (callback &&
+                        !isBenchmarkMode(state) &&
+                        shouldEmitPlannerPreamble(runtime, responseContent)) {
                         await callback({
                             ...responseContent,
                             actions: [],