@agentmbox/plugin-agentmbox 1.0.0 → 1.0.2

package/src/actions/getEmails.ts

@@ -1,153 +0,0 @@
-/**
- * Get Emails Action
- * Allows the agent to retrieve emails from the mailbox via AgentMBox
- */
-
-import {
-  type Action,
-  type HandlerCallback,
-  type IAgentRuntime,
-  type Memory,
-  type State,
-  type ActionExample,
-} from "@elizaos/core";
-import { AgentMBoxService } from "../services/AgentMBoxService";
-
-export const getEmailsAction: Action = {
-  name: "GET_EMAILS",
-  description: "Retrieve emails from the AgentMBox mailbox. Can filter by read status and limit results.",
-  handler: async (
-    runtime: IAgentRuntime,
-    message: Memory,
-    state: State,
-    options: Record<string, unknown>,
-    callback?: HandlerCallback
-  ) => {
-    const service = runtime.getService<AgentMBoxService>("agentmbox");
-    if (!service) {
-      throw new Error("AgentMBox service not initialized");
-    }
-
-    const limit = (options.limit as number) || 10;
-    const offset = (options.offset as number) || 0;
-    const emailId = options.emailId as string | undefined;
-
-    try {
-      // If emailId is provided, get a specific email
-      if (emailId) {
-        const emailDetail = await service.getEmail(emailId);
-
-        if (callback) {
-          await callback({
-            text: `Retrieved email: ${emailDetail.email.subject}`,
-            values: {
-              email: emailDetail.email,
-            },
-          });
-        }
-
-        return {
-          success: true,
-          values: {
-            email: emailDetail.email,
-          },
-        };
-      }
-
-      // Otherwise, list emails
-      const emailList = await service.listEmails(limit, offset);
-
-      // Filter by read status if specified
-      let emails = emailList.emails;
-      const unreadOnly = options.unreadOnly as boolean;
-      if (unreadOnly) {
-        emails = emails.filter((email) => !email.isRead);
-      }
-
-      if (callback) {
-        const preview = emails
-          .slice(0, 5)
-          .map((e) => `- ${e.subject} from ${e.from[0]?.email}`)
-          .join("\n");
-        await callback({
-          text: `Found ${emails.length} emails:\n${preview}`,
-          values: {
-            emails: emails,
-            total: emailList.emails.length,
-            unread: emailList.emails.filter((e) => !e.isRead).length,
-          },
-        });
-      }
-
-      return {
-        success: true,
-        values: {
-          emails: emails,
-          total: emailList.emails.length,
-          limit: emailList.limit,
-          offset: emailList.offset,
-        },
-      };
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      logger.error("Failed to get emails", { error: errorMessage });
-
-      if (callback) {
-        await callback({
-          text: `Failed to get emails: ${errorMessage}`,
-          values: {
-            success: false,
-            error: errorMessage,
-          },
-        });
-      }
-
-      return {
-        success: false,
-        error: errorMessage,
-      };
-    }
-  },
-  validate: async (runtime: IAgentRuntime) => {
-    try {
-      const service = runtime.getService<AgentMBoxService>("agentmbox");
-      return !!service;
-    } catch {
-      return false;
-    }
-  },
-  examples: [
-    [
-      {
-        name: "user",
-        content: "Check my inbox for any new emails",
-      },
-      {
-        name: "assistant",
-        content: "Let me check your inbox for new emails.",
-      },
-    ],
-    [
-      {
-        name: "user",
-        content: "Show me the last 5 emails I received",
-      },
-      {
-        name: "assistant",
-        content: "I'll retrieve your recent emails.",
-      },
-    ],
-    [
-      {
-        name: "user",
-        content: "Get the details of that email about the meeting",
-      },
-      {
-        name: "assistant",
-        content: "Let me fetch that email for you.",
-      },
-    ],
-  ] as ActionExample[][],
-};
-
-export default getEmailsAction;

package/src/actions/sendEmail.ts

