@elizaos/agent 0.25.8 → 2.0.0-alpha.83

package/packages/agent/src/actions/emote.d.ts

@@ -0,0 +1,14 @@
+/**
+ * PLAY_EMOTE action — plays an emote animation on the avatar.
+ *
+ * When triggered the action:
+ *   1. Extracts the emote ID from required structured parameters
+ *   2. Looks up the emote in the catalog
+ *   3. POSTs to the local API server to trigger the animation
+ *   4. Returns success without posting chat text
+ *
+ * @module actions/emote
+ */
+import type { Action } from "@elizaos/core";
+export declare const emoteAction: Action;
+//# sourceMappingURL=emote.d.ts.map

package/packages/agent/src/actions/emote.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emote.d.ts","sourceRoot":"","sources":["../../../../../src/actions/emote.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAkB,MAAM,eAAe,CAAC;AAM5D,eAAO,MAAM,WAAW,EAAE,MA2FzB,CAAC"}

package/packages/agent/src/actions/emote.js

@@ -0,0 +1,91 @@
+/**
+ * PLAY_EMOTE action — plays an emote animation on the avatar.
+ *
+ * When triggered the action:
+ *   1. Extracts the emote ID from required structured parameters
+ *   2. Looks up the emote in the catalog
+ *   3. POSTs to the local API server to trigger the animation
+ *   4. Returns success without posting chat text
+ *
+ * @module actions/emote
+ */
+import { AGENT_EMOTE_BY_ID, AGENT_EMOTE_CATALOG } from "../emotes/catalog";
+/** API port for posting emote requests. */
+const API_PORT = process.env.API_PORT || process.env.SERVER_PORT || "2138";
+export const emoteAction = {
+    name: "PLAY_EMOTE",
+    similes: [
+        "EMOTE",
+        "ANIMATE",
+        "GESTURE",
+        "DANCE",
+        "WAVE",
+        "PLAY_ANIMATION",
+        "DO_EMOTE",
+        "PERFORM",
+    ],
+    description: "Play a one-shot emote animation on your 3D VRM avatar, then return to idle. " +
+        "Use whenever a visible gesture, reaction, or trick helps convey emotion. " +
+        "This is a silent non-blocking visual side action that does not create " +
+        "chat text on its own. Only call it when you set the required emote " +
+        "parameter to a valid emote ID. If you also want speech, chain it " +
+        "before, after, or alongside other actions in the same turn " +
+        "(for example with REPLY, SEND_MESSAGE, or stream actions).",
+    validate: async (_runtime, _message, _state) => {
+        // Always valid — the handler will check if the emote exists.
+        return true;
+    },
+    handler: async (_runtime, _message, _state, options) => {
+        try {
+            const params = options?.parameters;
+            const emoteId = typeof params?.emote === "string" ? params.emote.trim() : "";
+            if (!emoteId) {
+                return { text: "", success: false };
+            }
+            // Look up the emote in the catalog.
+            const emote = AGENT_EMOTE_BY_ID.get(emoteId);
+            if (!emote) {
+                return {
+                    text: "",
+                    success: false,
+                };
+            }
+            // POST to the local API server to trigger the emote.
+            const response = await fetch(`http://localhost:${API_PORT}/api/emote`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ emoteId: emote.id }),
+            });
+            if (!response.ok) {
+                return {
+                    text: "",
+                    success: false,
+                };
+            }
+            return {
+                text: "",
+                success: true,
+                data: { emoteId: emote.id },
+            };
+        }
+        catch {
+            return {
+                text: "",
+                success: false,
+            };
+        }
+    },
+    parameters: [
+        {
+            name: "emote",
+            description: "Required emote ID to play once silently before returning to idle. " +
+                "Common mappings: dance/vibe → dance-happy, wave/greet → wave, " +
+                "flip/backflip → flip, cry/sad → crying, fight/punch → punching, fish → fishing",
+            required: true,
+            schema: {
+                type: "string",
+                enum: AGENT_EMOTE_CATALOG.map((e) => e.id),
+            },
+        },
+    ],
+};

package/packages/agent/src/actions/restart.d.ts

@@ -0,0 +1,19 @@
+/**
+ * RESTART_AGENT action — gracefully restarts the agent.
+ *
+ * When triggered the action:
+ *   1. Persists a "Restarting…" memory so the event is visible in logs
+ *   2. Returns a brief restart notice to the caller
+ *   3. After a short delay (so the response can flush), invokes
+ *      {@link requestRestart} which delegates to the registered
+ *      {@link RestartHandler}.
+ *
+ * In CLI mode the default handler exits with code 75 so the runner script
+ * rebuilds and relaunches. In headless / desktop mode a custom handler
+ * performs an in-process restart (stop → re-init → hot-swap references).
+ *
+ * @module actions/restart
+ */
+import type { Action } from "@elizaos/core";
+export declare const restartAction: Action;
+//# sourceMappingURL=restart.d.ts.map

