@elizaos/plugin-blooio 2.0.0-alpha.1

package/dist/index.js

@@ -0,0 +1,1019 @@
+// src/index.ts
+import { logger as logger5 } from "@elizaos/core";
+
+// src/actions/sendMessage.ts
+import {
+  logger as logger2
+} from "@elizaos/core";
+
+// src/constants.ts
+var MESSAGE_CONSTANTS = {
+  MAX_MESSAGES: 10,
+  RECENT_MESSAGE_COUNT: 3,
+  CHAT_HISTORY_COUNT: 5,
+  INTEREST_DECAY_TIME: 5 * 60 * 1e3,
+  // 5 minutes
+  PARTIAL_INTEREST_DECAY: 3 * 60 * 1e3,
+  // 3 minutes
+  DEFAULT_SIMILARITY_THRESHOLD: 0.3,
+  DEFAULT_SIMILARITY_THRESHOLD_FOLLOW_UPS: 0.2
+};
+var BLOOIO_SERVICE_NAME = "blooio";
+var BLOOIO_CONSTANTS = {
+  API_BASE_URL: "https://backend.blooio.com/v2/api",
+  WEBHOOK_PATHS: {
+    EVENTS: "/webhook"
+  },
+  SIGNATURE_TOLERANCE_SECONDS: 300,
+  CACHE_TTL: {
+    CONVERSATION: 3600
+    // 1 hour
+  }
+};
+var ERROR_MESSAGES = {
+  INVALID_CHAT_ID: "Invalid chat identifier. Use E.164 (+15551234567), email, or group id (grp_xxxx).",
+  MISSING_API_KEY: "Blooio API key not configured",
+  MISSING_WEBHOOK_URL: "Blooio webhook URL not configured",
+  WEBHOOK_VALIDATION_FAILED: "Failed to validate Blooio webhook signature"
+};
+
+// src/utils.ts
+import crypto from "crypto";
+import { logger } from "@elizaos/core";
+var E164_REGEX = /^\+\d{1,15}$/;
+var EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+var GROUP_REGEX = /^grp_[A-Za-z0-9]+$/;
+function isE164(value) {
+  return E164_REGEX.test(value);
+}
+function isEmail(value) {
+  return EMAIL_REGEX.test(value);
+}
+function isGroupId(value) {
+  return GROUP_REGEX.test(value);
+}
+function validateChatId(chatId) {
+  const parts = chatId.split(",").map((part) => part.trim()).filter((part) => part.length > 0);
+  if (parts.length === 0) {
+    return false;
+  }
+  return parts.every(
+    (part) => isE164(part) || isEmail(part) || isGroupId(part)
+  );
+}
+function extractChatIdCandidates(text) {
+  const matches = [];
+  const capture = (regex) => {
+    let match = regex.exec(text);
+    while (match) {
+      matches.push({ value: match[0], index: match.index });
+      match = regex.exec(text);
+    }
+  };
+  capture(/\+\d{1,15}/g);
+  capture(/\bgrp_[A-Za-z0-9]+\b/g);
+  capture(/\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g);
+  matches.sort((a, b) => a.index - b.index);
+  const unique = [];
+  for (const match of matches) {
+    if (!unique.includes(match.value)) {
+      unique.push(match.value);
+    }
+  }
+  return unique;
+}
+function extractAttachmentUrls(text) {
+  const urls = text.match(/https?:\/\/[^\s)]+/g) ?? [];
+  return Array.from(new Set(urls));
+}
+function stripChatIdsFromText(text, chatIds) {
+  let cleaned = text;
+  for (const chatId of chatIds) {
+    const escaped = escapeRegExp(chatId);
+    cleaned = cleaned.replace(new RegExp(escaped, "g"), "");
+  }
+  return cleaned.trim();
+}
+function getWebhookPath(webhookUrl) {
+  try {
+    const parsed = new URL(webhookUrl);
+    return parsed.pathname || BLOOIO_CONSTANTS.WEBHOOK_PATHS.EVENTS;
+  } catch (error) {
+    logger.warn(
+      { error: String(error) },
+      "Invalid webhook URL, using default path"
+    );
+    return BLOOIO_CONSTANTS.WEBHOOK_PATHS.EVENTS;
+  }
+}
+function verifyWebhookSignature(secret, signatureHeader, rawBody, toleranceSeconds = BLOOIO_CONSTANTS.SIGNATURE_TOLERANCE_SECONDS) {
+  const parsed = parseSignatureHeader(signatureHeader);
+  if (!parsed) {
+    logger.warn(
+      { signatureHeader: signatureHeader.substring(0, 50) },
+      "Failed to parse signature header"
+    );
+    return false;
+  }
+  const { timestamp, signature } = parsed;
+  const timestampNumber = Number(timestamp);
+  if (!Number.isFinite(timestampNumber)) {
+    logger.warn({ timestamp }, "Invalid timestamp in signature");
+    return false;
+  }
+  const nowSeconds = Math.floor(Date.now() / 1e3);
+  const timeDiff = Math.abs(nowSeconds - timestampNumber);
+  if (timeDiff > toleranceSeconds) {
+    logger.warn(
+      { timestampNumber, nowSeconds, timeDiff, toleranceSeconds },
+      "Webhook signature timestamp out of tolerance"
+    );
+    return false;
+  }
+  const payload = `${timestamp}.${rawBody}`;
+  const expected = crypto.createHmac("sha256", secret).update(payload).digest("hex");
+  const isValid = timingSafeEqual(expected, signature);
+  if (!isValid) {
+    logger.warn(
+      {
+        expectedFirst8: expected.substring(0, 8),
+        actualFirst8: signature.substring(0, 8),
+        bodyLength: rawBody.length
+      },
+      "Webhook signature mismatch"
+    );
+  }
+  return isValid;
+}
+function parseSignatureHeader(header) {
+  const parts = header.split(",").map((part) => part.trim());
+  const timestampPart = parts.find((part) => part.startsWith("t="));
+  const signaturePart = parts.find((part) => part.startsWith("v1="));
+  if (!timestampPart || !signaturePart) {
+    return null;
+  }
+  const timestamp = timestampPart.split("=")[1];
+  const signature = signaturePart.split("=")[1];
+  if (!timestamp || !signature) {
+    return null;
+  }
+  return { timestamp, signature };
+}
+function timingSafeEqual(expected, actual) {
+  const expectedBuffer = Buffer.from(expected, "hex");
+  const actualBuffer = Buffer.from(actual, "hex");
+  if (expectedBuffer.length !== actualBuffer.length) {
+    return false;
+  }
+  return crypto.timingSafeEqual(expectedBuffer, actualBuffer);
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/actions/sendMessage.ts
+var sendMessageAction = {
+  name: "SEND_MESSAGE",
+  description: "Send a message via Blooio to a chat (phone, email, or group)",
+  validate: async (runtime, message, _state) => {
+    const blooioService = runtime.getService(BLOOIO_SERVICE_NAME);
+    if (!blooioService) {
+      logger2.error("Blooio service not found");
+      return false;
+    }
+    const text = typeof message.content?.text === "string" ? message.content.text : "";
+    const candidates = extractChatIdCandidates(text);
+    return candidates.some((candidate) => validateChatId(candidate));
+  },
+  handler: async (runtime, message, _state, _options, callback) => {
+    try {
+      const blooioService = runtime.getService(
+        BLOOIO_SERVICE_NAME
+      );
+      if (!blooioService) {
+        throw new Error("Blooio service not available");
+      }
+      const text = typeof message.content?.text === "string" ? message.content.text : "";
+      const candidates = extractChatIdCandidates(text);
+      const validRecipients = candidates.filter(
+        (candidate) => validateChatId(candidate)
+      );
+      if (validRecipients.length === 0) {
+        throw new Error("No valid chat identifier found in message");
+      }
+      const chatId = validRecipients.map((recipient) => recipient.trim()).join(",");
+      const outboundAttachments = [];
+      const urlsFromText = extractAttachmentUrls(text);
+      for (const url of urlsFromText) {
+        outboundAttachments.push(url);
+      }
+      const contentAttachments = message.content?.attachments;
+      if (contentAttachments && Array.isArray(contentAttachments)) {
+        for (const attachment of contentAttachments) {
+          if (typeof attachment === "object" && attachment !== null) {
+            const media = attachment;
+            if (media.url) {
+              outboundAttachments.push({
+                url: media.url,
+                name: media.title ?? media.description ?? void 0
+              });
+            }
+          }
+        }
+      }
+      let messageContent = stripChatIdsFromText(text, validRecipients);
+      for (const url of urlsFromText) {
+        messageContent = messageContent.replace(url, "");
+      }
+      messageContent = messageContent.replace(/send\s+(a\s+)?(message|text|imessage|sms)?\s*(to)?\s*/gi, "").replace(/^\s*to\s+/i, "").replace(/^\s*(saying|with)\s*/gi, "").replace(/^\s*["']|["']\s*$/g, "").replace(/\s+/g, " ").trim();
+      if (/^(send|message|text|imessage|sms|saying|with|to)?$/i.test(
+        messageContent
+      )) {
+        messageContent = "";
+      }
+      if (!messageContent && outboundAttachments.length === 0) {
+        messageContent = "Hello from your assistant.";
+      }
+      await blooioService.sendMessage(chatId, {
+        text: messageContent || void 0,
+        attachments: outboundAttachments.length > 0 ? outboundAttachments : void 0
+      });
+      if (callback) {
+        await callback({
+          text: `Message sent successfully to ${chatId}`,
+          success: true
+        });
+      }
+    } catch (error) {
+      logger2.error(
+        { error: String(error) },
+        "Error sending message via Blooio"
+      );
+      if (callback) {
+        await callback({
+          text: `Failed to send message: ${error instanceof Error ? error.message : "Unknown error"}`,
+          success: false
+        });
+      }
+    }
+  },
+  examples: [
+    [
+      {
+        name: "user",
+        content: {
+          text: "Send a message to +17147023671 saying 'Hello from Blooio!'"
+        }
+      },
+      {
+        name: "assistant",
+        content: {
+          text: "I'll send that message.",
+          action: "SEND_MESSAGE"
+        }
+      }
+    ],
+    [
+      {
+        name: "user",
+        content: {
+          text: "Message jane@example.com with 'Your iMessage is ready.'"
+        }
+      },
+      {
+        name: "assistant",
+        content: {
+          text: "Sending that now.",
+          action: "SEND_MESSAGE"
+        }
+      }
+    ]
+  ],
+  similes: ["send message", "send imessage", "text", "message"]
+};
+var sendMessage_default = sendMessageAction;
+
+// src/providers/conversationHistory.ts
+var conversationHistoryProvider = {
+  name: "blooioConversationHistory",
+  description: "Provides recent Blooio conversation history with a chat",
+  get: async (runtime, message, _state) => {
+    try {
+      const blooioService = runtime.getService(
+        BLOOIO_SERVICE_NAME
+      );
+      if (!blooioService) {
+        return {
+          text: "No Blooio conversation history available - service not initialized"
+        };
+      }
+      if (typeof message.content === "string") {
+        return {
+          text: "No chat identifier found in context"
+        };
+      }
+      const chatId = typeof message.content?.chatId === "string" ? message.content.chatId : typeof message.content?.phoneNumber === "string" ? message.content.phoneNumber : message.content?.text?.match(
+        /(\+\d{1,15}|grp_[A-Za-z0-9]+|[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,})/
+      )?.[0];
+      if (!chatId || typeof chatId !== "string") {
+        return {
+          text: "No chat identifier found in context"
+        };
+      }
+      const conversationHistory = blooioService.getConversationHistory(
+        chatId,
+        10
+      );
+      if (!conversationHistory || conversationHistory.length === 0) {
+        return {
+          text: `No recent conversation history with ${chatId}`
+        };
+      }
+      const history = conversationHistory.map((msg) => {
+        const direction = msg.direction === "inbound" ? "From" : "To";
+        const time = new Date(msg.timestamp).toLocaleString();
+        const text = msg.text ?? "(no text)";
+        return `[${time}] ${direction} ${chatId}: ${text}`;
+      }).join("\n");
+      return {
+        text: `Recent Blooio conversation with ${chatId}:
+${history}`,
+        data: {
+          chatId,
+          messageCount: conversationHistory.length,
+          lastMessage: conversationHistory[conversationHistory.length - 1]
+        }
+      };
+    } catch (error) {
+      console.error("Error in conversationHistoryProvider:", error);
+      return {
+        text: "Error retrieving conversation history"
+      };
+    }
+  }
+};
+var conversationHistory_default = conversationHistoryProvider;
+
+// src/service.ts
+import {
+  ChannelType,
+  ContentType,
+  EventType,
+  Service,
+  createMessageMemory,
+  createUniqueUuid,
+  logger as logger3,
+  stringToUuid
+} from "@elizaos/core";
+import bodyParser from "body-parser";
+import express from "express";
+import NodeCache from "node-cache";
+
+// src/types.ts
+import { z } from "zod";
+var BlooioError = class extends Error {
+  constructor(message, statusCode, details) {
+    super(message);
+    this.statusCode = statusCode;
+    this.details = details;
+    this.name = "BlooioError";
+  }
+};
+var SendMessageSchema = z.object({
+  chatId: z.string().min(1),
+  text: z.string().min(1).optional(),
+  attachments: z.array(z.string().url()).optional()
+});
+var CACHE_KEYS = {
+  CONVERSATION: (chatId) => `blooio:conversation:${chatId}`
+};
+
+// src/service.ts
+var getMessageService = (runtime) => {
+  if ("messageService" in runtime) {
+    const withMessageService = runtime;
+    return withMessageService.messageService ?? null;
+  }
+  return null;
+};
+var BlooioService = class _BlooioService extends Service {
+  static serviceType = BLOOIO_SERVICE_NAME;
+  static async start(runtime) {
+    const service = new _BlooioService();
+    await service.initialize(runtime);
+    return service;
+  }
+  static async stop(_runtime) {
+    return;
+  }
+  blooioConfig;
+  app;
+  server = null;
+  cache;
+  isInitialized = false;
+  constructor() {
+    super();
+    this.cache = new NodeCache({ stdTTL: 600 });
+  }
+  async initialize(runtime) {
+    if (this.isInitialized) {
+      logger3.warn("BlooioService already initialized");
+      return;
+    }
+    this.runtime = runtime;
+    const apiKey = runtime.getSetting("BLOOIO_API_KEY");
+    const webhookUrl = runtime.getSetting("BLOOIO_WEBHOOK_URL");
+    const webhookSecret = runtime.getSetting("BLOOIO_WEBHOOK_SECRET");
+    const baseUrlSetting = runtime.getSetting("BLOOIO_BASE_URL");
+    const webhookPortSetting = runtime.getSetting(
+      "BLOOIO_WEBHOOK_PORT"
+    );
+    const fromNumber = runtime.getSetting("BLOOIO_FROM_NUMBER");
+    const signatureToleranceSetting = runtime.getSetting(
+      "BLOOIO_SIGNATURE_TOLERANCE_SEC"
+    );
+    const webhookPathSetting = runtime.getSetting(
+      "BLOOIO_WEBHOOK_PATH"
+    );
+    const webhookPort = Number.parseInt(webhookPortSetting || "3001", 10);
+    const signatureToleranceSeconds = Number.parseInt(
+      signatureToleranceSetting || "",
+      10
+    );
+    const resolvedSignatureTolerance = Number.isFinite(signatureToleranceSeconds) && signatureToleranceSeconds > 0 ? signatureToleranceSeconds : BLOOIO_CONSTANTS.SIGNATURE_TOLERANCE_SECONDS;
+    if (!apiKey || apiKey.trim() === "") {
+      throw new BlooioError(ERROR_MESSAGES.MISSING_API_KEY);
+    }
+    if (!webhookUrl || webhookUrl.trim() === "") {
+      throw new BlooioError(ERROR_MESSAGES.MISSING_WEBHOOK_URL);
+    }
+    const webhookPathRaw = webhookPathSetting && webhookPathSetting.trim() !== "" ? webhookPathSetting : getWebhookPath(webhookUrl);
+    const webhookPath = webhookPathRaw.startsWith("/") ? webhookPathRaw : `/${webhookPathRaw}`;
+    this.blooioConfig = {
+      apiKey,
+      webhookUrl,
+      webhookPath,
+      webhookPort: Number.isFinite(webhookPort) ? webhookPort : 3001,
+      webhookSecret: webhookSecret?.trim() ? webhookSecret : void 0,
+      baseUrl: baseUrlSetting?.trim() ? baseUrlSetting.trim() : BLOOIO_CONSTANTS.API_BASE_URL,
+      fromNumber: fromNumber?.trim() ? fromNumber.trim() : void 0,
+      signatureToleranceSeconds: resolvedSignatureTolerance
+    };
+    if (!this.blooioConfig.webhookSecret) {
+      logger3.warn(
+        "Blooio webhook secret not set; signature validation disabled"
+      );
+    }
+    await this.setupWebhookServer();
+    this.isInitialized = true;
+    logger3.info("BlooioService initialized successfully");
+  }
+  async stop() {
+    await this.cleanup();
+  }
+  get capabilityDescription() {
+    return "Blooio iMessage/SMS integration service for bidirectional messaging";
+  }
+  async setupWebhookServer() {
+    this.app = express();
+    this.app.use(
+      bodyParser.json({
+        verify: (req, _res, buf) => {
+          const typed = req;
+          typed.rawBody = buf.toString("utf8");
+        }
+      })
+    );
+    this.app.get("/health", (_req, res) => {
+      res.json({ status: "ok", service: "blooio" });
+    });
+    this.app.post(
+      this.blooioConfig.webhookPath,
+      async (req, res) => {
+        logger3.info(
+          {
+            path: req.path,
+            method: req.method,
+            headers: {
+              "X-Blooio-Event": req.header("X-Blooio-Event"),
+              "X-Blooio-Message-Id": req.header("X-Blooio-Message-Id"),
+              "Content-Type": req.header("Content-Type")
+            }
+          },
+          "Blooio webhook request received"
+        );
+        try {
+          const signatureHeader = req.header("X-Blooio-Signature") ?? "";
+          const eventHeader = req.header("X-Blooio-Event") ?? "";
+          const rawBody = typeof req.rawBody === "string" ? req.rawBody : "";
+          if (this.blooioConfig.webhookSecret) {
+            const valid = verifyWebhookSignature(
+              this.blooioConfig.webhookSecret,
+              signatureHeader,
+              rawBody,
+              this.blooioConfig.signatureToleranceSeconds
+            );
+            if (!valid) {
+              logger3.warn("Blooio webhook signature validation failed");
+              res.status(401).send(ERROR_MESSAGES.WEBHOOK_VALIDATION_FAILED);
+              return;
+            }
+          }
+          const payload = req.body;
+          if (!payload || typeof payload.event !== "string") {
+            logger3.warn({ body: req.body }, "Invalid webhook payload received");
+            res.status(400).send("Invalid webhook payload");
+            return;
+          }
+          logger3.info(
+            {
+              event: payload.event,
+              message_id: payload.message_id,
+              external_id: payload.external_id
+            },
+            "Processing Blooio webhook event"
+          );
+          if (eventHeader && payload.event !== eventHeader) {
+            logger3.warn(
+              { eventHeader, payloadEvent: payload.event },
+              "Blooio webhook event header mismatch"
+            );
+          }
+          await this.handleWebhookEvent(payload);
+          logger3.info(
+            { event: payload.event },
+            "Blooio webhook processed successfully"
+          );
+          res.sendStatus(200);
+        } catch (error) {
+          logger3.error(
+            { error: String(error) },
+            "Error handling Blooio webhook"
+          );
+          res.sendStatus(500);
+        }
+      }
+    );
+    this.server = this.app.listen(this.blooioConfig.webhookPort, () => {
+      logger3.info(
+        `Blooio webhook server listening on port ${this.blooioConfig.webhookPort} (${this.blooioConfig.webhookPath})`
+      );
+    });
+  }
+  async sendMessage(chatId, request) {
+    const normalizedChatId = chatId.split(",").map((part) => part.trim()).filter(Boolean).join(",");
+    if (!validateChatId(normalizedChatId)) {
+      throw new BlooioError(ERROR_MESSAGES.INVALID_CHAT_ID);
+    }
+    const url = `${this.blooioConfig.baseUrl}/chats/${encodeURIComponent(normalizedChatId)}/messages`;
+    const payload = {
+      text: request.text,
+      attachments: request.attachments,
+      metadata: request.metadata,
+      use_typing_indicator: request.use_typing_indicator,
+      fromNumber: request.fromNumber ?? this.blooioConfig.fromNumber
+    };
+    const cleanedPayload = Object.fromEntries(
+      Object.entries(payload).filter(([, value]) => value !== void 0)
+    );
+    const idempotencyKey = request.idempotencyKey?.trim();
+    const fromNumber = request.fromNumber ?? this.blooioConfig.fromNumber;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.blooioConfig.apiKey}`,
+        "Content-Type": "application/json",
+        ...idempotencyKey ? { "Idempotency-Key": idempotencyKey } : {},
+        ...fromNumber ? { "X-From-Number": fromNumber } : {}
+      },
+      body: JSON.stringify(cleanedPayload)
+    });
+    const responseText = await response.text();
+    if (!response.ok) {
+      throw new BlooioError(
+        `Blooio API error (${response.status})`,
+        response.status,
+        responseText
+      );
+    }
+    let data;
+    try {
+      data = JSON.parse(responseText);
+    } catch (error) {
+      throw new BlooioError(
+        "Invalid JSON response from Blooio",
+        response.status
+      );
+    }
+    const messageId = data.message_id || (data.message_ids ? data.message_ids[0] : void 0);
+    const message = {
+      messageId: messageId ?? createUniqueUuid(this.runtime, `${normalizedChatId}:${Date.now()}`),
+      chatId: normalizedChatId,
+      sender: fromNumber ?? "blooio",
+      text: typeof request.text === "string" ? request.text : void 0,
+      attachments: Array.isArray(request.attachments) ? request.attachments.map(
+        (item) => typeof item === "string" ? item : item.url
+      ) : void 0,
+      direction: "outbound",
+      status: data.status,
+      timestamp: Date.now()
+    };
+    this.cacheMessage(normalizedChatId, message);
+    if (this.runtime) {
+      this.runtime.emitEvent("blooio:message:sent", message);
+    }
+    return data;
+  }
+  async handleWebhookEvent(event) {
+    switch (event.event) {
+      case "message.received":
+        await this.handleIncomingMessage(event);
+        break;
+      case "message.sent":
+        this.handleMessageSent(event);
+        break;
+      case "message.delivered":
+        this.handleMessageDelivered(event);
+        break;
+      case "message.failed":
+        this.handleMessageFailed(event);
+        break;
+      case "message.read":
+        this.handleMessageRead(event);
+        break;
+      case "group.name_changed":
+      case "group.icon_changed":
+        if (this.runtime) {
+          this.runtime.emitEvent(`blooio:${event.event}`, event);
+        }
+        break;
+      default:
+        break;
+    }
+  }
+  handleMessageSent(event) {
+    if (this.runtime) {
+      this.runtime.emitEvent("blooio:message:sent", event);
+    }
+  }
+  handleMessageDelivered(event) {
+    if (this.runtime) {
+      this.runtime.emitEvent("blooio:message:delivered", event);
+    }
+  }
+  handleMessageFailed(event) {
+    if (this.runtime) {
+      this.runtime.emitEvent("blooio:message:failed", event);
+    }
+  }
+  handleMessageRead(event) {
+    if (this.runtime) {
+      this.runtime.emitEvent("blooio:message:read", event);
+    }
+  }
+  async handleIncomingMessage(webhook) {
+    const chatId = webhook.external_id ?? webhook.sender;
+    if (!chatId) {
+      logger3.warn("Blooio webhook missing chat identifier");
+      return;
+    }
+    const inboundMessage = {
+      messageId: webhook.message_id ?? createUniqueUuid(this.runtime, `${chatId}:${Date.now()}`),
+      chatId,
+      sender: webhook.sender,
+      text: webhook.text,
+      attachments: this.normalizeAttachmentUrls(webhook.attachments),
+      direction: "inbound",
+      protocol: webhook.protocol,
+      timestamp: webhook.received_at ?? webhook.timestamp,
+      internalId: webhook.internal_id
+    };
+    this.cacheMessage(chatId, inboundMessage);
+    if (this.runtime) {
+      this.runtime.emitEvent("blooio:message:received", inboundMessage);
+    }
+    await this.processIncomingMessage(webhook, inboundMessage);
+  }
+  async processIncomingMessage(webhook, message) {
+    try {
+      const text = message.text?.trim();
+      const hasAttachments = message.attachments && message.attachments.length > 0;
+      if (!text && !hasAttachments) {
+        return;
+      }
+      const channelType = webhook.is_group ? ChannelType.GROUP : ChannelType.DM;
+      const entityId = createUniqueUuid(this.runtime, webhook.sender);
+      const roomId = createUniqueUuid(this.runtime, `blooio:${message.chatId}`);
+      const worldId = createUniqueUuid(
+        this.runtime,
+        `blooio:${webhook.internal_id ?? "unknown"}`
+      );
+      await this.runtime.ensureConnection({
+        entityId,
+        roomId,
+        worldId,
+        userName: webhook.sender,
+        source: "blooio",
+        channelId: message.chatId,
+        type: channelType
+      });
+      const attachments = this.buildMediaFromBlooioAttachments(
+        webhook.attachments
+      );
+      const memory = createMessageMemory({
+        id: stringToUuid(message.messageId),
+        entityId,
+        roomId,
+        content: {
+          text: text ?? "",
+          source: "blooio",
+          channelType,
+          chatId: message.chatId,
+          phoneNumber: isE164(message.chatId) ? message.chatId : void 0,
+          protocol: message.protocol,
+          attachments: attachments.length > 0 ? attachments : void 0
+        }
+      });
+      const callback = async (content) => {
+        const responseText = typeof content.text === "string" ? content.text.trim() : "";
+        const outboundAttachments = [];
+        if (content.attachments && Array.isArray(content.attachments)) {
+          for (const attachment of content.attachments) {
+            if (typeof attachment === "object" && attachment !== null) {
+              const media = attachment;
+              if (media.url) {
+                outboundAttachments.push({
+                  url: media.url,
+                  name: media.title ?? media.description ?? void 0
+                });
+              }
+            }
+          }
+        }
+        const urlsFromText = extractAttachmentUrls(responseText);
+        for (const url of urlsFromText) {
+          outboundAttachments.push(url);
+        }
+        if (!responseText && outboundAttachments.length === 0) {
+          return [];
+        }
+        await this.sendMessage(message.chatId, {
+          text: responseText || void 0,
+          attachments: outboundAttachments.length > 0 ? outboundAttachments : void 0,
+          fromNumber: this.blooioConfig.fromNumber ?? webhook.internal_id
+        });
+        return [];
+      };
+      const messageService = getMessageService(this.runtime);
+      if (messageService) {
+        await messageService.handleMessage(this.runtime, memory, callback);
+      } else {
+        logger3.warn("messageService unavailable; falling back to event emit");
+        await this.runtime.emitEvent(EventType.MESSAGE_RECEIVED, {
+          message: memory,
+          callback,
+          source: "blooio"
+        });
+      }
+    } catch (error) {
+      logger3.error({ error: String(error) }, "Error processing Blooio message");
+    }
+  }
+  buildMediaAttachments(attachments) {
+    if (!attachments || attachments.length === 0) {
+      return [];
+    }
+    return attachments.map((url) => ({
+      id: createUniqueUuid(this.runtime, url),
+      url,
+      contentType: this.resolveContentType(url)
+    }));
+  }
+  /**
+   * Build Media attachments from Blooio webhook attachments (preserves names)
+   */
+  buildMediaFromBlooioAttachments(attachments) {
+    if (!attachments || attachments.length === 0) {
+      return [];
+    }
+    return attachments.map((item) => {
+      const url = typeof item === "string" ? item : item.url;
+      const name = typeof item === "object" ? item.name : void 0;
+      return {
+        id: createUniqueUuid(this.runtime, url),
+        url,
+        title: name,
+        contentType: this.resolveContentType(url)
+      };
+    });
+  }
+  normalizeAttachmentUrls(attachments) {
+    if (!attachments || attachments.length === 0) {
+      return void 0;
+    }
+    return attachments.map((item) => typeof item === "string" ? item : item.url).filter((url) => typeof url === "string" && url.length > 0);
+  }
+  resolveContentType(url) {
+    const lower = url.toLowerCase();
+    if (lower.match(/\.(png|jpe?g|gif|webp|bmp|svg|ico|heic|heif|tiff?)$/)) {
+      return ContentType.IMAGE;
+    }
+    if (lower.match(/\.(mp4|mov|webm|avi|mkv|m4v|3gp|flv|wmv)$/)) {
+      return ContentType.VIDEO;
+    }
+    if (lower.match(/\.(mp3|wav|m4a|ogg|aac|flac|wma|aiff?)$/)) {
+      return ContentType.AUDIO;
+    }
+    return ContentType.DOCUMENT;
+  }
+  /**
+   * Resolve ContentType from a MIME type string (e.g., from webhook payload)
+   */
+  resolveContentTypeFromMime(mimeType) {
+    const lower = mimeType.toLowerCase();
+    if (lower.startsWith("image/")) {
+      return ContentType.IMAGE;
+    }
+    if (lower.startsWith("video/")) {
+      return ContentType.VIDEO;
+    }
+    if (lower.startsWith("audio/")) {
+      return ContentType.AUDIO;
+    }
+    return ContentType.DOCUMENT;
+  }
+  cacheMessage(chatId, message) {
+    const key = CACHE_KEYS.CONVERSATION(chatId);
+    const history = this.cache.get(key) ?? [];
+    history.push(message);
+    const trimmed = history.length > 50 ? history.slice(-50) : history;
+    this.cache.set(key, trimmed, BLOOIO_CONSTANTS.CACHE_TTL.CONVERSATION);
+  }
+  async cleanup() {
+    if (this.server) {
+      this.server.close();
+    }
+    this.cache.flushAll();
+    this.isInitialized = false;
+    logger3.info("BlooioService cleaned up");
+  }
+  get serviceType() {
+    return BLOOIO_SERVICE_NAME;
+  }
+  get serviceName() {
+    return "blooio";
+  }
+  get isConnected() {
+    return this.isInitialized;
+  }
+  getConversationHistory(chatId, limit = 10) {
+    const cacheKey = CACHE_KEYS.CONVERSATION(chatId);
+    const messages = this.cache.get(cacheKey);
+    if (!messages) {
+      return [];
+    }
+    return messages.slice(-limit);
+  }
+  get defaultFromNumber() {
+    return this.blooioConfig.fromNumber;
+  }
+};
+
+// src/tests.ts
+import {
+  logger as logger4
+} from "@elizaos/core";
+var BlooioTestSuite = class {
+  name = "Blooio Plugin Test Suite";
+  description = "Tests for Blooio iMessage/SMS functionality";
+  tests = [
+    {
+      name: "Service Initialization Test",
+      fn: async (runtime) => {
+        const blooioService = runtime.getService(
+          BLOOIO_SERVICE_NAME
+        );
+        if (!blooioService) {
+          throw new Error("Blooio service not initialized");
+        }
+        if (!blooioService.isConnected) {
+          throw new Error("Blooio service is not connected");
+        }
+        logger4.info("\u2705 Blooio service initialized");
+      }
+    },
+    {
+      name: "Send Message Test",
+      fn: async (runtime) => {
+        const blooioService = runtime.getService(
+          BLOOIO_SERVICE_NAME
+        );
+        if (!blooioService) {
+          throw new Error("Blooio service not initialized");
+        }
+        const testChatId = runtime.getSetting("BLOOIO_TEST_CHAT_ID");
+        if (!testChatId) {
+          logger4.warn("BLOOIO_TEST_CHAT_ID not set, skipping send test");
+          return;
+        }
+        const result = await blooioService.sendMessage(testChatId, {
+          text: "Test message from Eliza Blooio plugin"
+        });
+        logger4.info(`\u2705 Message test queued. Status: ${result.status}`);
+      }
+    },
+    {
+      name: "Conversation History Test",
+      fn: async (runtime) => {
+        const blooioService = runtime.getService(
+          BLOOIO_SERVICE_NAME
+        );
+        if (!blooioService) {
+          throw new Error("Blooio service not initialized");
+        }
+        const testChatId = runtime.getSetting("BLOOIO_TEST_CHAT_ID");
+        if (!testChatId) {
+          logger4.warn("BLOOIO_TEST_CHAT_ID not set, skipping history test");
+          return;
+        }
+        await blooioService.sendMessage(testChatId, {
+          text: "History test message"
+        });
+        const history = blooioService.getConversationHistory(testChatId, 5);
+        if (history.length > 0) {
+          logger4.info(
+            `\u2705 Conversation history retrieved: ${history.length} messages`
+          );
+          logger4.info(
+            `   Latest message: ${history[history.length - 1].text ?? "(no text)"}`
+          );
+        } else {
+          logger4.info(
+            "\u2705 Conversation history is empty (expected for new chat)"
+          );
+        }
+      }
+    },
+    {
+      name: "Error Handling Test",
+      fn: async (runtime) => {
+        const blooioService = runtime.getService(
+          BLOOIO_SERVICE_NAME
+        );
+        if (!blooioService) {
+          throw new Error("Blooio service not initialized");
+        }
+        try {
+          await blooioService.sendMessage("invalid-chat-id", { text: "Test" });
+          throw new Error("Expected error for invalid chat id");
+        } catch (error) {
+          logger4.info("\u2705 Invalid chat id error handled correctly");
+        }
+      }
+    }
+  ];
+};
+
+// src/index.ts
+var blooioPlugin = {
+  name: "blooio",
+  description: "Blooio plugin for iMessage/SMS messaging integration",
+  services: [BlooioService],
+  actions: [sendMessage_default],
+  providers: [conversationHistory_default],
+  tests: [new BlooioTestSuite()],
+  init: async (_config, runtime) => {
+    const apiKey = runtime.getSetting("BLOOIO_API_KEY");
+    const webhookUrl = runtime.getSetting("BLOOIO_WEBHOOK_URL");
+    const webhookSecret = runtime.getSetting("BLOOIO_WEBHOOK_SECRET");
+    if (!apiKey || apiKey.trim() === "") {
+      logger5.warn(
+        "Blooio API key not provided - Blooio plugin is loaded but will not be functional"
+      );
+      logger5.warn(
+        "To enable Blooio functionality, please provide BLOOIO_API_KEY in your .env file"
+      );
+      return;
+    }
+    if (!webhookUrl || webhookUrl.trim() === "") {
+      logger5.warn(
+        "Blooio webhook URL not provided - Blooio will not receive incoming messages"
+      );
+      logger5.warn(
+        "To enable incoming communication, please provide BLOOIO_WEBHOOK_URL in your .env file"
+      );
+      return;
+    }
+    if (!webhookSecret || webhookSecret.trim() === "") {
+      logger5.warn(
+        "Blooio webhook secret not provided - signature verification is disabled"
+      );
+    }
+    logger5.info("Blooio plugin initialized successfully");
+  }
+};
+var index_default = blooioPlugin;
+export {
+  index_default as default
+};
+//# sourceMappingURL=index.js.map