@elizaos/agent 2.0.0-alpha.144 → 2.0.0-alpha.152

package/packages/agent/src/actions/log-level.js

@@ -0,0 +1,125 @@
+import { elizaLogger, } from "@elizaos/core";
+import { getValidationKeywordTerms, textIncludesKeywordTerm, } from "@elizaos/shared/validation-keywords";
+const LOG_LEVEL_COMMAND_TERMS = getValidationKeywordTerms("action.logLevel.command", {
+    includeAllLocales: true,
+});
+const LOG_LEVEL_SET_TERMS = getValidationKeywordTerms("action.logLevel.setVerb", {
+    includeAllLocales: true,
+});
+const LOG_LEVEL_DOMAIN_TERMS = getValidationKeywordTerms("action.logLevel.domain", {
+    includeAllLocales: true,
+});
+const LOG_LEVEL_ALIASES = {
+    trace: getValidationKeywordTerms("action.logLevel.level.trace", {
+        includeAllLocales: true,
+    }),
+    debug: getValidationKeywordTerms("action.logLevel.level.debug", {
+        includeAllLocales: true,
+    }),
+    info: getValidationKeywordTerms("action.logLevel.level.info", {
+        includeAllLocales: true,
+    }),
+    warn: getValidationKeywordTerms("action.logLevel.level.warn", {
+        includeAllLocales: true,
+    }),
+    error: getValidationKeywordTerms("action.logLevel.level.error", {
+        includeAllLocales: true,
+    }),
+};
+function containsLogLevelTerm(text, terms) {
+    return terms.some((term) => textIncludesKeywordTerm(text, term));
+}
+function resolveLogLevel(text) {
+    const entries = Object.entries(LOG_LEVEL_ALIASES);
+    for (const [level, aliases] of entries) {
+        if (containsLogLevelTerm(text, aliases)) {
+            return level;
+        }
+    }
+    return null;
+}
+export const logLevelAction = {
+    name: "LOG_LEVEL",
+    similes: [
+        "SET_LOG_LEVEL",
+        "CHANGE_LOG_LEVEL",
+        "DEBUG_MODE",
+        "SET_DEBUG",
+        "CONFIGURE_LOGGING",
+    ],
+    description: "Set the log level for the current session (trace, debug, info, warn, error).",
+    validate: async (_runtime, message) => {
+        const text = message.content.text || "";
+        const hasLevel = resolveLogLevel(text) !== null;
+        if (!hasLevel) {
+            return false;
+        }
+        return (containsLogLevelTerm(text, LOG_LEVEL_COMMAND_TERMS) ||
+            (containsLogLevelTerm(text, LOG_LEVEL_SET_TERMS) &&
+                containsLogLevelTerm(text, LOG_LEVEL_DOMAIN_TERMS)));
+    },
+    handler: async (runtime, message, _state, _options, callback) => {
+        const text = message.content.text || "";
+        const levels = Object.keys(LOG_LEVEL_ALIASES);
+        const level = resolveLogLevel(text);
+        if (!level) {
+            if (callback) {
+                callback({
+                    text: `Please specify a valid log level: ${levels.join(", ")}.`,
+                    action: "LOG_LEVEL_FAILED",
+                });
+            }
+            return { success: false, error: "Invalid log level" };
+        }
+        // Set the override
+        const runtimeWithOverrides = runtime;
+        if (runtimeWithOverrides.logLevelOverrides) {
+            runtimeWithOverrides.logLevelOverrides.set(message.roomId, level);
+            elizaLogger.info(`Log level set to ${level} for room ${message.roomId}`);
+            if (callback) {
+                callback({
+                    text: `Log level changed to **${level.toUpperCase()}** for this room.`,
+                    action: "LOG_LEVEL_SET",
+                });
+            }
+            return { success: true };
+        }
+        else {
+            if (callback) {
+                callback({
+                    text: "Dynamic log levels are not supported by this runtime version.",
+                    action: "LOG_LEVEL_FAILED",
+                });
+            }
+            return { success: false, error: "Not supported" };
+        }
+    },
+    examples: [
+        [
+            {
+                name: "{{user1}}",
+                content: { text: "/logLevel debug" },
+            },
+            {
+                name: "{{agentName}}",
+                content: {
+                    text: "Log level changed to **DEBUG** for this room.",
+                    action: "LOG_LEVEL_SET",
+                },
+            },
+        ],
+        [
+            {
+                name: "{{user1}}",
+                content: { text: "Set log level to trace" },
+            },
+            {
+                name: "{{agentName}}",
+                content: {
+                    text: "Log level changed to **TRACE** for this room.",
+                    action: "LOG_LEVEL_SET",
+                },
+            },
+        ],
+    ],
+};