package/packages/agent/src/actions/restart.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"restart.d.ts","sourceRoot":"","sources":["../../../../../src/actions/restart.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,KAAK,EAAE,MAAM,EAAgC,MAAM,eAAe,CAAC;AAO1E,eAAO,MAAM,aAAa,EAAE,MA2E3B,CAAC"}

package/packages/agent/src/actions/restart.js

@@ -0,0 +1,86 @@
+/**
+ * RESTART_AGENT action — gracefully restarts the agent.
+ *
+ * When triggered the action:
+ *   1. Persists a "Restarting…" memory so the event is visible in logs
+ *   2. Returns a brief restart notice to the caller
+ *   3. After a short delay (so the response can flush), invokes
+ *      {@link requestRestart} which delegates to the registered
+ *      {@link RestartHandler}.
+ *
+ * In CLI mode the default handler exits with code 75 so the runner script
+ * rebuilds and relaunches. In headless / desktop mode a custom handler
+ * performs an in-process restart (stop → re-init → hot-swap references).
+ *
+ * @module actions/restart
+ */
+import crypto from "node:crypto";
+import { logger } from "@elizaos/core";
+import { requestRestart } from "../runtime/restart";
+/** Small delay (ms) before restarting so the response has time to flush. */
+const SHUTDOWN_DELAY_MS = 1_500;
+export const restartAction = {
+    name: "RESTART_AGENT",
+    similes: [
+        "RESTART",
+        "REBOOT",
+        "RELOAD",
+        "REFRESH",
+        "RESPAWN",
+        "RESTART_SELF",
+        "REBOOT_AGENT",
+        "RELOAD_AGENT",
+    ],
+    description: "Restart the agent process. This stops the runtime, rebuilds if source " +
+        "files changed, and relaunches — picking up new code, config, or plugins.",
+    validate: async (_runtime, _message, _state) => {
+        // Always valid — the registered handler decides how (or whether) to restart.
+        return true;
+    },
+    handler: async (runtime, message, _state, options) => {
+        // This action declares parameters, so the runtime provides HandlerOptions.
+        const params = options?.parameters;
+        const reason = typeof params?.reason === "string" ? params.reason : undefined;
+        const restartText = reason ? `Restarting… (${reason})` : "Restarting…";
+        logger.info(`[eliza] ${restartText}`);
+        // Persist a "Restarting…" memory so it shows up in the message log.
+        try {
+            const restartMemory = {
+                id: crypto.randomUUID(),
+                entityId: runtime.agentId,
+                roomId: message.roomId,
+                worldId: message.worldId,
+                content: {
+                    text: restartText,
+                    source: "eliza",
+                    type: "system",
+                },
+            };
+            await runtime.createMemory(restartMemory, "messages");
+        }
+        catch (err) {
+            // Non-fatal — the restart still proceeds even if the memory write fails.
+            const msg = err instanceof Error ? err.message : String(err);
+            logger.warn(`[eliza] Could not persist restart memory: ${msg}`);
+        }
+        // Schedule the restart slightly after returning so the response can be
+        // delivered to the user / channel before the process bounces.
+        setTimeout(() => {
+            requestRestart(reason);
+        }, SHUTDOWN_DELAY_MS);
+        return {
+            text: restartText,
+            success: true,
+            values: { restarting: true },
+            data: { reason },
+        };
+    },
+    parameters: [
+        {
+            name: "reason",
+            description: "Optional reason for the restart (logged for diagnostics).",
+            required: false,
+            schema: { type: "string" },
+        },
+    ],
+};

package/packages/agent/src/actions/send-message.d.ts

@@ -0,0 +1,3 @@
+import type { Action } from "@elizaos/core";
+export declare const sendMessageAction: Action;
+//# sourceMappingURL=send-message.d.ts.map

package/packages/agent/src/actions/send-message.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"send-message.d.ts","sourceRoot":"","sources":["../../../../../src/actions/send-message.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAA2B,MAAM,eAAe,CAAC;AAUrE,eAAO,MAAM,iBAAiB,EAAE,MAqK/B,CAAC"}

package/packages/agent/src/actions/send-message.js

