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

package/packages/agent/src/actions/read-messages.js

@@ -0,0 +1,228 @@
+/**
+ * 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 { logger } from "@elizaos/core";
+import { hasAdminAccess } from "../security/access.js";
+import { formatContactCandidates, formatConversationView, getActiveConnectors, getPersonConversations, resolveContact, resolveContactCandidates, } from "./connector-resolver.js";
+import { hasContextSignalSyncForKey } from "./context-signal.js";
+const DEFAULT_LIMIT = 15;
+const MAX_LIMIT = 50;
+export const readMessagesAction = {
+    name: "READ_MESSAGES",
+    similes: [
+        "GET_MESSAGES",
+        "VIEW_MESSAGES",
+        "CHECK_MESSAGES",
+        "SHOW_MESSAGES",
+        "MESSAGES_WITH",
+        "CONVERSATION_WITH",
+        "CHAT_WITH",
+        "READ_DMS",
+        "CHECK_DMS",
+    ],
+    description: "Read recent messages/conversations with a specific person across all connected platforms. " +
+        "Resolves the person via the Rolodex and shows conversations from every platform where " +
+        "the agent has interacted with them. Use for conversation context before sending a reply, " +
+        "or to review what was discussed on different platforms. " +
+        "Results can be saved to clipboard with CLIPBOARD_WRITE.",
+    validate: async (runtime, message, state) => {
+        if (!(await hasAdminAccess(runtime, message)))
+            return false;
+        return hasContextSignalSyncForKey(message, state, "read_messages");
+    },
+    handler: async (runtime, message, _state, options) => {
+        if (!(await hasAdminAccess(runtime, message))) {
+            return {
+                text: "Permission denied: only the owner or admins may read messages.",
+                success: false,
+                values: { success: false, error: "PERMISSION_DENIED" },
+                data: { actionName: "READ_MESSAGES" },
+            };
+        }
+        const params = (options?.parameters ??
+            {});
+        const { contact, entityId, platform } = params;
+        const contactName = typeof contact === "string" ? contact.trim() : "";
+        const limit = Math.min(Math.max(1, params.limit ?? DEFAULT_LIMIT), MAX_LIMIT);
+        if ((!contact || typeof contact !== "string" || !contact.trim()) &&
+            (!entityId || typeof entityId !== "string" || !entityId.trim())) {
+            return {
+                text: "READ_MESSAGES requires either a 'contact' name or 'entityId' parameter.",
+                success: false,
+                values: { success: false, error: "INVALID_PARAMETERS" },
+                data: { actionName: "READ_MESSAGES" },
+            };
+        }
+        try {
+            let view;
+            if (entityId) {
+                // Direct entity ID lookup — find person in graph
+                const { getGraphService } = await import("./connector-resolver.js");
+                const graphService = getGraphService(runtime);
+                if (!graphService) {
+                    return {
+                        text: "Relationships service not available.",
+                        success: false,
+                        values: { success: false, error: "SERVICE_NOT_FOUND" },
+                        data: { actionName: "READ_MESSAGES" },
+                    };
+                }
+                const snapshot = await graphService.getGraphSnapshot({
+                    search: entityId,
+                    limit: 1,
+                });
+                if (!snapshot || snapshot.people.length === 0) {
+                    return {
+                        text: `No person found for entityId "${entityId}". Use SEARCH_ENTITY first.`,
+                        success: false,
+                        values: { success: false, error: "ENTITY_NOT_FOUND" },
+                        data: { actionName: "READ_MESSAGES", entityId },
+                    };
+                }
+                view = await getPersonConversations(runtime, snapshot.people[0], {
+                    limitPerPlatform: limit,
+                });
+            }
+            else {
+                // Name-based Rolodex resolution
+                const resolved = await resolveContact(runtime, contactName, platform);
+                if (!resolved) {
+                    const candidates = await resolveContactCandidates(runtime, contactName);
+                    if (candidates.length > 0) {
+                        return {
+                            text: `Multiple contacts match "${contact}":\n` +
+                                formatContactCandidates(candidates) +
+                                "\nSpecify the entityId or use a more specific name.",
+                            success: false,
+                            values: { success: false, error: "AMBIGUOUS_CONTACT" },
+                            data: {
+                                actionName: "READ_MESSAGES",
+                                contact,
+                                candidateCount: candidates.length,
+                                candidates: candidates.map((c) => ({
+                                    displayName: c.displayName,
+                                    primaryEntityId: c.primaryEntityId,
+                                    platforms: c.platforms,
+                                })),
+                            },
+                        };
+                    }
+                    return {
+                        text: `No contacts found matching "${contact}" in the Rolodex.`,
+                        success: false,
+                        values: { success: false, error: "CONTACT_NOT_FOUND" },
+                        data: { actionName: "READ_MESSAGES", contact },
+                    };
+                }
+                view = await getPersonConversations(runtime, resolved.person, {
+                    limitPerPlatform: limit,
+                });
+            }
+            // Filter by platform if specified
+            if (platform) {
+                view = {
+                    ...view,
+                    conversations: view.conversations.filter((c) => c.platform.toLowerCase() === platform.toLowerCase()),
+                    totalMessages: view.conversations
+                        .filter((c) => c.platform.toLowerCase() === platform.toLowerCase())
+                        .reduce((sum, c) => sum + c.messageCount, 0),
+                };
+            }
+            if (view.conversations.length === 0) {
+                return {
+                    text: `No conversations found with ${view.person.displayName}` +
+                        (platform ? ` on ${platform}` : "") +
+                        ".",
+                    success: true,
+                    values: {
+                        success: true,
+                        messageCount: 0,
+                        personName: view.person.displayName,
+                    },
+                    data: {
+                        actionName: "READ_MESSAGES",
+                        contact: contact ?? entityId,
+                        personName: view.person.displayName,
+                        platform,
+                    },
+                };
+            }
+            const formatted = formatConversationView(runtime, view);
+            const activeConnectors = getActiveConnectors(runtime);
+            const reachable = view.person.platforms.filter((p) => activeConnectors.has(p));
+            const footer = `\nReachable platforms: ${reachable.join(", ") || "none"}` +
+                "\nUse SEND_MESSAGE with recipient name to reply on the best platform." +
+                "\nTo save to clipboard, use CLIPBOARD_WRITE.";
+            return {
+                text: `${formatted}\n${footer}`,
+                success: true,
+                values: {
+                    success: true,
+                    messageCount: view.totalMessages,
+                    conversationCount: view.conversations.length,
+                    personName: view.person.displayName,
+                    platforms: [...new Set(view.conversations.map((c) => c.platform))],
+                },
+                data: {
+                    actionName: "READ_MESSAGES",
+                    contact: contact ?? entityId,
+                    personName: view.person.displayName,
+                    primaryEntityId: view.person.primaryEntityId,
+                    conversations: view.conversations.map((c) => ({
+                        platform: c.platform,
+                        roomId: c.roomId,
+                        roomName: c.roomName,
+                        messageCount: c.messageCount,
+                        lastMessageAt: c.lastMessageAt,
+                    })),
+                },
+            };
+        }
+        catch (error) {
+            const errMsg = error instanceof Error ? error.message : String(error);
+            logger.error("[READ_MESSAGES] Error:", errMsg);
+            return {
+                text: `Failed to read messages: ${errMsg}`,
+                success: false,
+                values: { success: false, error: "READ_FAILED" },
+                data: { actionName: "READ_MESSAGES", contact: contact ?? entityId },
+            };
+        }
+    },
+    parameters: [
+        {
+            name: "contact",
+            description: "Person's name for Rolodex resolution. The agent will find all conversations " +
+                "with this person across all platforms.",
+            required: false,
+            schema: { type: "string" },
+        },
+        {
+            name: "entityId",
+            description: "Entity ID (from SEARCH_ENTITY results) for direct lookup. Alternative to contact name.",
+            required: false,
+            schema: { type: "string" },
+        },
+        {
+            name: "platform",
+            description: 'Filter to a specific platform (e.g. "discord", "telegram"). ' +
+                "Optional — omit to see conversations across all platforms.",
+            required: false,
+            schema: { type: "string" },
+        },
+        {
+            name: "limit",
+            description: "Maximum number of messages per conversation thread (default 15, max 50).",
+            required: false,
+            schema: { type: "number" },
+        },
+    ],
+};

package/packages/agent/src/actions/reinject-plugin.d.ts

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

package/packages/agent/src/actions/reinject-plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reinject-plugin.d.ts","sourceRoot":"","sources":["../../../../../src/actions/reinject-plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAiC,MAAM,eAAe,CAAC;AAc3E,eAAO,MAAM,oBAAoB,EAAE,MAuDlC,CAAC"}

package/packages/agent/src/actions/reinject-plugin.js

@@ -0,0 +1,47 @@
+import { requestRestart } from "@elizaos/shared/restart";
+function getPluginManager(runtime) {
+    return runtime.getService("plugin_manager");
+}
+export const reinjectPluginAction = {
+    name: "REINJECT_PLUGIN",
+    similes: ["UNEJECT_PLUGIN", "RESTORE_PLUGIN", "REMOVE_LOCAL_PLUGIN"],
+    description: "Remove an ejected plugin copy so runtime falls back to the npm package.",
+    validate: async () => true,
+    handler: async (runtime, _message, _state, options) => {
+        const params = options?.parameters;
+        const pluginId = typeof params?.pluginId === "string" ? params.pluginId.trim() : "";
+        if (!pluginId) {
+            return { text: "I need a plugin ID to reinject.", success: false };
+        }
+        const mgr = getPluginManager(runtime);
+        if (!mgr) {
+            return {
+                text: "Plugin manager service is not available.",
+                success: false,
+            };
+        }
+        const result = await mgr.reinjectPlugin(pluginId);
+        if (!result.success) {
+            return {
+                text: `Failed to reinject ${pluginId}: ${result.error ?? "unknown error"}`,
+                success: false,
+            };
+        }
+        setTimeout(() => {
+            requestRestart(`Plugin ${result.pluginName} reinjected`);
+        }, 1_000);
+        return {
+            text: `Removed ejected plugin ${result.pluginName}. Restarting to load npm version.`,
+            success: true,
+            data: { ...result },
+        };
+    },
+    parameters: [
+        {
+            name: "pluginId",
+            description: "Plugin ID or npm package to reinject (e.g. 'discord' or '@elizaos/plugin-discord')",
+            required: true,
+            schema: { type: "string" },
+        },
+    ],
+};

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

@@ -1,11 +1,4 @@
 import type { Action, IAgentRuntime, Memory, UUID } from "@elizaos/core";
-/**
- * Resolve the admin/owner entity ID.
- *
- * Priority:
- * 1. World ownership metadata (room-aware path -- mirrors admin-trust provider)
- * 2. Deterministic fallback from agent name (mirrors chat-routes / lifeops service)
- */
 export declare function resolveAdminEntityId(runtime: IAgentRuntime, message: Memory): Promise<UUID>;
 export declare const sendMessageAction: Action;
 //# sourceMappingURL=send-message.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"send-message.d.ts","sourceRoot":"","sources":["../../../../../src/actions/send-message.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,MAAM,EAIN,aAAa,EACb,MAAM,EACN,IAAI,EACL,MAAM,eAAe,CAAC;AAgCvB;;;;;;GAMG;AACH,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,aAAa,EACtB,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,IAAI,CAAC,CAQf;AAuED,eAAO,MAAM,iBAAiB,EAAE,MA0L/B,CAAC"}