package/packages/agent/src/actions/manage-tasks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"manage-tasks.d.ts","sourceRoot":"","sources":["../../../../../src/actions/manage-tasks.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACL,KAAK,MAAM,EASZ,MAAM,eAAe,CAAC;AAgEvB,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAIzD;AAED,eAAO,MAAM,iBAAiB,EAAE,MA6M/B,CAAC"}
+{"version":3,"file":"manage-tasks.d.ts","sourceRoot":"","sources":["../../../../../src/actions/manage-tasks.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACL,KAAK,MAAM,EASZ,MAAM,eAAe,CAAC;AA+EvB,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAIzD;AAED,eAAO,MAAM,iBAAiB,EAAE,MA0O/B,CAAC"}

package/packages/agent/src/actions/manage-tasks.js

@@ -4,18 +4,33 @@
  */
 import { ModelType, parseKeyValueXml, } from "@elizaos/core";
 import { findKeywordTermMatch } from "@elizaos/shared/validation-keywords";
+import { readTaskCompleted, readTaskMetadata, toWorkbenchTask, WORKBENCH_TASK_TAG, } from "../api/workbench-helpers.js";
 import { hasOwnerAccess } from "../security/access.js";
-import { WORKBENCH_TASK_TAG, readTaskCompleted, readTaskMetadata, toWorkbenchTask, } from "../api/workbench-helpers.js";
 import { readTriggerConfig } from "../triggers/runtime.js";
 const MANAGE_TASKS_ACTION = "MANAGE_TASKS";
 const TASK_INTENT_TERMS = [
-    "create task", "add task", "new task", "make task",
-    "complete task", "finish task", "done with task", "mark task done",
-    "delete task", "remove task",
-    "update task", "edit task", "change task",
-    "list tasks", "show tasks", "my tasks", "what are my tasks",
-    "add a todo", "add a to-do", "create a to do",
-    "task list", "check off",
+    "create task",
+    "add task",
+    "new task",
+    "make task",
+    "complete task",
+    "finish task",
+    "done with task",
+    "mark task done",
+    "delete task",
+    "remove task",
+    "update task",
+    "edit task",
+    "change task",
+    "list tasks",
+    "show tasks",
+    "my tasks",
+    "what are my tasks",
+    "add a todo",
+    "add a to-do",
+    "create a to do",
+    "task list",
+    "check off",
 ];
 function parseExtraction(text) {
     const parsed = parseKeyValueXml(text);
@@ -177,10 +192,13 @@ export const manageTasksAction = {
             if (operation === "complete") {
                 const taskId = extraction.taskId;
                 if (!taskId) {
-                    return { success: false, text: "Could not identify which task to complete." };
+                    return {
+                        success: false,
+                        text: "Could not identify which task to complete.",
+                    };
                 }
                 const task = await runtime.getTask(taskId);
-                if (!task) {
+                if (!task?.id) {
                     return { success: false, text: `Task not found: ${taskId}` };
                 }
                 const metadata = readTaskMetadata(task);
@@ -195,13 +213,20 @@ export const manageTasksAction = {
                         metadata: { taskId, operation: "complete" },
                     });
                 }
-                return { success: true, text: msg, data: { taskId, operation: "complete" } };
+                return {
+                    success: true,
+                    text: msg,
+                    data: { taskId, operation: "complete" },
+                };
             }
             // ── DELETE ──
             if (operation === "delete") {
                 const taskId = extraction.taskId;
                 if (!taskId) {
-                    return { success: false, text: "Could not identify which task to delete." };
+                    return {
+                        success: false,
+                        text: "Could not identify which task to delete.",
+                    };
                 }
                 const task = await runtime.getTask(taskId);
                 if (!task?.id) {
@@ -216,13 +241,20 @@ export const manageTasksAction = {
                         metadata: { taskId, operation: "delete" },
                     });
                 }
-                return { success: true, text: msg, data: { taskId, operation: "delete" } };
+                return {
+                    success: true,
+                    text: msg,
+                    data: { taskId, operation: "delete" },
+                };
             }
             // ── UPDATE ──
             if (operation === "update") {
                 const taskId = extraction.taskId;
                 if (!taskId) {
-                    return { success: false, text: "Could not identify which task to update." };
+                    return {
+                        success: false,
+                        text: "Could not identify which task to update.",
+                    };
                 }
                 const task = await runtime.getTask(taskId);
                 if (!task?.id) {
@@ -242,7 +274,11 @@ export const manageTasksAction = {
                         metadata: { taskId, operation: "update" },
                     });
                 }
-                return { success: true, text: msg, data: { taskId, operation: "update" } };
+                return {
+                    success: true,
+                    text: msg,
+                    data: { taskId, operation: "update" },
+                };
             }
             return { success: false, text: `Unknown operation: ${operation}` };
         }

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