@@ -0,0 +1,144 @@
+export const sendMessageAction = {
+    name: "SEND_MESSAGE",
+    similes: ["DM", "MESSAGE", "SEND_DM", "POST_MESSAGE"],
+    description: "Send a message to a user or room on a specific platform/service using explicit parameters.",
+    validate: async () => true,
+    handler: async (runtime, _message, _state, options) => {
+        const params = options?.parameters;
+        const targetType = params?.targetType === "user" || params?.targetType === "room"
+            ? params.targetType
+            : null;
+        const source = typeof params?.source === "string" ? params.source.trim() : "";
+        const target = typeof params?.target === "string" ? params.target.trim() : "";
+        const text = typeof params?.text === "string" ? params.text.trim() : "";
+        if (!targetType || !source || !target || !text) {
+            return {
+                text: "SEND_MESSAGE requires targetType, source, target, and text parameters.",
+                success: false,
+                values: {
+                    success: false,
+                    error: "INVALID_PARAMETERS",
+                },
+                data: {
+                    actionName: "SEND_MESSAGE",
+                    targetType,
+                    source: source || null,
+                    target: target || null,
+                },
+            };
+        }
+        const service = runtime.getService(source);
+        if (!service) {
+            return {
+                text: `Message service '${source}' is not available.`,
+                success: false,
+                values: {
+                    success: false,
+                    error: "SERVICE_NOT_FOUND",
+                },
+                data: {
+                    actionName: "SEND_MESSAGE",
+                    targetType,
+                    source,
+                    target,
+                },
+            };
+        }
+        if (targetType === "user") {
+            if (!service.sendDirectMessage) {
+                return {
+                    text: `Direct messaging is not supported by '${source}'.`,
+                    success: false,
+                    values: {
+                        success: false,
+                        error: "DIRECT_MESSAGE_UNSUPPORTED",
+                    },
+                    data: {
+                        actionName: "SEND_MESSAGE",
+                        targetType,
+                        source,
+                        target,
+                    },
+                };
+            }
+            await service.sendDirectMessage(target, { text, source });
+            return {
+                text: `Message sent to user ${target} on ${source}.`,
+                success: true,
+                values: {
+                    success: true,
+                    targetType,
+                    source,
+                    target,
+                },
+                data: {
+                    actionName: "SEND_MESSAGE",
+                    targetType,
+                    source,
+                    target,
+                    text,
+                },
+            };
+        }
+        if (!service.sendRoomMessage) {
+            return {
+                text: `Room messaging is not supported by '${source}'.`,
+                success: false,
+                values: {
+                    success: false,
+                    error: "ROOM_MESSAGE_UNSUPPORTED",
+                },
+                data: {
+                    actionName: "SEND_MESSAGE",
+                    targetType,
+                    source,
+                    target,
+                },
+            };
+        }
+        await service.sendRoomMessage(target, { text, source });
+        return {
+            text: `Message sent to room ${target} on ${source}.`,
+            success: true,
+            values: {
+                success: true,
+                targetType,
+                source,
+                target,
+            },
+            data: {
+                actionName: "SEND_MESSAGE",
+                targetType,
+                source,
+                target,
+                text,
+            },
+        };
+    },
+    parameters: [
+        {
+            name: "targetType",
+            description: "Target entity type: user or room.",
+            required: true,
+            schema: { type: "string", enum: ["user", "room"] },
+        },
+        {
+            name: "source",
+            description: "Messaging source/service name (e.g. telegram, discord).",
+            required: true,
+            schema: { type: "string" },
+        },
+        {
+            name: "target",
+            description: "Target identifier. For users: entity ID/username. For rooms: room ID/name.",
+            required: true,
+            schema: { type: "string" },
+        },
+        {
+            name: "text",
+            description: "Message text to send.",
+            required: true,
+            schema: { type: "string" },
+        },
+    ],
+};

package/packages/agent/src/actions/stream-control.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Stream control actions — agents can go live, go offline, switch
+ * destinations, speak via TTS, and manage overlay widgets.
+ *
+ * All actions hit the local Eliza API (127.0.0.1:API_PORT).
+ *
+ * @module actions/stream-control
+ */
+import type { Action } from "@elizaos/core";
+export declare const goLiveAction: Action;
+export declare const goOfflineAction: Action;
+export declare const setStreamDestinationAction: Action;
+export declare const speakOnStreamAction: Action;
+export declare const manageOverlayWidgetAction: Action;
+//# sourceMappingURL=stream-control.d.ts.map

package/packages/agent/src/actions/stream-control.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-control.d.ts","sourceRoot":"","sources":["../../../../../src/actions/stream-control.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AA2C5C,eAAO,MAAM,YAAY,EAAE,MAoC1B,CAAC;AAMF,eAAO,MAAM,eAAe,EAAE,MAwB7B,CAAC;AAMF,eAAO,MAAM,0BAA0B,EAAE,MAkHxC,CAAC;AAMF,eAAO,MAAM,mBAAmB,EAAE,MA+CjC,CAAC;AAMF,eAAO,MAAM,yBAAyB,EAAE,MA6IvC,CAAC"}