@agentmbox/plugin-agentmbox 1.0.0

package/dist/index.js

@@ -0,0 +1,811 @@
+// src/index.ts
+import { logger as logger4 } from "@elizaos/core";
+
+// src/services/AgentMBoxService.ts
+import { Service, logger as logger2 } from "@elizaos/core";
+
+// src/types/index.ts
+function isAgentMBoxError(response) {
+  return typeof response === "object" && response !== null && "error" in response && typeof response.error === "string";
+}
+
+// src/services/AgentMBoxService.ts
+var AgentMBoxService = class _AgentMBoxService extends Service {
+  apiKey = "";
+  mailbox;
+  baseUrl = "https://agentmbox.com/api/v1";
+  static serviceName = "agentmbox";
+  constructor(runtime) {
+    super(runtime);
+  }
+  get serviceName() {
+    return _AgentMBoxService.serviceName;
+  }
+  get capabilityDescription() {
+    return "AgentMBox email service - allows sending and receiving emails";
+  }
+  async initialize(runtime) {
+    const apiKey = String(runtime.getSetting("AGENTMBOX_API_KEY") || "");
+    const mailbox = String(runtime.getSetting("AGENTMBOX_MAILBOX") || "");
+    const baseUrl = String(runtime.getSetting("AGENTMBOX_BASE_URL") || "");
+    if (!apiKey) {
+      throw new Error(
+        "AGENTMBOX_API_KEY is required. Get your API key from https://agentmbox.com"
+      );
+    }
+    const agentName = runtime.character?.name?.toLowerCase().replace(/\s+/g, "-") || "agent";
+    const defaultMailbox = mailbox || `${agentName}@agentmbox.com`;
+    this.apiKey = apiKey;
+    this.mailbox = defaultMailbox;
+    this.baseUrl = baseUrl || "https://agentmbox.com/api/v1";
+    this.runtime = runtime;
+    if (!this.apiKey.startsWith("ai_")) {
+      logger2.warn("AgentMBox API key should start with 'ai_'");
+    }
+    logger2.info("AgentMBox service initialized for: " + this.mailbox);
+  }
+  async stop() {
+    logger2.info("AgentMBox service stopped");
+  }
+  async request(endpoint, options = {}) {
+    const url = `${this.baseUrl}${endpoint}`;
+    const headers = {
+      Authorization: `Bearer ${this.apiKey}`,
+      "Content-Type": "application/json",
+      ...options.headers
+    };
+    const response = await fetch(url, { ...options, headers });
+    const data = await response.json();
+    if (!response.ok) {
+      if (isAgentMBoxError(data)) {
+        throw new Error(`AgentMBox API error (${response.status}): ${data.error}`);
+      }
+      throw new Error(`AgentMBox API error: ${response.status}`);
+    }
+    return data;
+  }
+  getMailboxParam() {
+    if (!this.mailbox) {
+      throw new Error("Mailbox not configured");
+    }
+    return "?mailbox=" + encodeURIComponent(this.mailbox);
+  }
+  async listEmails(limit = 50, offset = 0) {
+    const mailboxParam = this.getMailboxParam();
+    return this.request("/mail" + mailboxParam + "&limit=" + limit + "&offset=" + offset);
+  }
+  async getEmail(emailId) {
+    const mailboxParam = this.getMailboxParam();
+    return this.request("/mail/" + emailId + mailboxParam);
+  }
+  async sendEmail(request) {
+    const from = request.from || this.mailbox;
+    if (!from) {
+      throw new Error("Sender address not specified");
+    }
+    return this.request("/mail/send", {
+      method: "POST",
+      body: JSON.stringify({ ...request, from })
+    });
+  }
+  async deleteEmail(emailId) {
+    const mailboxParam = this.getMailboxParam();
+    return this.request("/mail/" + emailId + mailboxParam, {
+      method: "DELETE"
+    });
+  }
+  async listMailboxes() {
+    return this.request("/mailboxes");
+  }
+  async createMailbox(request) {
+    return this.request("/mailboxes", {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  async deleteMailbox(mailboxId) {
+    return this.request("/mailboxes/" + mailboxId, {
+      method: "DELETE"
+    });
+  }
+  async getPaymentStatus() {
+    return this.request("/payment");
+  }
+  async checkPayment() {
+    return this.request("/payment/check", {
+      method: "POST"
+    });
+  }
+  async listDomains() {
+    return this.request("/domains");
+  }
+  async addDomain(domain) {
+    return this.request("/domains", {
+      method: "POST",
+      body: JSON.stringify({ domain })
+    });
+  }
+  async verifyDomain(domainId) {
+    return this.request("/domains/" + domainId + "/verify", {
+      method: "POST"
+    });
+  }
+  async deleteDomain(domainId) {
+    return this.request("/domains/" + domainId, {
+      method: "DELETE"
+    });
+  }
+  async createApiKey(name) {
+    return this.request("/keys", {
+      method: "POST",
+      body: JSON.stringify({ name })
+    });
+  }
+  async getStatus() {
+    try {
+      const status = await this.getPaymentStatus();
+      return { paid: status.paid, paidUntil: status.paidUntil };
+    } catch (error) {
+      logger2.error("Failed to get AgentMBox status");
+      return { paid: false, paidUntil: null };
+    }
+  }
+};
+
+// src/services/AgentMBoxOnboardingService.ts
+import { Service as Service2, logger as logger3 } from "@elizaos/core";
+var AgentMBoxOnboardingService = class _AgentMBoxOnboardingService extends Service2 {
+  apiKey = "";
+  mailbox;
+  baseUrl = "https://agentmbox.com/api/v1";
+  cfg = null;
+  status = { stage: "pending" };
+  static serviceName = "agentmbox-onboarding";
+  constructor(runtime) {
+    super(runtime);
+  }
+  get serviceName() {
+    return _AgentMBoxOnboardingService.serviceName;
+  }
+  get capabilityDescription() {
+    return "AgentMBox autonomous onboarding - creates account, pays for subscription, sets up mailbox";
+  }
+  getApiKey() {
+    return this.apiKey;
+  }
+  getMailbox() {
+    return this.mailbox;
+  }
+  generatePassword(length = 32) {
+    const chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*";
+    let password = "";
+    const array = new Uint8Array(length);
+    crypto.getRandomValues(array);
+    for (let i = 0; i < length; i++) {
+      password += chars[array[i] % chars.length];
+    }
+    return password;
+  }
+  async getAgentWallet() {
+    if (!this.runtime) return null;
+    try {
+      const privateKeyBase58 = String(
+        this.runtime.getSetting("SOLANA_PRIVATE_KEY") || ""
+      );
+      if (privateKeyBase58) {
+        const { default: bs58 } = await import("bs58");
+        const { Keypair } = await import("@solana/web3.js");
+        const privateKey = bs58.decode(privateKeyBase58);
+        const keypair = Keypair.fromSecretKey(privateKey);
+        return {
+          publicKey: keypair.publicKey.toBase58(),
+          privateKey
+        };
+      }
+      const walletService = await this.runtime.getService("wallet");
+      if (walletService) {
+        const keypair = await walletService.getKeypair?.();
+        if (keypair) {
+          return {
+            publicKey: keypair.publicKey.toBase58(),
+            privateKey: keypair.secretKey
+          };
+        }
+      }
+    } catch (error) {
+      logger3.warn("Could not get agent wallet");
+    }
+    return null;
+  }
+  async request(endpoint, options = {}) {
+    const url = `${this.baseUrl}${endpoint}`;
+    const headers = {
+      "Content-Type": "application/json",
+      ...options.headers
+    };
+    const response = await fetch(url, { ...options, headers });
+    const data = await response.json();
+    if (!response.ok) {
+      const error = data.error || `${response.status}`;
+      throw new Error(error);
+    }
+    return data;
+  }
+  async authenticatedRequest(endpoint, options = {}) {
+    if (!this.apiKey) {
+      throw new Error("API key not set");
+    }
+    const url = `${this.baseUrl}${endpoint}`;
+    const headers = {
+      Authorization: `Bearer ${this.apiKey}`,
+      "Content-Type": "application/json",
+      ...options.headers
+    };
+    const response = await fetch(url, { ...options, headers });
+    const data = await response.json();
+    if (!response.ok) {
+      const error = data.error || `${response.status}`;
+      throw new Error(error);
+    }
+    return data;
+  }
+  async startOnboarding(runtime) {
+    this.runtime = runtime;
+    const existingApiKey = String(
+      runtime.getSetting("AGENTMBOX_API_KEY") || ""
+    );
+    if (existingApiKey && existingApiKey.startsWith("ai_")) {
+      this.apiKey = existingApiKey;
+      return await this.checkExistingSetup();
+    }
+    const agentName = runtime.character?.name?.toLowerCase().replace(/\s+/g, "-") || "agent";
+    const mailboxSetting = String(
+      runtime.getSetting("AGENTMBOX_MAILBOX") || ""
+    );
+    this.cfg = {
+      ownerEmail: String(runtime.getSetting("AGENTMBOX_OWNER_EMAIL")) || `agent-${agentName}@owner.local`,
+      password: this.generatePassword(32),
+      mailboxLocalPart: mailboxSetting ? mailboxSetting.split("@")[0] : agentName
+    };
+    try {
+      await this.createAccount();
+      this.status = { stage: "account_created" };
+      logger3.info("AgentMBox account created");
+      const apiKeyResponse = await this.createApiKey(agentName);
+      this.apiKey = apiKeyResponse.key;
+      this.status = { stage: "api_key_created" };
+      logger3.info("AgentMBox API key created");
+      const payment = await this.getPaymentStatus();
+      this.status = {
+        stage: "awaiting_payment",
+        paymentAddress: payment.solanaAddress
+      };
+      logger3.info("Payment address: " + payment.solanaAddress);
+      await this.payForSubscription(payment.solanaAddress, runtime);
+      this.status = { stage: "paid" };
+      logger3.info("Payment completed");
+      const mailbox = await this.createMailbox(this.cfg.mailboxLocalPart);
+      this.mailbox = mailbox.address;
+      this.status = {
+        stage: "complete",
+        mailbox: mailbox.address
+      };
+      logger3.info("Mailbox created: " + mailbox.address);
+      return this.status;
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : "Unknown error";
+      logger3.error("AgentMBox onboarding failed: " + errorMsg);
+      this.status = { stage: "error", error: errorMsg };
+      throw error;
+    }
+  }
+  async checkExistingSetup() {
+    try {
+      const payment = await this.getPaymentStatus();
+      if (payment.paid) {
+        const mailbox = await this.getOrCreateMailbox();
+        this.status = mailbox ? { stage: "complete", mailbox: mailbox.address } : { stage: "paid" };
+      } else {
+        const wallet = await this.getAgentWallet();
+        if (wallet && this.runtime) {
+          await this.payForSubscription(payment.solanaAddress, this.runtime);
+          this.status = { stage: "paid" };
+          const mailbox = await this.getOrCreateMailbox();
+          if (mailbox) {
+            this.status = { stage: "complete", mailbox: mailbox.address };
+          }
+        } else {
+          this.status = {
+            stage: "awaiting_payment",
+            paymentAddress: payment.solanaAddress
+          };
+        }
+      }
+    } catch (error) {
+      logger3.warn("Could not check existing setup");
+      this.status = { stage: "pending" };
+    }
+    return this.status;
+  }
+  async payForSubscription(paymentAddress, runtime) {
+    const wallet = await this.getAgentWallet();
+    if (!wallet) {
+      logger3.warn("No agent wallet found, waiting for manual payment");
+      await this.waitForPayment();
+      return;
+    }
+    logger3.info("Using agent wallet to pay for subscription");
+    try {
+      const { Connection, Keypair } = await import("@solana/web3.js");
+      const { transfer, getOrCreateAssociatedTokenAccount } = await import("@solana/spl-token");
+      const connection = new Connection("https://api.mainnet-beta.solana.com");
+      const signer = Keypair.fromSecretKey(wallet.privateKey);
+      const usdcMintStr = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGZwyTDt1v";
+      const { PublicKey } = await import("@solana/web3.js");
+      const usdcMint = new PublicKey(usdcMintStr);
+      const toPublicKey = new PublicKey(paymentAddress);
+      const fromTokenAccount = await getOrCreateAssociatedTokenAccount(
+        connection,
+        signer,
+        usdcMint,
+        signer.publicKey
+      );
+      const toTokenAccount = await getOrCreateAssociatedTokenAccount(
+        connection,
+        signer,
+        usdcMint,
+        toPublicKey
+      );
+      const amount = 5e6;
+      await transfer(
+        connection,
+        signer,
+        fromTokenAccount.address,
+        toTokenAccount.address,
+        signer.publicKey,
+        amount
+      );
+      logger3.info("USDC transfer complete");
+      await this.waitForPayment();
+    } catch (error) {
+      logger3.error("Failed to transfer USDC, waiting for manual payment");
+      await this.waitForPayment();
+    }
+  }
+  async stop() {
+    logger3.info("AgentMBox onboarding service stopped");
+  }
+  async createAccount() {
+    if (!this.cfg) throw new Error("Config not set");
+    const response = await this.request("/auth/signup", {
+      method: "POST",
+      body: JSON.stringify({
+        email: this.cfg.ownerEmail,
+        password: this.cfg.password
+      })
+    });
+    logger3.info("Account created: " + response.id);
+  }
+  async createApiKey(name) {
+    const response = await this.request("/keys", {
+      method: "POST",
+      body: JSON.stringify({ name })
+    });
+    logger3.info("API key created: " + response.key.substring(0, 12) + "...");
+    return response;
+  }
+  async getPaymentStatus() {
+    return this.authenticatedRequest("/payment");
+  }
+  async waitForPayment(maxAttempts = 60, intervalMs = 5e3) {
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        const result = await this.authenticatedRequest(
+          "/payment/check",
+          {
+            method: "POST"
+          }
+        );
+        if (result.paid) {
+          return result;
+        }
+        logger3.info(
+          "Waiting for payment... (" + attempt + "/" + maxAttempts + ")"
+        );
+      } catch (e) {
+        logger3.warn(
+          "Payment check failed: " + (e instanceof Error ? e.message : "unknown")
+        );
+      }
+      if (attempt < maxAttempts) {
+        await new Promise((resolve) => setTimeout(resolve, intervalMs));
+      }
+    }
+    throw new Error("Payment not received after " + maxAttempts + " attempts");
+  }
+  async createMailbox(localPart) {
+    const response = await this.authenticatedRequest(
+      "/mailboxes",
+      {
+        method: "POST",
+        body: JSON.stringify({
+          localPart,
+          displayName: this.cfg?.mailboxLocalPart || "Agent Mailbox"
+        })
+      }
+    );
+    return response.mailbox;
+  }
+  async getOrCreateMailbox() {
+    try {
+      const response = await this.authenticatedRequest("/mailboxes");
+      if (response.mailboxes.length > 0) {
+        return response.mailboxes[0];
+      }
+      if (this.cfg?.mailboxLocalPart) {
+        return await this.createMailbox(this.cfg.mailboxLocalPart);
+      }
+      return null;
+    } catch (error) {
+      logger3.error("Failed to get/create mailbox");
+      return null;
+    }
+  }
+  getStatus() {
+    return this.status;
+  }
+  async getPaymentAddress() {
+    if (this.status.paymentAddress) {
+      return this.status.paymentAddress;
+    }
+    try {
+      const payment = await this.getPaymentStatus();
+      return payment.solanaAddress;
+    } catch {
+      return null;
+    }
+  }
+  isOnboardingComplete() {
+    return this.status.stage === "complete";
+  }
+};
+
+// src/actions/sendEmail.ts
+var sendEmailAction = {
+  name: "SEND_EMAIL",
+  description: "Send an email to a recipient using AgentMBox email service",
+  handler: async (runtime, message, state, options, callback) => {
+    const service = runtime.getService("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;
+    try {
+      const result = await service.sendEmail({
+        from,
+        to: Array.isArray(to) ? to : to,
+        subject,
+        text,
+        html
+      });
+      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) => {
+    try {
+      const service = runtime.getService("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."
+      }
+    ]
+  ]
+};
+
+// src/actions/getEmails.ts
+var getEmailsAction = {
+  name: "GET_EMAILS",
+  description: "Retrieve emails from the AgentMBox mailbox. Can filter by read status and limit results.",
+  handler: async (runtime, message, state, options, callback) => {
+    const service = runtime.getService("agentmbox");
+    if (!service) {
+      throw new Error("AgentMBox service not initialized");
+    }
+    const limit = options.limit || 10;
+    const offset = options.offset || 0;
+    const emailId = options.emailId;
+    try {
+      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
+          }
+        };
+      }
+      const emailList = await service.listEmails(limit, offset);
+      let emails = emailList.emails;
+      const unreadOnly = options.unreadOnly;
+      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:
+${preview}`,
+          values: {
+            emails,
+            total: emailList.emails.length,
+            unread: emailList.emails.filter((e) => !e.isRead).length
+          }
+        });
+      }
+      return {
+        success: true,
+        values: {
+          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) => {
+    try {
+      const service = runtime.getService("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."
+      }
+    ]
+  ]
+};
+
+// src/providers/emailProvider.ts
+var emailProvider = {
+  name: "email",
+  description: "Provides email context from AgentMBox including unread counts and recent messages",
+  get: async (runtime, message, _state) => {
+    try {
+      const service = runtime.getService("agentmbox");
+      if (!service) {
+        return {
+          text: "Email service not available",
+          values: {
+            available: false
+          }
+        };
+      }
+      const emailList = await service.listEmails(10, 0);
+      const unreadCount = emailList.emails.filter((e) => !e.isRead).length;
+      const recentEmails = emailList.emails.slice(0, 5);
+      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 ? `
+
+Recent Emails:
+${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
+        }
+      };
+    }
+  }
+};
+
+// src/index.ts
+var agentMBoxPlugin = {
+  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, runtime) => {
+    logger4.info("AgentMBox plugin initializing");
+    const existingApiKey = runtime.getSetting("AGENTMBOX_API_KEY");
+    const skipOnboarding = runtime.getSetting("AGENTMBOX_SKIP_ONBOARDING") === "true";
+    if (!existingApiKey && !skipOnboarding) {
+      logger4.info("Starting AgentMBox autonomous onboarding...");
+      try {
+        const onboardingService = runtime.getService(
+          "agentmbox-onboarding"
+        );
+        if (onboardingService) {
+          const status = await onboardingService.startOnboarding(runtime);
+          if (status.stage === "complete" && status.mailbox) {
+            const apiKey = onboardingService.getApiKey();
+            const mailbox = onboardingService.getMailbox();
+            if (apiKey) {
+              runtime.setSetting("AGENTMBOX_API_KEY", apiKey, true);
+            }
+            if (mailbox) {
+              runtime.setSetting("AGENTMBOX_MAILBOX", mailbox);
+            }
+            logger4.info("Onboarding complete! Mailbox: " + status.mailbox);
+          } else if (status.stage === "awaiting_payment" && status.paymentAddress) {
+            logger4.warn(
+              "Payment required. Please fund: " + status.paymentAddress
+            );
+            logger4.info("Required: 5 USDC on Solana + ~0.01 SOL for fees");
+          }
+        }
+      } catch (error) {
+        const errorMsg = error instanceof Error ? error.message : "Unknown error";
+        logger4.error("Onboarding failed: " + errorMsg);
+      }
+    } else if (existingApiKey) {
+      logger4.info("Using existing AgentMBox configuration");
+    } else {
+      logger4.info("Onboarding skipped per configuration");
+    }
+    const emailService = runtime.getService("agentmbox");
+    if (emailService) {
+      try {
+        await emailService.initialize(runtime);
+      } catch (error) {
+        const errorMsg = error instanceof Error ? error.message : "Unknown error";
+        logger4.error(
+          "Failed to initialize AgentMBox email service: " + errorMsg
+        );
+      }
+    }
+  }
+};
+var index_default = agentMBoxPlugin;
+export {
+  AgentMBoxOnboardingService,
+  AgentMBoxService,
+  agentMBoxPlugin,
+  index_default as default,
+  isAgentMBoxError
+};
+//# sourceMappingURL=index.js.map