@@ -0,0 +1,21 @@
+/**
+ * Media Generation Actions
+ *
+ * Provides runtime actions for generating and analyzing media:
+ * - GENERATE_IMAGE: Text-to-image generation
+ * - GENERATE_VIDEO: Text-to-video generation
+ * - GENERATE_AUDIO: Text-to-audio/music generation
+ * - ANALYZE_IMAGE: Vision/image analysis
+ *
+ * Uses the media-provider abstraction with Eliza Cloud as default,
+ * or user-configured providers (FAL, OpenAI, Google, Anthropic, etc.)
+ *
+ * @module actions/media
+ */
+import type { Action } from "@elizaos/core";
+export declare const generateImageAction: Action;
+export declare const generateVideoAction: Action;
+export declare const generateAudioAction: Action;
+export declare const analyzeImageAction: Action;
+export declare const mediaActions: Action[];
+//# sourceMappingURL=media.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"media.d.ts","sourceRoot":"","sources":["../../../../../src/actions/media.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAiC,MAAM,eAAe,CAAC;AA4B3E,eAAO,MAAM,mBAAmB,EAAE,MAsHjC,CAAC;AAMF,eAAO,MAAM,mBAAmB,EAAE,MAuGjC,CAAC;AAMF,eAAO,MAAM,mBAAmB,EAAE,MA6GjC,CAAC;AAMF,eAAO,MAAM,kBAAkB,EAAE,MAgGhC,CAAC;AAEF,eAAO,MAAM,YAAY,UAKxB,CAAC"}

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