@@ -1,132 +0,0 @@
-/**
- * Send Email Action
- * Allows the agent to send emails via AgentMBox
- */
-
-import {
-  type Action,
-  type HandlerCallback,
-  type IAgentRuntime,
-  type Memory,
-  type State,
-  type ActionExample,
-} from "@elizaos/core";
-import { AgentMBoxService } from "../services/AgentMBoxService";
-
-export const sendEmailAction: Action = {
-  name: "SEND_EMAIL",
-  description: "Send an email to a recipient using AgentMBox email service",
-  handler: async (
-    runtime: IAgentRuntime,
-    message: Memory,
-    state: State,
-    options: Record<string, unknown>,
-    callback?: HandlerCallback
-  ) => {
-    const service = runtime.getService<AgentMBoxService>("agentmbox");
-    if (!service) {
-      throw new Error("AgentMBox service not initialized");
-    }
-
-    const { to, subject, text, html } = options;
-
-    if (!to) {
-      throw new Error("Missing required field: 'to' (recipient email)");
-    }
-
-    if (!subject) {
-      throw new Error("Missing required field: 'subject'");
-    }
-
-    const from = options.from as string | undefined;
-
-    try {
-      const result = await service.sendEmail({
-        from,
-        to: Array.isArray(to) ? to : to,
-        subject,
-        text: text as string | undefined,
-        html: html as string | undefined,
-      });
-
-      if (callback) {
-        await callback({
-          text: `Email sent successfully to ${to}`,
-          values: {
-            success: result.success,
-            recipient: to,
-            subject,
-          },
-        });
-      }
-
-      return {
-        success: true,
-        values: {
-          sentTo: to,
-          subject,
-        },
-      };
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      logger.error("Failed to send email", { error: errorMessage });
-
-      if (callback) {
-        await callback({
-          text: `Failed to send email: ${errorMessage}`,
-          values: {
-            success: false,
-            error: errorMessage,
-          },
-        });
-      }
-
-      return {
-        success: false,
-        error: errorMessage,
-      };
-    }
-  },
-  validate: async (runtime: IAgentRuntime) => {
-    try {
-      const service = runtime.getService<AgentMBoxService>("agentmbox");
-      return !!service;
-    } catch {
-      return false;
-    }
-  },
-  examples: [
-    [
-      {
-        name: "user",
-        content: "Send an email to john@example.com about the project update",
-      },
-      {
-        name: "assistant",
-        content: "I'll send that email for you.",
-      },
-    ],
-    [
-      {
-        name: "user",
-        content: "Email the team that the meeting is at 3pm",
-      },
-      {
-        name: "assistant",
-        content: "Sending that email now.",
-      },
-    ],
-    [
-      {
-        name: "user",
-        content: "Can you notify alice@example.com that the report is ready?",
-      },
-      {
-        name: "assistant",
-        content: "I'll send her an email right away.",
-      },
-    ],
-  ] as ActionExample[][],
-};
-
-export default sendEmailAction;

package/src/index.ts