+{"version":3,"file":"send-message.d.ts","sourceRoot":"","sources":["../../../../../src/actions/send-message.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,MAAM,EAIN,aAAa,EACb,MAAM,EACN,IAAI,EACL,MAAM,eAAe,CAAC;AAyCvB,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,aAAa,EACtB,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,IAAI,CAAC,CAQf;AA+LD,eAAO,MAAM,iBAAiB,EAAE,MAuO/B,CAAC"}

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

@@ -1,18 +1,12 @@
 import { logger, resolveCanonicalOwnerIdForMessage, stringToUuid, } from "@elizaos/core";
 import { hasAdminAccess } from "../security/access.js";
+import { formatContactCandidates, resolveContact, resolveContactCandidates, } from "./connector-resolver.js";
 import { hasContextSignalSyncForKey } from "./context-signal.js";
 const ADMIN_TARGETS = new Set(["admin", "owner"]);
 const VALID_URGENCIES = new Set(["normal", "important", "urgent"]);
 // ---------------------------------------------------------------------------
-// Admin pathway helpers (absorbed from send-admin-message.ts)
+// Admin pathway helpers
 // ---------------------------------------------------------------------------
-/**
- * Resolve the admin/owner entity ID.
- *
- * Priority:
- * 1. World ownership metadata (room-aware path -- mirrors admin-trust provider)
- * 2. Deterministic fallback from agent name (mirrors chat-routes / lifeops service)
- */
 export async function resolveAdminEntityId(runtime, message) {
     const ownerId = await resolveCanonicalOwnerIdForMessage(runtime, message);
     if (ownerId) {
@@ -21,14 +15,8 @@ export async function resolveAdminEntityId(runtime, message) {
     const agentName = runtime.character?.name ?? runtime.agentId;
     return stringToUuid(`${agentName}-admin-entity`);
 }
-/**
- * Handle sending a message to the admin/owner, optionally with urgency
- * escalation.
- */
 async function handleAdminMessage(runtime, message, text, urgency) {
     const adminEntityId = await resolveAdminEntityId(runtime, message);
-    // Urgent messages trigger multi-channel escalation (fire-and-forget --
-    // the primary send below still runs for immediate delivery).
     if (urgency === "urgent") {
         try {
             const { EscalationService } = await import("../services/escalation.js");
@@ -57,9 +45,6 @@ async function handleAdminMessage(runtime, message, text, urgency) {
         data: { actionName: "SEND_MESSAGE", targetType: "admin", urgency },
     };
 }
-/**
- * Detect whether the params indicate an admin/owner target.
- */
 function isAdminTarget(params) {
     const { target, source } = params;
     if (target && ADMIN_TARGETS.has(target.toLowerCase()))
@@ -69,6 +54,110 @@ function isAdminTarget(params) {
     return false;
 }
 // ---------------------------------------------------------------------------
+// Rolodex-based send pathway
+// ---------------------------------------------------------------------------
+async function handleRolodexSend(runtime, recipientName, text, platformHint) {
+    // Resolve contact via rolodex
+    const resolved = await resolveContact(runtime, recipientName, platformHint);
+    if (!resolved) {
+        // Try to get candidates for disambiguation
+        const candidates = await resolveContactCandidates(runtime, recipientName);
+        if (candidates.length > 0) {
+            return {
+                text: `Found ${candidates.length} contacts matching "${recipientName}" but none have a reachable platform:\n` +
+                    formatContactCandidates(candidates) +
+                    "\nSpecify a platform or use a more specific name.",
+                success: false,
+                values: { success: false, error: "NO_REACHABLE_PLATFORM" },
+                data: {
+                    actionName: "SEND_MESSAGE",
+                    recipient: recipientName,
+                    candidateCount: candidates.length,
+                },
+            };
+        }
+        return {
+            text: `No contacts found matching "${recipientName}" in the Rolodex. Use SEARCH_ENTITY to find contacts.`,
+            success: false,
+            values: { success: false, error: "CONTACT_NOT_FOUND" },
+            data: { actionName: "SEND_MESSAGE", recipient: recipientName },
+        };
+    }
+    if (!resolved.recommendedPlatform) {
+        return {
+            text: `Found ${resolved.person.displayName} in the Rolodex, but no connected platform is available to reach them.\n` +
+                `Known platforms: ${resolved.person.platforms.join(", ") || "none"}.\n` +
+                `Active connectors: check that the relevant connector is configured and running.`,
+            success: false,
+            values: { success: false, error: "NO_ACTIVE_CONNECTOR" },
+            data: {
+                actionName: "SEND_MESSAGE",
+                recipient: recipientName,
+                resolvedName: resolved.person.displayName,
+                knownPlatforms: resolved.person.platforms,
+            },
+        };
+    }
+    // Multiple reachable platforms and no clear preference — inform the user
+    // which platform we're using
+    const platform = resolved.recommendedPlatform;
+    const entityId = resolved.platformEntityIds.get(platform);
+    if (!entityId) {
+        return {
+            text: `Could not resolve entity ID for ${resolved.person.displayName} on ${platform}.`,
+            success: false,
+            values: { success: false, error: "ENTITY_RESOLUTION_FAILED" },
+            data: { actionName: "SEND_MESSAGE", recipient: recipientName, platform },
+        };
+    }
+    try {
+        await runtime.sendMessageToTarget({ source: platform, entityId }, {
+            text,
+            source: platform,
+            metadata: {
+                resolvedFrom: recipientName,
+                resolvedPerson: resolved.person.displayName,
+            },
+        });
+    }
+    catch (err) {
+        logger.error(`[SEND_MESSAGE] Failed to send to ${resolved.person.displayName} on ${platform}:`, String(err));
+        return {
+            text: `Failed to send message to ${resolved.person.displayName} on ${platform}: ${err instanceof Error ? err.message : String(err)}`,
+            success: false,
+            values: { success: false, error: "SEND_FAILED" },
+            data: {
+                actionName: "SEND_MESSAGE",
+                recipient: recipientName,
+                platform,
+                entityId,
+            },
+        };
+    }
+    const platformNote = resolved.reachablePlatforms.length > 1
+        ? ` (also reachable on: ${resolved.reachablePlatforms.filter((p) => p !== platform).join(", ")})`
+        : "";
+    return {
+        text: `Message sent to ${resolved.person.displayName} on ${platform}${platformNote}.`,
+        success: true,
+        values: {
+            success: true,
+            recipient: resolved.person.displayName,
+            platform,
+            entityId,
+        },
+        data: {
+            actionName: "SEND_MESSAGE",
+            recipient: recipientName,
+            resolvedName: resolved.person.displayName,
+            platform,
+            entityId,
+            reachablePlatforms: resolved.reachablePlatforms,
+            text,
+        },
+    };
+}
+// ---------------------------------------------------------------------------
 // Unified SEND_MESSAGE action
 // ---------------------------------------------------------------------------
 export const sendMessageAction = {
@@ -78,16 +167,20 @@ export const sendMessageAction = {
         "MESSAGE",
         "SEND_DM",
         "POST_MESSAGE",
-        // Absorbed from SEND_ADMIN_MESSAGE:
+        "TEXT_SOMEONE",
+        "MESSAGE_SOMEONE",
+        // Admin pathway:
         "MESSAGE_ADMIN",
         "NOTIFY_OWNER",
         "ALERT_ADMIN",
         "SEND_OWNER_MESSAGE",
     ],
-    description: "Send a message to a user, room, or the admin/owner. " +
+    description: "Send a message to a person, room, or the admin/owner. " +
+        "Use 'recipient' with a person's name to resolve via the Rolodex — " +
+        "the agent will find the right platform and handle automatically. " +
         "For admin messages, set target to 'admin' or 'owner'. " +
-        "Supports urgency levels for admin messages (normal, important, urgent). " +
-        "Urgent admin messages trigger multi-channel escalation.",
+        "For explicit routing, provide source + target + targetType directly. " +
+        "Supports urgency levels for admin messages (normal, important, urgent).",
     validate: async (runtime, message, state) => {
         if (!(await hasAdminAccess(runtime, message)))
             return false;
@@ -104,7 +197,7 @@ export const sendMessageAction = {
         }
         const params = (options?.parameters ??
             {});
-        const { targetType, source, target, text, urgency } = params;
+        const { targetType, source, target, text, urgency, recipient, platform } = params;
         if (!text || typeof text !== "string" || text.trim().length === 0) {
             return {
                 text: "SEND_MESSAGE requires a non-empty text parameter.",
@@ -115,15 +208,6 @@ export const sendMessageAction = {
         }
         // ── Admin/owner pathway ───────────────────────────────────────────
         if (isAdminTarget(params)) {
-            // Only the agent itself or admin/owner callers may send admin messages
-            if (!(await hasAdminAccess(runtime, message))) {
-                return {
-                    text: "Permission denied: only the agent or admin/owner may send admin messages.",
-                    success: false,
-                    values: { success: false, error: "PERMISSION_DENIED" },
-                    data: { actionName: "SEND_MESSAGE" },
-                };
-            }
             const adminUrgency = urgency ?? "normal";
             if (!VALID_URGENCIES.has(adminUrgency)) {
                 return {
@@ -135,10 +219,15 @@ export const sendMessageAction = {
             }
             return handleAdminMessage(runtime, message, text.trim(), adminUrgency);
         }
-        // ── Standard service-based send ───────────────────────────────────
+        // ── Rolodex-based send (recipient name resolution) ────────────────
+        if (recipient && typeof recipient === "string" && recipient.trim()) {
+            return handleRolodexSend(runtime, recipient.trim(), text.trim(), platform);
+        }
+        // ── Explicit service-based send ───────────────────────────────────
         if (!targetType || !source || !target) {
             return {
-                text: "SEND_MESSAGE requires targetType, source, and target parameters for non-admin messages.",
+                text: "SEND_MESSAGE requires either 'recipient' (person name for Rolodex lookup) " +
+                    "or explicit 'targetType' + 'source' + 'target' parameters.",
                 success: false,
                 values: { success: false, error: "INVALID_PARAMETERS" },
                 data: {
@@ -151,12 +240,30 @@ export const sendMessageAction = {
         }
         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 },
-            };
+            // Fall back to runtime.sendMessageToTarget which uses registered send handlers
+            try {
+                await runtime.sendMessageToTarget({ source, entityId: target }, { text: text.trim(), source });
+                return {
+                    text: `Message sent to ${targetType} ${target} on ${source}.`,
+                    success: true,
+                    values: { success: true, targetType, source, target },
+                    data: {
+                        actionName: "SEND_MESSAGE",
+                        targetType,
+                        source,
+                        target,
+                        text: text.trim(),
+                    },
+                };
+            }
+            catch {
+                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) {
@@ -204,29 +311,43 @@ export const sendMessageAction = {
         };
     },
     parameters: [
+        {
+            name: "recipient",
+            description: "Person's name for Rolodex-based resolution. The agent will automatically find " +
+                "the right platform and handle. Preferred over explicit target/source.",
+            required: false,
+            schema: { type: "string" },
+        },
+        {
+            name: "platform",
+            description: 'Platform hint for Rolodex resolution (e.g. "telegram", "discord", "signal"). ' +
+                "Optional — omit to let the agent pick the best platform.",
+            required: false,
+            schema: { type: "string" },
+        },
+        {
+            name: "text",
+            description: "Message text to send.",
+            required: true,
+            schema: { type: "string" },
+        },
         {
             name: "targetType",
-            description: "Target entity type: user or room. Not required when target is 'admin' or 'owner'.",
+            description: "Target entity type: user or room. Only needed for explicit routing (not Rolodex).",
             required: false,
             schema: { type: "string", enum: ["user", "room"] },
         },
         {
             name: "source",
-            description: "Messaging source/service name (e.g. telegram, discord). Not required when target is 'admin' or 'owner'.",
+            description: "Messaging source/service name (e.g. telegram, discord). Only needed for explicit routing.",
             required: false,
             schema: { type: "string" },
         },
         {
             name: "target",
             description: "Target identifier. Use 'admin' or 'owner' for admin messages. " +
-                "For users: entity ID/username. For rooms: room ID/name.",
-            required: true,
-            schema: { type: "string" },
-        },
-        {
-            name: "text",
-            description: "Message text to send.",
-            required: true,
+                "For users: entity ID/username. For rooms: room ID/name. Only needed for explicit routing.",
+            required: false,
             schema: { type: "string" },
         },
         {

package/packages/agent/src/actions/sync-plugin.d.ts

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

package/packages/agent/src/actions/sync-plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-plugin.d.ts","sourceRoot":"","sources":["../../../../../src/actions/sync-plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAiC,MAAM,eAAe,CAAC;AAc3E,eAAO,MAAM,gBAAgB,EAAE,MAwD9B,CAAC"}

package/packages/agent/src/actions/sync-plugin.js

@@ -0,0 +1,47 @@
+function getPluginManager(runtime) {
+    return runtime.getService("plugin_manager");
+}
+export const syncPluginAction = {
+    name: "SYNC_PLUGIN",
+    similes: ["UPDATE_PLUGIN", "PULL_PLUGIN_UPSTREAM", "SYNC_EJECTED_PLUGIN"],
+    description: "Sync an ejected plugin with upstream by fetching and merging new commits.",
+    validate: async () => true,
+    handler: async (runtime, _message, _state, options) => {
+        const params = options?.parameters;
+        const pluginId = typeof params?.pluginId === "string" ? params.pluginId.trim() : "";
+        if (!pluginId) {
+            return { text: "I need a plugin ID to sync.", success: false };
+        }
+        const mgr = getPluginManager(runtime);
+        if (!mgr) {
+            return {
+                text: "Plugin manager service is not available.",
+                success: false,
+            };
+        }
+        const result = await mgr.syncPlugin(pluginId);
+        if (!result.success) {
+            const conflictText = result.conflicts.length > 0
+                ? ` Conflicts: ${result.conflicts.join(", ")}`
+                : "";
+            return {
+                text: `Failed to sync ${pluginId}: ${result.error ?? "unknown error"}.${conflictText}`,
+                success: false,
+                data: { ...result },
+            };
+        }
+        return {
+            text: `Synced ${result.pluginName} (${result.upstreamCommits} upstream commits).`,
+            success: true,
+            data: { ...result },
+        };
+    },
+    parameters: [
+        {
+            name: "pluginId",
+            description: "Plugin ID or npm package to sync (e.g. 'discord' or '@elizaos/plugin-discord')",
+            required: true,
+            schema: { type: "string" },
+        },
+    ],
+};