@@ -0,0 +1,384 @@
+/**
+ * Media Generation Actions
+ *
+ * Provides runtime actions for generating and analyzing media:
+ * - GENERATE_IMAGE: Text-to-image generation
+ * - GENERATE_VIDEO: Text-to-video generation
+ * - GENERATE_AUDIO: Text-to-audio/music generation
+ * - ANALYZE_IMAGE: Vision/image analysis
+ *
+ * Uses the media-provider abstraction with Eliza Cloud as default,
+ * or user-configured providers (FAL, OpenAI, Google, Anthropic, etc.)
+ *
+ * @module actions/media
+ */
+import { isElizaCloudServiceSelectedInConfig } from "@elizaos/shared/contracts";
+import { loadElizaConfig } from "../config/config.js";
+import { createAudioProvider, createImageProvider, createVideoProvider, createVisionProvider, } from "../providers/media-provider.js";
+function getMediaProviderOptions() {
+    const config = loadElizaConfig();
+    const cloudMediaSelected = isElizaCloudServiceSelectedInConfig(config, "media");
+    return {
+        elizaCloudBaseUrl: config.cloud?.baseUrl ?? "https://elizacloud.ai/api/v1",
+        elizaCloudApiKey: config.cloud?.apiKey,
+        cloudMediaDisabled: !cloudMediaSelected,
+    };
+}
+// ============================================================================
+// GENERATE_IMAGE Action
+// ============================================================================
+export const generateImageAction = {
+    name: "GENERATE_IMAGE",
+    similes: [
+        "CREATE_IMAGE",
+        "MAKE_IMAGE",
+        "DRAW",
+        "PAINT",
+        "ILLUSTRATE",
+        "RENDER_IMAGE",
+        "IMAGE_GEN",
+        "TEXT_TO_IMAGE",
+    ],
+    description: "Generate an image from a text prompt using AI image generation. " +
+        "Supports various styles, sizes, and quality settings.",
+    validate: async (_runtime) => true,
+    handler: async (_runtime, _message, _state, options) => {
+        const params = options?.parameters;
+        const prompt = params?.prompt;
+        if (!prompt || typeof prompt !== "string" || prompt.trim().length === 0) {
+            return {
+                text: "I need a prompt to generate an image. Please describe what you'd like me to create.",
+                success: false,
+            };
+        }
+        const config = loadElizaConfig();
+        const provider = createImageProvider(config.media?.image, getMediaProviderOptions());
+        const result = await provider.generate({
+            prompt: prompt.trim(),
+            size: params?.size,
+            quality: params?.quality,
+            style: params?.style,
+            negativePrompt: params?.negativePrompt,
+        });
+        if (!result.success || !result.data) {
+            return {
+                text: `I couldn't generate the image: ${result.error ?? "Unknown error"}`,
+                success: false,
+            };
+        }
+        const imageUrl = result.data.imageUrl ?? result.data.imageBase64;
+        const revisedPrompt = result.data.revisedPrompt;
+        return {
+            text: revisedPrompt
+                ? `Here's the generated image based on: "${revisedPrompt}"`
+                : "Here's the generated image.",
+            success: true,
+            data: {
+                imageUrl: result.data.imageUrl,
+                imageBase64: result.data.imageBase64,
+                revisedPrompt,
+            },
+            attachments: imageUrl
+                ? [
+                    {
+                        type: "image",
+                        url: result.data.imageUrl,
+                        base64: result.data.imageBase64,
+                        mimeType: "image/png",
+                    },
+                ]
+                : undefined,
+        };
+    },
+    parameters: [
+        {
+            name: "prompt",
+            description: "The text description of the image to generate",
+            required: true,
+            schema: { type: "string" },
+        },
+        {
+            name: "size",
+            description: "Image size (e.g., '1024x1024', '1792x1024')",
+            required: false,
+            schema: { type: "string" },
+        },
+        {
+            name: "quality",
+            description: "Image quality ('standard' or 'hd')",
+            required: false,
+            schema: { type: "string", enum: ["standard", "hd"] },
+        },
+        {
+            name: "style",
+            description: "Image style ('natural' or 'vivid')",
+            required: false,
+            schema: { type: "string", enum: ["natural", "vivid"] },
+        },
+        {
+            name: "negativePrompt",
+            description: "Things to avoid in the generated image",
+            required: false,
+            schema: { type: "string" },
+        },
+    ],
+};
+// ============================================================================
+// GENERATE_VIDEO Action
+// ============================================================================
+export const generateVideoAction = {
+    name: "GENERATE_VIDEO",
+    similes: [
+        "CREATE_VIDEO",
+        "MAKE_VIDEO",
+        "ANIMATE",
+        "RENDER_VIDEO",
+        "VIDEO_GEN",
+        "TEXT_TO_VIDEO",
+        "FILM",
+    ],
+    description: "Generate a video from a text prompt using AI video generation. " +
+        "Can optionally use an input image for image-to-video generation.",
+    validate: async (_runtime) => true,
+    handler: async (_runtime, _message, _state, options) => {
+        const params = options?.parameters;
+        const prompt = params?.prompt;
+        if (!prompt || typeof prompt !== "string" || prompt.trim().length === 0) {
+            return {
+                text: "I need a prompt to generate a video. Please describe what you'd like me to create.",
+                success: false,
+            };
+        }
+        const config = loadElizaConfig();
+        const provider = createVideoProvider(config.media?.video, getMediaProviderOptions());
+        const result = await provider.generate({
+            prompt: prompt.trim(),
+            duration: params?.duration,
+            aspectRatio: params?.aspectRatio,
+            imageUrl: params?.imageUrl,
+        });
+        if (!result.success || !result.data) {
+            return {
+                text: `I couldn't generate the video: ${result.error ?? "Unknown error"}`,
+                success: false,
+            };
+        }
+        return {
+            text: "Here's the generated video.",
+            success: true,
+            data: {
+                videoUrl: result.data.videoUrl,
+                thumbnailUrl: result.data.thumbnailUrl,
+                duration: result.data.duration,
+            },
+            attachments: result.data.videoUrl
+                ? [
+                    {
+                        type: "video",
+                        url: result.data.videoUrl,
+                        mimeType: "video/mp4",
+                    },
+                ]
+                : undefined,
+        };
+    },
+    parameters: [
+        {
+            name: "prompt",
+            description: "The text description of the video to generate",
+            required: true,
+            schema: { type: "string" },
+        },
+        {
+            name: "duration",
+            description: "Video duration in seconds",
+            required: false,
+            schema: { type: "number" },
+        },
+        {
+            name: "aspectRatio",
+            description: "Video aspect ratio (e.g., '16:9', '9:16', '1:1')",
+            required: false,
+            schema: { type: "string" },
+        },
+        {
+            name: "imageUrl",
+            description: "URL of an image to use as starting frame (image-to-video)",
+            required: false,
+            schema: { type: "string" },
+        },
+    ],
+};
+// ============================================================================
+// GENERATE_AUDIO Action
+// ============================================================================
+export const generateAudioAction = {
+    name: "GENERATE_AUDIO",
+    similes: [
+        "CREATE_AUDIO",
+        "MAKE_MUSIC",
+        "COMPOSE",
+        "GENERATE_MUSIC",
+        "CREATE_SONG",
+        "MAKE_SOUND",
+        "AUDIO_GEN",
+        "TEXT_TO_MUSIC",
+    ],
+    description: "Generate audio or music from a text prompt using AI audio generation. " +
+        "Can create songs, sound effects, or instrumental music.",
+    validate: async (_runtime) => true,
+    handler: async (_runtime, _message, _state, options) => {
+        const params = options?.parameters;
+        const prompt = params?.prompt;
+        if (!prompt || typeof prompt !== "string" || prompt.trim().length === 0) {
+            return {
+                text: "I need a prompt to generate audio. Please describe the music or sound you'd like me to create.",
+                success: false,
+            };
+        }
+        const config = loadElizaConfig();
+        const provider = createAudioProvider(config.media?.audio, getMediaProviderOptions());
+        const result = await provider.generate({
+            prompt: prompt.trim(),
+            duration: params?.duration,
+            instrumental: params?.instrumental,
+            genre: params?.genre,
+        });
+        if (!result.success || !result.data) {
+            return {
+                text: `I couldn't generate the audio: ${result.error ?? "Unknown error"}`,
+                success: false,
+            };
+        }
+        const title = result.data.title ?? "Generated Audio";
+        return {
+            text: `Here's the generated audio: "${title}"`,
+            success: true,
+            data: {
+                audioUrl: result.data.audioUrl,
+                title: result.data.title,
+                duration: result.data.duration,
+            },
+            attachments: result.data.audioUrl
+                ? [
+                    {
+                        type: "audio",
+                        url: result.data.audioUrl,
+                        mimeType: "audio/mpeg",
+                        title,
+                    },
+                ]
+                : undefined,
+        };
+    },
+    parameters: [
+        {
+            name: "prompt",
+            description: "The text description of the audio to generate (song lyrics, mood, style, etc.)",
+            required: true,
+            schema: { type: "string" },
+        },
+        {
+            name: "duration",
+            description: "Audio duration in seconds",
+            required: false,
+            schema: { type: "number" },
+        },
+        {
+            name: "instrumental",
+            description: "Whether to generate instrumental music without vocals",
+            required: false,
+            schema: { type: "boolean" },
+        },
+        {
+            name: "genre",
+            description: "Music genre (e.g., 'pop', 'rock', 'classical', 'synthwave')",
+            required: false,
+            schema: { type: "string" },
+        },
+    ],
+};
+// ============================================================================
+// ANALYZE_IMAGE Action
+// ============================================================================
+export const analyzeImageAction = {
+    name: "ANALYZE_IMAGE",
+    similes: [
+        "DESCRIBE_IMAGE",
+        "WHAT_IS_IN_IMAGE",
+        "IDENTIFY_IMAGE",
+        "READ_IMAGE",
+        "UNDERSTAND_IMAGE",
+        "VISION",
+        "OCR",
+        "IMAGE_TO_TEXT",
+    ],
+    description: "Analyze an image using AI vision to describe its contents, identify objects, " +
+        "read text, or answer questions about the image.",
+    validate: async (_runtime) => true,
+    handler: async (_runtime, _message, _state, options) => {
+        const params = options?.parameters;
+        const hasImage = params?.imageUrl || params?.imageBase64;
+        if (!hasImage) {
+            return {
+                text: "I need an image to analyze. Please provide an image URL or upload an image.",
+                success: false,
+            };
+        }
+        const config = loadElizaConfig();
+        const provider = createVisionProvider(config.media?.vision, getMediaProviderOptions());
+        const result = await provider.analyze({
+            imageUrl: params?.imageUrl,
+            imageBase64: params?.imageBase64,
+            prompt: params?.prompt ?? "Describe this image in detail.",
+            maxTokens: params?.maxTokens,
+        });
+        if (!result.success || !result.data) {
+            return {
+                text: `I couldn't analyze the image: ${result.error ?? "Unknown error"}`,
+                success: false,
+            };
+        }
+        return {
+            text: result.data.description,
+            success: true,
+            data: {
+                description: result.data.description,
+                labels: result.data.labels,
+                confidence: result.data.confidence,
+            },
+        };
+    },
+    parameters: [
+        {
+            name: "imageUrl",
+            description: "URL of the image to analyze",
+            required: false,
+            schema: { type: "string" },
+        },
+        {
+            name: "imageBase64",
+            description: "Base64-encoded image data",
+            required: false,
+            schema: { type: "string" },
+        },
+        {
+            name: "prompt",
+            description: "Specific question or instruction for the analysis (default: describe the image)",
+            required: false,
+            schema: { type: "string" },
+        },
+        {
+            name: "maxTokens",
+            description: "Maximum tokens for the response",
+            required: false,
+            schema: { type: "number" },
+        },
+    ],
+};
+export const mediaActions = [
+    generateImageAction,
+    generateVideoAction,
+    generateAudioAction,
+    analyzeImageAction,
+];

package/packages/agent/src/actions/read-messages.d.ts

@@ -0,0 +1,14 @@
+/**
+ * READ_MESSAGES — Person-centric cross-platform conversation view.
+ *
+ * Unlike READ_CHANNEL (which reads a specific channel), READ_MESSAGES
+ * resolves a person via the Rolodex and shows recent conversations with
+ * them across ALL connected platforms. This enables conversation handoff —
+ * the user can see full context from Telegram, Discord, Signal, etc.
+ * before deciding where to continue the conversation.
+ *
+ * @module actions/read-messages
+ */
+import type { Action } from "@elizaos/core";
+export declare const readMessagesAction: Action;
+//# sourceMappingURL=read-messages.d.ts.map

package/packages/agent/src/actions/read-messages.d.ts.map

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