@@ -1,95 +0,0 @@
-/**
- * AgentMBox Plugin for ElizaOS
- * Email integration plugin that enables AI agents to send and receive emails
- * Includes autonomous self-onboarding using the agent's Solana wallet
- */
-
-import type { Plugin, IAgentRuntime } from "@elizaos/core";
-import { logger } from "@elizaos/core";
-import { AgentMBoxService } from "./services/AgentMBoxService";
-import { AgentMBoxOnboardingService } from "./services/AgentMBoxOnboardingService";
-import { sendEmailAction } from "./actions/sendEmail";
-import { getEmailsAction } from "./actions/getEmails";
-import { emailProvider } from "./providers/emailProvider";
-
-export const agentMBoxPlugin: Plugin = {
-  name: "agentmbox",
-  description:
-    "AgentMBox email integration plugin for ElizaOS - enables AI agents to send/receive emails with autonomous onboarding",
-  actions: [sendEmailAction, getEmailsAction],
-  providers: [emailProvider],
-  services: [AgentMBoxService, AgentMBoxOnboardingService],
-  init: async (config: Record<string, string>, runtime: IAgentRuntime) => {
-    logger.info("AgentMBox plugin initializing");
-
-    // Check if onboarding is needed
-    const existingApiKey = runtime.getSetting("AGENTMBOX_API_KEY");
-    const skipOnboarding =
-      runtime.getSetting("AGENTMBOX_SKIP_ONBOARDING") === "true";
-
-    if (!existingApiKey && !skipOnboarding) {
-      logger.info("Starting AgentMBox autonomous onboarding...");
-
-      try {
-        const onboardingService =
-          runtime.getService<AgentMBoxOnboardingService>(
-            "agentmbox-onboarding",
-          );
-        if (onboardingService) {
-          const status = await onboardingService.startOnboarding(runtime);
-
-          if (status.stage === "complete" && status.mailbox) {
-            // Save credentials to runtime settings for persistence
-            const apiKey = onboardingService.getApiKey();
-            const mailbox = onboardingService.getMailbox();
-            if (apiKey) {
-              runtime.setSetting("AGENTMBOX_API_KEY", apiKey, true);
-            }
-            if (mailbox) {
-              runtime.setSetting("AGENTMBOX_MAILBOX", mailbox);
-            }
-            logger.info("Onboarding complete! Mailbox: " + status.mailbox);
-          } else if (
-            status.stage === "awaiting_payment" &&
-            status.paymentAddress
-          ) {
-            logger.warn(
-              "Payment required. Please fund: " + status.paymentAddress,
-            );
-            logger.info("Required: 5 USDC on Solana + ~0.01 SOL for fees");
-          }
-        }
-      } catch (error) {
-        const errorMsg =
-          error instanceof Error ? error.message : "Unknown error";
-        logger.error("Onboarding failed: " + errorMsg);
-      }
-    } else if (existingApiKey) {
-      logger.info("Using existing AgentMBox configuration");
-    } else {
-      logger.info("Onboarding skipped per configuration");
-    }
-
-    // Initialize main email service (after onboarding has potentially saved credentials)
-    const emailService = runtime.getService<AgentMBoxService>("agentmbox");
-    if (emailService) {
-      try {
-        await emailService.initialize(runtime);
-      } catch (error) {
-        const errorMsg =
-          error instanceof Error ? error.message : "Unknown error";
-        logger.error(
-          "Failed to initialize AgentMBox email service: " + errorMsg,
-        );
-        // Don't fail the whole plugin initialization - the service will be unavailable
-      }
-    }
-  },
-};
-
-export default agentMBoxPlugin;
-
-// Re-export for convenience
-export { AgentMBoxService } from "./services/AgentMBoxService";
-export { AgentMBoxOnboardingService } from "./services/AgentMBoxOnboardingService";
-export * from "./types";

package/src/providers/emailProvider.ts

@@ -1,82 +0,0 @@
-/**
- * Email Provider
- * Provides email context to the agent, including unread counts and recent emails
- */
-
-import {
-    type Provider,
-    type IAgentRuntime,
-    type Memory,
-    type State,
-    type ProviderResult,
-} from "@elizaos/core";
-import { AgentMBoxService } from "../services/AgentMBoxService";
-
-export const emailProvider: Provider = {
-    name: "email",
-    description: "Provides email context from AgentMBox including unread counts and recent messages",
-    get: async (
-        runtime: IAgentRuntime,
-        message: Memory,
-        _state: State
-    ): Promise<ProviderResult> => {
-        try {
-            const service = runtime.getService<AgentMBoxService>("agentmbox");
-            if (!service) {
-                return {
-                    text: "Email service not available",
-                    values: {
-                        available: false,
-                    },
-                };
-            }
-
-            // Get recent emails
-            const emailList = await service.listEmails(10, 0);
-            const unreadCount = emailList.emails.filter((e) => !e.isRead).length;
-            const recentEmails = emailList.emails.slice(0, 5);
-
-            // Format recent emails for context
-            const recentEmailsText = recentEmails
-                .map(
-                    (email) =>
-                        `- From: ${email.from[0]?.name || email.from[0]?.email || "Unknown"} | Subject: ${email.subject}${
-                            !email.isRead ? " [UNREAD]" : ""
-                        }`
-                )
-                .join("\n");
-
-            return {
-                text: `Email Status: ${unreadCount} unread of ${emailList.emails.length} total${
-                    recentEmails.length > 0
-                        ? `\n\nRecent Emails:\n${recentEmailsText}`
-                        : "\n\nNo recent emails."
-                }`,
-                values: {
-                    available: true,
-                    unreadCount,
-                    totalEmails: emailList.emails.length,
-                    recentEmails: recentEmails.map((e) => ({
-                        id: e.id,
-                        from: e.from[0],
-                        subject: e.subject,
-                        preview: e.preview,
-                        isRead: e.isRead,
-                        receivedAt: e.receivedAt,
-                    })),
-                },
-            };
-        } catch (error) {
-            const errorMessage = error instanceof Error ? error.message : "Unknown error";
-            return {
-                text: `Email service error: ${errorMessage}`,
-                values: {
-                    available: false,
-                    error: errorMessage,
-                },
-            };
-        }
-    },
-};
-
-export default emailProvider;