@elizaos/plugin-twilio 2.0.0-alpha.1

package/dist/index.js

@@ -0,0 +1,1650 @@
+// src/index.ts
+import { logger as logger7 } from "@elizaos/core";
+
+// src/actions/sendSms.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 TWILIO_SERVICE_NAME = "twilio";
+var TWILIO_CONSTANTS = {
+  // Message limits
+  SMS_MAX_LENGTH: 1600,
+  MMS_MAX_MEDIA_SIZE: 5242880,
+  // 5MB
+  MMS_MAX_MEDIA_COUNT: 10,
+  // Voice constants
+  DEFAULT_VOICE: "alice",
+  DEFAULT_LANGUAGE: "en-US",
+  VOICE_STREAM_TIMEOUT: 3e5,
+  // 5 minutes
+  // API endpoints
+  API_BASE_URL: "https://api.twilio.com",
+  // Webhook paths
+  WEBHOOK_PATHS: {
+    SMS: "/webhooks/twilio/sms",
+    VOICE: "/webhooks/twilio/voice",
+    STATUS: "/webhooks/twilio/status",
+    VOICE_STREAM: "/webhooks/twilio/voice-stream"
+  },
+  // TwiML templates
+  TWIML: {
+    DEFAULT_VOICE_RESPONSE: `<?xml version="1.0" encoding="UTF-8"?>
+<Response>
+    <Say voice="alice">Hello from Eliza AI assistant. How can I help you today?</Say>
+    <Pause length="1"/>
+</Response>`,
+    STREAM_RESPONSE: (streamUrl) => `<?xml version="1.0" encoding="UTF-8"?>
+<Response>
+    <Start>
+        <Stream url="${streamUrl}" />
+    </Start>
+    <Say>Please wait while I connect you to the AI assistant.</Say>
+    <Pause length="60"/>
+</Response>`
+  },
+  // Rate limits
+  RATE_LIMITS: {
+    SMS_PER_SECOND: 1,
+    CALLS_PER_SECOND: 1,
+    WEBHOOK_TIMEOUT: 15e3
+    // 15 seconds
+  },
+  // Cache TTL
+  CACHE_TTL: {
+    CONVERSATION: 3600,
+    // 1 hour
+    MEDIA: 86400,
+    // 24 hours
+    CALL_STATE: 1800
+    // 30 minutes
+  }
+};
+var ERROR_MESSAGES = {
+  INVALID_PHONE_NUMBER: "Invalid phone number format. Please use E.164 format (e.g., +18885551212)",
+  MISSING_CREDENTIALS: "Twilio credentials not configured",
+  WEBHOOK_VALIDATION_FAILED: "Failed to validate Twilio webhook signature",
+  RATE_LIMIT_EXCEEDED: "Rate limit exceeded. Please try again later.",
+  MEDIA_TOO_LARGE: "Media file too large. Maximum size is 5MB",
+  UNSUPPORTED_MEDIA_TYPE: "Unsupported media type"
+};
+
+// src/utils.ts
+import { logger } from "@elizaos/core";
+function validatePhoneNumber(phoneNumber) {
+  const e164Regex = /^\+[1-9]\d{1,14}$/;
+  return e164Regex.test(phoneNumber);
+}
+function validateMessagingAddress(address) {
+  const messagingRegex = /^(whatsapp:)?\+[1-9]\d{1,14}$/;
+  return messagingRegex.test(address);
+}
+function isWhatsAppAddress(address) {
+  return address.startsWith("whatsapp:");
+}
+function stripWhatsAppPrefix(address) {
+  return isWhatsAppAddress(address) ? address.slice("whatsapp:".length) : address;
+}
+function formatMessagingAddress(address, defaultCountryCode = "+1") {
+  const hasPrefix = isWhatsAppAddress(address);
+  const formatted = formatPhoneNumber(
+    stripWhatsAppPrefix(address),
+    defaultCountryCode
+  );
+  if (!formatted) {
+    return null;
+  }
+  return hasPrefix ? `whatsapp:${formatted}` : formatted;
+}
+function formatPhoneNumber(phoneNumber, defaultCountryCode = "+1") {
+  let cleaned = phoneNumber.replace(/[^\d+]/g, "");
+  if (!cleaned.startsWith("+")) {
+    if (cleaned.startsWith("1") && cleaned.length === 11) {
+      cleaned = "+" + cleaned;
+    } else if (cleaned.length === 10) {
+      cleaned = defaultCountryCode + cleaned;
+    } else {
+      return null;
+    }
+  }
+  if (validatePhoneNumber(cleaned)) {
+    return cleaned;
+  }
+  return null;
+}
+var generateTwiML = {
+  /**
+   * Generates TwiML for a simple voice response
+   * @param message The message to say
+   * @param voice The voice to use (default: alice)
+   * @returns TwiML string
+   */
+  say: (message, voice = "alice") => {
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<Response>
+    <Say voice="${voice}">${escapeXml(message)}</Say>
+</Response>`;
+  },
+  /**
+   * Generates TwiML for gathering input
+   * @param prompt The prompt message
+   * @param options Gather options
+   * @returns TwiML string
+   */
+  gather: (prompt, options = {}) => {
+    const {
+      numDigits = 1,
+      timeout = 5,
+      action = "",
+      method = "POST"
+    } = options;
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<Response>
+    <Gather numDigits="${numDigits}" timeout="${timeout}" action="${action}" method="${method}">
+        <Say>${escapeXml(prompt)}</Say>
+    </Gather>
+</Response>`;
+  },
+  /**
+   * Generates TwiML for starting a media stream
+   * @param streamUrl The WebSocket URL for streaming
+   * @param customParameters Optional custom parameters
+   * @returns TwiML string
+   */
+  stream: (streamUrl, customParameters) => {
+    let params = "";
+    if (customParameters) {
+      params = Object.entries(customParameters).map(
+        ([key, value]) => `<Parameter name="${key}" value="${escapeXml(value)}" />`
+      ).join("\n        ");
+    }
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<Response>
+    <Start>
+        <Stream url="${streamUrl}">
+            ${params}
+        </Stream>
+    </Start>
+    <Say>Please wait while I connect you to the AI assistant.</Say>
+    <Pause length="60"/>
+</Response>`;
+  },
+  /**
+   * Generates TwiML for recording a call
+   * @param options Recording options
+   * @returns TwiML string
+   */
+  record: (options = {}) => {
+    const {
+      maxLength = 3600,
+      timeout = 5,
+      transcribe = false,
+      action = ""
+    } = options;
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<Response>
+    <Record maxLength="${maxLength}" timeout="${timeout}" transcribe="${transcribe}" action="${action}" />
+</Response>`;
+  },
+  /**
+   * Generates TwiML to hang up
+   * @returns TwiML string
+   */
+  hangup: () => {
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<Response>
+    <Hangup />
+</Response>`;
+  }
+};
+function escapeXml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function extractPhoneNumber(input) {
+  const wantsWhatsApp = input.toLowerCase().includes("whatsapp:");
+  const patterns = [
+    /\+\d{1,15}/,
+    // E.164 format
+    /\(\d{3}\)\s*\d{3}-\d{4}/,
+    // (555) 555-5555
+    /\d{3}-\d{3}-\d{4}/,
+    // 555-555-5555
+    /\d{10,15}/
+    // Just digits
+  ];
+  for (const pattern of patterns) {
+    const match = input.match(pattern);
+    if (match) {
+      const formatted = formatPhoneNumber(match[0]);
+      if (formatted) {
+        return wantsWhatsApp ? `whatsapp:${formatted}` : formatted;
+      }
+    }
+  }
+  return null;
+}
+function chunkTextForSms(text, maxLength = 160) {
+  if (text.length <= maxLength) {
+    return [text];
+  }
+  const chunks = [];
+  const words = text.split(" ");
+  let currentChunk = "";
+  for (const word of words) {
+    if ((currentChunk + " " + word).trim().length <= maxLength) {
+      currentChunk = (currentChunk + " " + word).trim();
+    } else {
+      if (currentChunk) {
+        chunks.push(currentChunk);
+      }
+      currentChunk = word;
+    }
+  }
+  if (currentChunk) {
+    chunks.push(currentChunk);
+  }
+  return chunks;
+}
+
+// src/actions/sendSms.ts
+var sendSmsAction = {
+  name: "SEND_SMS",
+  description: "Send an SMS message to a phone number via Twilio",
+  validate: async (runtime, message, state) => {
+    const twilioService = runtime.getService(TWILIO_SERVICE_NAME);
+    if (!twilioService) {
+      logger2.error("Twilio service not found");
+      return false;
+    }
+    const text = message.content.text || "";
+    const phoneNumber = extractPhoneNumber(text);
+    const hasSmsIntent = text.toLowerCase().includes("sms") || text.toLowerCase().includes("text") || text.toLowerCase().includes("message");
+    return !!phoneNumber && hasSmsIntent;
+  },
+  handler: async (runtime, message, state, options, callback) => {
+    try {
+      const twilioService = runtime.getService(
+        TWILIO_SERVICE_NAME
+      );
+      if (!twilioService) {
+        throw new Error("Twilio service not available");
+      }
+      const text = message.content.text || "";
+      const phoneNumber = extractPhoneNumber(text);
+      if (!phoneNumber) {
+        throw new Error("No phone number found in message");
+      }
+      let messageContent = text.replace(phoneNumber, "").replace(
+        /^(send\s*(an?\s*)?(sms|text|message)\s*(to\s*)?|text\s+)/gi,
+        ""
+      ).replace(/\b(saying|with\s*(the\s*)?(message|text))\b/gi, "").trim();
+      messageContent = messageContent.replace(/^["']|["']$/g, "").trim();
+      if (!messageContent) {
+        messageContent = "Hello from your AI assistant!";
+      }
+      if (!validateMessagingAddress(phoneNumber)) {
+        throw new Error("Invalid phone number format");
+      }
+      const messageChunks = chunkTextForSms(messageContent);
+      for (const chunk of messageChunks) {
+        await twilioService.sendSms(phoneNumber, chunk);
+        logger2.info(`SMS sent to ${phoneNumber}: ${chunk.substring(0, 50)}...`);
+      }
+      if (callback) {
+        callback({
+          text: `SMS message sent successfully to ${phoneNumber}`,
+          success: true
+        });
+      }
+    } catch (error) {
+      logger2.error({ error: String(error) }, "Error sending SMS");
+      if (callback) {
+        callback({
+          text: `Failed to send SMS: ${error instanceof Error ? error.message : "Unknown error"}`,
+          success: false
+        });
+      }
+    }
+  },
+  examples: [
+    [
+      {
+        name: "user",
+        content: {
+          text: "Send an SMS to +18885551234 saying 'Hello from AI assistant!'"
+        }
+      },
+      {
+        name: "assistant",
+        content: {
+          text: "I'll send that SMS message for you.",
+          action: "SEND_SMS"
+        }
+      }
+    ],
+    [
+      {
+        name: "user",
+        content: {
+          text: "Text +15555551234 with the message 'Meeting confirmed for 3pm tomorrow'"
+        }
+      },
+      {
+        name: "assistant",
+        content: {
+          text: "Sending the meeting confirmation SMS now.",
+          action: "SEND_SMS"
+        }
+      }
+    ]
+  ],
+  similes: [
+    "send sms",
+    "send text",
+    "text message",
+    "sms to",
+    "text to",
+    "message phone"
+  ]
+};
+var sendSms_default = sendSmsAction;
+
+// src/actions/makeCall.ts
+import {
+  logger as logger3
+} from "@elizaos/core";
+var makeCallAction = {
+  name: "MAKE_CALL",
+  description: "Make a phone call via Twilio with a message or custom TwiML",
+  validate: async (runtime, message, state) => {
+    const twilioService = runtime.getService(TWILIO_SERVICE_NAME);
+    if (!twilioService) {
+      logger3.error("Twilio service not found");
+      return false;
+    }
+    const text = message.content.text || "";
+    const phoneNumber = extractPhoneNumber(text);
+    const callIntent = text.toLowerCase().includes("call") || text.toLowerCase().includes("phone") || text.toLowerCase().includes("dial");
+    return !!phoneNumber && callIntent;
+  },
+  handler: async (runtime, message, state, options, callback) => {
+    try {
+      const twilioService = runtime.getService(
+        TWILIO_SERVICE_NAME
+      );
+      if (!twilioService) {
+        throw new Error("Twilio service not available");
+      }
+      const text = message.content.text || "";
+      const phoneNumber = extractPhoneNumber(text);
+      if (!phoneNumber) {
+        throw new Error("No phone number found in message");
+      }
+      let callMessage = text.replace(phoneNumber, "").replace(/call|phone|dial/gi, "").replace(/and\s*say/gi, "").replace(/with\s*(the\s*)?(message|saying)/gi, "").trim();
+      callMessage = callMessage.replace(/^["']|["']$/g, "").trim();
+      if (!callMessage) {
+        callMessage = "Hello, this is an automated call from your AI assistant.";
+      }
+      if (!validatePhoneNumber(phoneNumber)) {
+        throw new Error("Invalid phone number format");
+      }
+      const twiml = generateTwiML.say(callMessage);
+      const call = await twilioService.makeCall(phoneNumber, twiml);
+      logger3.info(`Call initiated to ${phoneNumber}, Call SID: ${call.sid}`);
+      if (callback) {
+        callback({
+          text: `Call initiated successfully to ${phoneNumber}. Call ID: ${call.sid}`,
+          success: true
+        });
+      }
+    } catch (error) {
+      logger3.error({ error: String(error) }, "Error making call");
+      if (callback) {
+        callback({
+          text: `Failed to make call: ${error instanceof Error ? error.message : "Unknown error"}`,
+          success: false
+        });
+      }
+    }
+  },
+  examples: [
+    [
+      {
+        name: "user",
+        content: {
+          text: "Call +18885551234 and say 'This is an important reminder about your appointment tomorrow at 3pm'"
+        }
+      },
+      {
+        name: "assistant",
+        content: {
+          text: "I'll place that call with your reminder message.",
+          action: "MAKE_CALL"
+        }
+      }
+    ],
+    [
+      {
+        name: "user",
+        content: {
+          text: "Phone +15555551234 with an automated message about the meeting cancellation"
+        }
+      },
+      {
+        name: "assistant",
+        content: {
+          text: "Initiating the call with the cancellation message.",
+          action: "MAKE_CALL"
+        }
+      }
+    ]
+  ],
+  similes: [
+    "make call",
+    "phone call",
+    "call phone",
+    "dial number",
+    "voice call",
+    "ring phone"
+  ]
+};
+var makeCall_default = makeCallAction;
+
+// src/actions/sendMms.ts
+import {
+  logger as logger4
+} from "@elizaos/core";
+var sendMmsAction = {
+  name: "SEND_MMS",
+  description: "Send an MMS (multimedia message) with images, audio, or video via Twilio",
+  validate: async (runtime, message, state) => {
+    const twilioService = runtime.getService(TWILIO_SERVICE_NAME);
+    if (!twilioService) {
+      logger4.error("Twilio service not found");
+      return false;
+    }
+    const text = message.content.text || "";
+    const phoneNumber = extractPhoneNumber(text);
+    const mediaIntent = text.toLowerCase().includes("image") || text.toLowerCase().includes("photo") || text.toLowerCase().includes("picture") || text.toLowerCase().includes("video") || text.toLowerCase().includes("media") || text.toLowerCase().includes("mms");
+    const urlPattern = /https?:\/\/[^\s]+/g;
+    const hasUrls = urlPattern.test(text);
+    return !!phoneNumber && (mediaIntent || hasUrls);
+  },
+  handler: async (runtime, message, state, options, callback) => {
+    try {
+      const twilioService = runtime.getService(
+        TWILIO_SERVICE_NAME
+      );
+      if (!twilioService) {
+        throw new Error("Twilio service not available");
+      }
+      const text = message.content.text || "";
+      const phoneNumber = extractPhoneNumber(text);
+      if (!phoneNumber) {
+        throw new Error("No phone number found in message");
+      }
+      const urlPattern = /https?:\/\/[^\s]+/g;
+      const mediaUrls = text.match(urlPattern) || [];
+      if (mediaUrls.length === 0) {
+        mediaUrls.push("https://demo.twilio.com/owl.png");
+      }
+      let messageContent = text.replace(phoneNumber, "").replace(
+        /send\s*(an?\s*)?(mms|picture|photo|image|video|media)\s*(to\s*)?/gi,
+        ""
+      ).replace(/with\s*(the\s*)?(image|photo|picture|video|media|mms)/gi, "").replace(/at|from/gi, "").replace(urlPattern, "").replace(/saying|with\s*(the\s*)?(message|text)/gi, "").trim();
+      messageContent = messageContent.replace(/^["']|["']$/g, "").trim();
+      if (!messageContent) {
+        messageContent = "Here's the media you requested";
+      }
+      if (!validateMessagingAddress(phoneNumber)) {
+        throw new Error("Invalid phone number format");
+      }
+      const sentMessage = await twilioService.sendSms(
+        phoneNumber,
+        messageContent,
+        mediaUrls
+      );
+      logger4.info(
+        `MMS sent to ${phoneNumber} with ${mediaUrls.length} media attachment(s)`
+      );
+      if (callback) {
+        callback({
+          text: `MMS sent successfully to ${phoneNumber} with ${mediaUrls.length} media attachment(s)`,
+          success: true
+        });
+      }
+    } catch (error) {
+      logger4.error({ error: String(error) }, "Error sending MMS");
+      if (callback) {
+        callback({
+          text: `Failed to send MMS: ${error instanceof Error ? error.message : "Unknown error"}`,
+          success: false
+        });
+      }
+    }
+  },
+  examples: [
+    [
+      {
+        name: "user",
+        content: {
+          text: "Send a picture to +18885551234 with the image from https://example.com/photo.jpg saying 'Check out this photo!'"
+        }
+      },
+      {
+        name: "assistant",
+        content: {
+          text: "I'll send that photo with your message.",
+          action: "SEND_MMS"
+        }
+      }
+    ],
+    [
+      {
+        name: "user",
+        content: {
+          text: "Send an MMS to +15555551234 with the video at https://example.com/video.mp4"
+        }
+      },
+      {
+        name: "assistant",
+        content: {
+          text: "Sending the video message now.",
+          action: "SEND_MMS"
+        }
+      }
+    ]
+  ],
+  similes: [
+    "send mms",
+    "send picture",
+    "send photo",
+    "send image",
+    "send video",
+    "send media",
+    "picture message",
+    "photo message"
+  ]
+};
+var sendMms_default = sendMmsAction;
+
+// src/providers/conversationHistory.ts
+var conversationHistoryProvider = {
+  name: "twilioConversationHistory",
+  description: "Provides recent SMS/MMS conversation history with a phone number",
+  get: async (runtime, message, state) => {
+    try {
+      const twilioService = runtime.getService(
+        TWILIO_SERVICE_NAME
+      );
+      if (!twilioService) {
+        return {
+          text: "No Twilio conversation history available - service not initialized"
+        };
+      }
+      if (typeof message.content === "string") {
+        return {
+          text: "No phone number found in context"
+        };
+      }
+      const phoneNumber = message.content.phoneNumber || message.content.text?.match(/\+?\d{10,15}/)?.[0];
+      if (!phoneNumber || typeof phoneNumber !== "string") {
+        return {
+          text: "No phone number found in context"
+        };
+      }
+      const conversationHistory = twilioService.getConversationHistory(
+        phoneNumber,
+        10
+      );
+      if (!conversationHistory || conversationHistory.length === 0) {
+        return {
+          text: `No recent conversation history with ${phoneNumber}`
+        };
+      }
+      const history = conversationHistory.map((msg) => {
+        const direction = msg.direction === "inbound" ? "From" : "To";
+        const time = new Date(msg.dateCreated).toLocaleString();
+        return `[${time}] ${direction} ${phoneNumber}: ${msg.body}`;
+      }).join("\n");
+      return {
+        text: `Recent SMS conversation with ${phoneNumber}:
+${history}`,
+        data: {
+          phoneNumber,
+          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/providers/callState.ts
+var callStateProvider = {
+  name: "twilioCallState",
+  description: "Provides information about active voice calls and streams",
+  get: async (runtime, message, state) => {
+    try {
+      const twilioService = runtime.getService(
+        TWILIO_SERVICE_NAME
+      );
+      if (!twilioService) {
+        return {
+          text: "No Twilio call state available - service not initialized"
+        };
+      }
+      const activeStreams = twilioService.voiceStreams;
+      if (!activeStreams || activeStreams.size === 0) {
+        return {
+          text: "No active voice calls",
+          data: {
+            activeCallCount: 0
+          }
+        };
+      }
+      const callInfo = [];
+      const callData = [];
+      activeStreams.forEach((stream, callSid) => {
+        callInfo.push(`Call ${callSid}: ${stream.from} \u2192 ${stream.to}`);
+        callData.push({
+          callSid,
+          streamSid: stream.streamSid,
+          from: stream.from,
+          to: stream.to
+        });
+      });
+      return {
+        text: `Active voice calls (${activeStreams.size}):
+${callInfo.join("\n")}`,
+        data: {
+          activeCallCount: activeStreams.size,
+          calls: callData
+        }
+      };
+    } catch (error) {
+      console.error("Error in callStateProvider:", error);
+      return {
+        text: "Error retrieving call state"
+      };
+    }
+  }
+};
+var callState_default = callStateProvider;
+
+// src/service.ts
+import {
+  ChannelType,
+  ContentType,
+  EventType,
+  Service,
+  createMessageMemory,
+  createUniqueUuid,
+  logger as logger5,
+  stringToUuid
+} from "@elizaos/core";
+import bodyParser from "body-parser";
+import express from "express";
+import NodeCache from "node-cache";
+import twilio from "twilio";
+import { WebSocketServer } from "ws";
+
+// src/types.ts
+import { z } from "zod";
+var E164_REGEX = /^\+\d{1,15}$/;
+var MESSAGING_REGEX = /^(whatsapp:)?\+\d{1,15}$/;
+var TwilioMessageSchema = z.object({
+  to: z.string().regex(MESSAGING_REGEX),
+  body: z.string().min(1).max(1600),
+  mediaUrl: z.array(z.string().url()).optional()
+});
+var TwilioCallSchema = z.object({
+  to: z.string().regex(E164_REGEX),
+  twiml: z.string().optional(),
+  url: z.string().url().optional()
+});
+var SendSmsSchema = z.object({
+  to: z.string().regex(MESSAGING_REGEX),
+  message: z.string().min(1).max(1600),
+  mediaUrl: z.array(z.string().url()).optional()
+});
+var MakeCallSchema = z.object({
+  to: z.string().regex(E164_REGEX),
+  message: z.string().optional(),
+  url: z.string().url().optional()
+});
+var SendMmsSchema = z.object({
+  to: z.string().regex(MESSAGING_REGEX),
+  message: z.string().min(1).max(1600),
+  mediaUrl: z.array(z.string().url()).min(1)
+});
+var CACHE_KEYS = {
+  CONVERSATION: (phoneNumber) => `twilio:conversation:${phoneNumber}`,
+  CALL_STATE: (callSid) => `twilio:call:${callSid}`,
+  MEDIA: (mediaSid) => `twilio:media:${mediaSid}`
+};
+var TwilioError = class extends Error {
+  constructor(message, code, twilioCode) {
+    super(message);
+    this.code = code;
+    this.twilioCode = twilioCode;
+    this.name = "TwilioError";
+  }
+};
+
+// src/service.ts
+var getMessageService = (runtime) => {
+  if ("messageService" in runtime) {
+    const withMessageService = runtime;
+    return withMessageService.messageService ?? null;
+  }
+  return null;
+};
+var TwilioService = class _TwilioService extends Service {
+  static serviceType = TWILIO_SERVICE_NAME;
+  // Required static methods for Service type
+  static async start(runtime) {
+    const service = new _TwilioService();
+    await service.initialize(runtime);
+    return service;
+  }
+  static async stop(_runtime) {
+    return;
+  }
+  twilioConfig;
+  client;
+  // Twilio client
+  app;
+  server;
+  wss;
+  cache;
+  voiceStreams;
+  isInitialized = false;
+  constructor() {
+    super();
+    this.voiceStreams = /* @__PURE__ */ new Map();
+    this.cache = new NodeCache({ stdTTL: 600 });
+  }
+  async initialize(runtime) {
+    if (this.isInitialized) {
+      logger5.warn("TwilioService already initialized");
+      return;
+    }
+    this.runtime = runtime;
+    const configuredPhoneNumber = runtime.getSetting(
+      "TWILIO_PHONE_NUMBER"
+    );
+    const normalizedPhoneNumber = stripWhatsAppPrefix(
+      configuredPhoneNumber || ""
+    );
+    this.twilioConfig = {
+      accountSid: runtime.getSetting("TWILIO_ACCOUNT_SID"),
+      authToken: runtime.getSetting("TWILIO_AUTH_TOKEN"),
+      phoneNumber: normalizedPhoneNumber,
+      webhookUrl: runtime.getSetting("TWILIO_WEBHOOK_URL"),
+      webhookPort: parseInt(
+        runtime.getSetting("TWILIO_WEBHOOK_PORT") || "3000"
+      )
+    };
+    if (!this.twilioConfig.accountSid || !this.twilioConfig.authToken || !this.twilioConfig.phoneNumber) {
+      throw new TwilioError(ERROR_MESSAGES.MISSING_CREDENTIALS);
+    }
+    this.client = twilio(
+      this.twilioConfig.accountSid,
+      this.twilioConfig.authToken
+    );
+    await this.setupWebhookServer();
+    await this.updatePhoneNumberWebhooks();
+    this.isInitialized = true;
+    logger5.info("TwilioService initialized successfully");
+  }
+  // Implement stop method required by Service interface
+  async stop() {
+    await this.cleanup();
+  }
+  // Add capability description getter
+  get capabilityDescription() {
+    return "Twilio voice and SMS integration service for bidirectional communication";
+  }
+  async setupWebhookServer() {
+    this.app = express();
+    this.app.use(bodyParser.urlencoded({ extended: false }));
+    this.app.use(bodyParser.json());
+    this.app.post(TWILIO_CONSTANTS.WEBHOOK_PATHS.SMS, async (req, res) => {
+      try {
+        const webhook = req.body;
+        await this.handleIncomingSms(webhook);
+        res.type("text/xml").send("<Response></Response>");
+      } catch (error) {
+        logger5.error({ error: String(error) }, "Error handling SMS webhook");
+        res.status(500).send("<Response></Response>");
+      }
+    });
+    this.app.post(TWILIO_CONSTANTS.WEBHOOK_PATHS.VOICE, async (req, res) => {
+      try {
+        const webhook = req.body;
+        const twiml = await this.handleIncomingCall(webhook);
+        res.type("text/xml").send(twiml);
+      } catch (error) {
+        logger5.error({ error: String(error) }, "Error handling voice webhook");
+        res.type("text/xml").send(TWILIO_CONSTANTS.TWIML.DEFAULT_VOICE_RESPONSE);
+      }
+    });
+    this.app.post(TWILIO_CONSTANTS.WEBHOOK_PATHS.STATUS, (req, res) => {
+      const webhook = req.body;
+      const {
+        MessageSid,
+        MessageStatus,
+        SmsStatus,
+        CallSid,
+        CallStatus,
+        ErrorCode,
+        ErrorMessage,
+        To,
+        From,
+        MessagingServiceSid,
+        AccountSid,
+        ApiVersion
+      } = webhook;
+      logger5.info(
+        {
+          MessageSid,
+          MessageStatus,
+          SmsStatus,
+          CallSid,
+          CallStatus,
+          ErrorCode,
+          ErrorMessage,
+          To,
+          From,
+          MessagingServiceSid,
+          AccountSid,
+          ApiVersion
+        },
+        "Status callback received"
+      );
+      res.sendStatus(200);
+    });
+    this.server = this.app.listen(this.twilioConfig.webhookPort, () => {
+      logger5.info(
+        `Twilio webhook server listening on port ${this.twilioConfig.webhookPort}`
+      );
+    });
+    this.wss = new WebSocketServer({ server: this.server });
+    this.setupVoiceStreamingWebSocket();
+  }
+  setupVoiceStreamingWebSocket() {
+    this.wss.on("connection", (ws, req) => {
+      const url = new URL(req.url, `http://${req.headers.host}`);
+      const callSid = url.searchParams.get("callSid");
+      if (!callSid) {
+        logger5.error("No callSid provided for voice stream");
+        ws.close();
+        return;
+      }
+      logger5.info(`Voice stream connected for call ${callSid}`);
+      ws.on("message", async (data) => {
+        try {
+          const message = JSON.parse(data.toString());
+          switch (message.event) {
+            case "start":
+              this.handleStreamStart(callSid, message, ws);
+              break;
+            case "media":
+              this.handleStreamMedia(callSid, message);
+              break;
+            case "stop":
+              this.handleStreamStop(callSid);
+              break;
+          }
+        } catch (error) {
+          logger5.error(
+            { error: String(error) },
+            "Error processing voice stream message"
+          );
+        }
+      });
+      ws.on("close", () => {
+        logger5.info(`Voice stream closed for call ${callSid}`);
+        this.voiceStreams.delete(callSid);
+        if (this.runtime) {
+          this.runtime.emitEvent("voice:stream:ended" /* VOICE_STREAM_ENDED */, {
+            callSid
+          });
+        }
+      });
+    });
+  }
+  handleStreamStart(callSid, message, ws) {
+    const stream = {
+      streamSid: message.streamSid,
+      callSid,
+      from: message.start.customParameters.from,
+      to: message.start.customParameters.to,
+      socket: ws
+    };
+    this.voiceStreams.set(callSid, stream);
+    if (this.runtime) {
+      this.runtime.emitEvent("voice:stream:started" /* VOICE_STREAM_STARTED */, { stream });
+    }
+  }
+  handleStreamMedia(callSid, message) {
+    const stream = this.voiceStreams.get(callSid);
+    if (!stream) return;
+    const audioBuffer = Buffer.from(message.media.payload, "base64");
+    if (this.runtime) {
+      this.runtime.emitEvent("audio:received", {
+        callSid,
+        audio: audioBuffer,
+        timestamp: message.media.timestamp
+      });
+    }
+  }
+  handleStreamStop(callSid) {
+    this.voiceStreams.delete(callSid);
+    if (this.runtime) {
+      this.runtime.emitEvent("voice:stream:ended" /* VOICE_STREAM_ENDED */, { callSid });
+    }
+  }
+  async updatePhoneNumberWebhooks() {
+    try {
+      const phoneNumbers = await this.client.incomingPhoneNumbers.list({
+        phoneNumber: this.twilioConfig.phoneNumber
+      });
+      if (phoneNumbers.length === 0) {
+        throw new TwilioError(
+          `Phone number ${this.twilioConfig.phoneNumber} not found`
+        );
+      }
+      const phoneNumber = phoneNumbers[0];
+      await this.client.incomingPhoneNumbers(phoneNumber.sid).update({
+        smsUrl: `${this.twilioConfig.webhookUrl}${TWILIO_CONSTANTS.WEBHOOK_PATHS.SMS}`,
+        smsMethod: "POST",
+        voiceUrl: `${this.twilioConfig.webhookUrl}${TWILIO_CONSTANTS.WEBHOOK_PATHS.VOICE}`,
+        voiceMethod: "POST",
+        statusCallback: `${this.twilioConfig.webhookUrl}${TWILIO_CONSTANTS.WEBHOOK_PATHS.STATUS}`,
+        statusCallbackMethod: "POST"
+      });
+      logger5.info(
+        `Updated webhooks for phone number ${this.twilioConfig.phoneNumber}`
+      );
+    } catch (error) {
+      logger5.error(
+        { error: String(error) },
+        "Error updating phone number webhooks"
+      );
+      throw error;
+    }
+  }
+  async sendSms(to, body, mediaUrl, fromOverride) {
+    const normalizedTo = formatMessagingAddress(to);
+    if (!normalizedTo || !validateMessagingAddress(normalizedTo)) {
+      throw new TwilioError(ERROR_MESSAGES.INVALID_PHONE_NUMBER);
+    }
+    const normalizedFrom = formatMessagingAddress(
+      fromOverride || this.twilioConfig.phoneNumber
+    );
+    if (!normalizedFrom) {
+      throw new TwilioError(ERROR_MESSAGES.INVALID_PHONE_NUMBER);
+    }
+    const fromNumber = isWhatsAppAddress(normalizedTo) ? `whatsapp:${stripWhatsAppPrefix(normalizedFrom)}` : stripWhatsAppPrefix(normalizedFrom);
+    try {
+      const message = await this.client.messages.create({
+        from: fromNumber,
+        to: normalizedTo,
+        body,
+        mediaUrl,
+        statusCallback: `${this.twilioConfig.webhookUrl}${TWILIO_CONSTANTS.WEBHOOK_PATHS.STATUS}`
+      });
+      const twilioMessage = {
+        sid: message.sid,
+        from: message.from,
+        to: message.to,
+        body: message.body,
+        direction: "outbound",
+        status: message.status,
+        dateCreated: message.dateCreated,
+        dateSent: message.dateSent || void 0
+      };
+      const conversationKey = CACHE_KEYS.CONVERSATION(normalizedTo);
+      let conversationHistory = this.cache.get(conversationKey) || [];
+      conversationHistory.push(twilioMessage);
+      if (conversationHistory.length > 50) {
+        conversationHistory = conversationHistory.slice(-50);
+      }
+      this.cache.set(
+        conversationKey,
+        conversationHistory,
+        TWILIO_CONSTANTS.CACHE_TTL.CONVERSATION
+      );
+      if (this.runtime) {
+        this.runtime.emitEvent("sms:sent" /* SMS_SENT */, twilioMessage);
+      }
+      return twilioMessage;
+    } catch (error) {
+      throw new TwilioError(
+        `Failed to send SMS: ${error.message}`,
+        error.code,
+        error.moreInfo
+      );
+    }
+  }
+  async makeCall(to, twiml, url) {
+    if (!validatePhoneNumber(to)) {
+      throw new TwilioError(ERROR_MESSAGES.INVALID_PHONE_NUMBER);
+    }
+    try {
+      const callParams = {
+        from: this.twilioConfig.phoneNumber,
+        to,
+        statusCallback: `${this.twilioConfig.webhookUrl}${TWILIO_CONSTANTS.WEBHOOK_PATHS.STATUS}`,
+        statusCallbackEvent: ["initiated", "ringing", "answered", "completed"]
+      };
+      if (twiml) {
+        callParams.twiml = twiml;
+      } else if (url) {
+        callParams.url = url;
+      } else {
+        callParams.twiml = TWILIO_CONSTANTS.TWIML.DEFAULT_VOICE_RESPONSE;
+      }
+      const call = await this.client.calls.create(callParams);
+      const twilioCall = {
+        sid: call.sid,
+        from: call.from,
+        to: call.to,
+        status: call.status,
+        direction: "outbound",
+        dateCreated: call.dateCreated
+      };
+      this.cache.set(
+        CACHE_KEYS.CALL_STATE(call.sid),
+        twilioCall,
+        TWILIO_CONSTANTS.CACHE_TTL.CALL_STATE
+      );
+      return twilioCall;
+    } catch (error) {
+      throw new TwilioError(
+        `Failed to make call: ${error.message}`,
+        error.code,
+        error.moreInfo
+      );
+    }
+  }
+  async handleIncomingSms(webhook) {
+    const message = {
+      sid: webhook.MessageSid,
+      from: webhook.From,
+      to: webhook.To,
+      body: webhook.Body,
+      direction: "inbound",
+      status: "received",
+      dateCreated: /* @__PURE__ */ new Date()
+    };
+    if (webhook.NumMedia && parseInt(webhook.NumMedia) > 0) {
+      message.media = [];
+      for (let i = 0; i < parseInt(webhook.NumMedia); i++) {
+        const mediaUrl = webhook[`MediaUrl${i}`];
+        const contentType = webhook[`MediaContentType${i}`];
+        if (mediaUrl) {
+          message.media.push({
+            url: mediaUrl,
+            contentType: contentType || "unknown",
+            sid: `media_${i}`
+          });
+        }
+      }
+    }
+    const conversationKey = CACHE_KEYS.CONVERSATION(webhook.From);
+    let conversationHistory = this.cache.get(conversationKey) || [];
+    conversationHistory.push(message);
+    if (conversationHistory.length > 50) {
+      conversationHistory = conversationHistory.slice(-50);
+    }
+    this.cache.set(
+      conversationKey,
+      conversationHistory,
+      TWILIO_CONSTANTS.CACHE_TTL.CONVERSATION
+    );
+    if (this.runtime) {
+      this.runtime.emitEvent("sms:received" /* SMS_RECEIVED */, message);
+    }
+    await this.processIncomingMessage(message);
+  }
+  async handleIncomingCall(webhook) {
+    const call = {
+      sid: webhook.CallSid,
+      from: webhook.From,
+      to: webhook.To,
+      status: webhook.CallStatus,
+      direction: "inbound",
+      dateCreated: /* @__PURE__ */ new Date()
+    };
+    this.cache.set(
+      CACHE_KEYS.CALL_STATE(webhook.CallSid),
+      call,
+      TWILIO_CONSTANTS.CACHE_TTL.CALL_STATE
+    );
+    if (this.runtime) {
+      this.runtime.emitEvent("call:received" /* CALL_RECEIVED */, call);
+    }
+    const streamUrl = `wss://${new URL(this.twilioConfig.webhookUrl).host}${TWILIO_CONSTANTS.WEBHOOK_PATHS.VOICE_STREAM}?callSid=${webhook.CallSid}`;
+    return TWILIO_CONSTANTS.TWIML.STREAM_RESPONSE(streamUrl);
+  }
+  async startVoiceStream(callSid) {
+    const stream = this.voiceStreams.get(callSid);
+    if (!stream) {
+      throw new TwilioError(`No voice stream found for call ${callSid}`);
+    }
+    logger5.info(`Starting voice stream processing for call ${callSid}`);
+  }
+  async endVoiceStream(callSid) {
+    const stream = this.voiceStreams.get(callSid);
+    if (stream && stream.socket) {
+      stream.socket.close();
+    }
+    this.voiceStreams.delete(callSid);
+  }
+  async processIncomingMessage(message) {
+    try {
+      const text = message.body?.trim();
+      if (!text) {
+        return;
+      }
+      const source = isWhatsAppAddress(message.from) ? "whatsapp" : "twilio";
+      const entityId = createUniqueUuid(this.runtime, message.from);
+      const roomId = createUniqueUuid(this.runtime, `twilio:${message.from}`);
+      const worldId = createUniqueUuid(this.runtime, `twilio:${message.to}`);
+      await this.runtime.ensureConnection({
+        entityId,
+        roomId,
+        worldId,
+        userName: message.from,
+        source,
+        channelId: message.from,
+        type: ChannelType.DM
+      });
+      const attachments = this.buildMediaAttachments(message.media);
+      const memory = createMessageMemory({
+        id: stringToUuid(message.sid),
+        entityId,
+        roomId,
+        content: {
+          text,
+          source,
+          channelType: ChannelType.DM,
+          phoneNumber: message.from,
+          attachments: attachments.length > 0 ? attachments : void 0
+        }
+      });
+      const callback = async (content) => {
+        const responseText = typeof content.text === "string" ? content.text.trim() : "";
+        if (!responseText) {
+          return [];
+        }
+        await this.sendSms(message.from, responseText, void 0, message.to);
+        return [];
+      };
+      const messageService = getMessageService(this.runtime);
+      if (messageService) {
+        await messageService.handleMessage(this.runtime, memory, callback);
+      } else {
+        logger5.warn("messageService unavailable; falling back to event emit");
+        await this.runtime.emitEvent(EventType.MESSAGE_RECEIVED, {
+          message: memory,
+          callback,
+          source
+        });
+      }
+    } catch (error) {
+      logger5.error(
+        { error: String(error) },
+        "Error processing incoming message"
+      );
+    }
+  }
+  buildMediaAttachments(media) {
+    if (!media || media.length === 0) {
+      return [];
+    }
+    return media.map((item) => ({
+      id: item.sid,
+      url: item.url,
+      contentType: this.resolveContentType(item.contentType)
+    }));
+  }
+  resolveContentType(contentType) {
+    if (contentType.startsWith("image/")) {
+      return ContentType.IMAGE;
+    }
+    if (contentType.startsWith("video/")) {
+      return ContentType.VIDEO;
+    }
+    if (contentType.startsWith("audio/")) {
+      return ContentType.AUDIO;
+    }
+    return ContentType.DOCUMENT;
+  }
+  sendStreamAudio(callSid, audio) {
+    const stream = this.voiceStreams.get(callSid);
+    if (!stream || !stream.socket) return;
+    const payload = {
+      event: "media",
+      streamSid: stream.streamSid,
+      media: {
+        payload: audio.toString("base64")
+      }
+    };
+    stream.socket.send(JSON.stringify(payload));
+  }
+  async cleanup() {
+    for (const [callSid, stream] of this.voiceStreams) {
+      if (stream.socket) {
+        stream.socket.close();
+      }
+    }
+    this.voiceStreams.clear();
+    if (this.wss) {
+      this.wss.close();
+    }
+    if (this.server) {
+      this.server.close();
+    }
+    this.cache.flushAll();
+    this.isInitialized = false;
+    logger5.info("TwilioService cleaned up");
+  }
+  // Getters for service information
+  get serviceType() {
+    return TWILIO_SERVICE_NAME;
+  }
+  get serviceName() {
+    return "twilio";
+  }
+  get phoneNumber() {
+    return this.twilioConfig.phoneNumber;
+  }
+  get isConnected() {
+    return this.isInitialized;
+  }
+  // Add public method to get conversation history
+  getConversationHistory(phoneNumber, limit = 10) {
+    const cacheKey = CACHE_KEYS.CONVERSATION(phoneNumber);
+    const messages = this.cache.get(cacheKey);
+    if (!messages || !Array.isArray(messages)) {
+      return [];
+    }
+    return messages.slice(-limit);
+  }
+  // Add method to get call state
+  getCallState(callSid) {
+    const cacheKey = CACHE_KEYS.CALL_STATE(callSid);
+    return this.cache.get(cacheKey);
+  }
+};
+
+// src/tests.ts
+import {
+  logger as logger6
+} from "@elizaos/core";
+import * as readline from "readline";
+import axios from "axios";
+var TwilioTestSuite = class {
+  name = "Twilio Plugin Test Suite";
+  description = "Tests for Twilio voice and SMS functionality";
+  tests = [
+    {
+      name: "Service Initialization Test",
+      fn: async (runtime) => {
+        const twilioService = runtime.getService(
+          TWILIO_SERVICE_NAME
+        );
+        if (!twilioService) {
+          throw new Error("Twilio service not initialized");
+        }
+        if (!twilioService.isConnected) {
+          throw new Error("Twilio service is not connected");
+        }
+        if (!twilioService.phoneNumber) {
+          throw new Error("Twilio phone number not configured");
+        }
+        logger6.info(
+          `\u2705 Service initialized with phone number: ${twilioService.phoneNumber}`
+        );
+      }
+    },
+    {
+      name: "Send SMS Test",
+      fn: async (runtime) => {
+        const twilioService = runtime.getService(
+          TWILIO_SERVICE_NAME
+        );
+        if (!twilioService) {
+          throw new Error("Twilio service not initialized");
+        }
+        const testNumber = runtime.getSetting("TWILIO_TEST_PHONE_NUMBER");
+        if (!testNumber) {
+          logger6.warn("TWILIO_TEST_PHONE_NUMBER not set, skipping SMS test");
+          return;
+        }
+        const result = await twilioService.sendSms(
+          testNumber,
+          "Test SMS from Eliza Twilio plugin"
+        );
+        logger6.info(`\u2705 SMS test successful. Message SID: ${result.sid}`);
+      }
+    },
+    {
+      name: "Send MMS Test",
+      fn: async (runtime) => {
+        const twilioService = runtime.getService(
+          TWILIO_SERVICE_NAME
+        );
+        if (!twilioService) {
+          throw new Error("Twilio service not initialized");
+        }
+        const testNumber = runtime.getSetting("TWILIO_TEST_PHONE_NUMBER");
+        if (!testNumber) {
+          logger6.warn("TWILIO_TEST_PHONE_NUMBER not set, skipping MMS test");
+          return;
+        }
+        const result = await twilioService.sendSms(
+          testNumber,
+          "Test MMS from Eliza Twilio plugin",
+          ["https://demo.twilio.com/owl.png"]
+          // Twilio's demo image
+        );
+        logger6.info(`\u2705 MMS test successful. Message SID: ${result.sid}`);
+      }
+    },
+    {
+      name: "Make Call Test",
+      fn: async (runtime) => {
+        const twilioService = runtime.getService(
+          TWILIO_SERVICE_NAME
+        );
+        if (!twilioService) {
+          throw new Error("Twilio service not initialized");
+        }
+        const testNumber = runtime.getSetting("TWILIO_TEST_PHONE_NUMBER");
+        if (!testNumber) {
+          logger6.warn("TWILIO_TEST_PHONE_NUMBER not set, skipping call test");
+          return;
+        }
+        const twiml = `<?xml version="1.0" encoding="UTF-8"?>
+<Response>
+    <Say voice="alice">This is a test call from Eliza Twilio plugin. Goodbye!</Say>
+    <Hangup/>
+</Response>`;
+        const result = await twilioService.makeCall(testNumber, twiml);
+        logger6.info(`\u2705 Call test successful. Call SID: ${result.sid}`);
+      }
+    },
+    {
+      name: "Webhook Server Test",
+      fn: async (runtime) => {
+        const twilioService = runtime.getService(
+          TWILIO_SERVICE_NAME
+        );
+        if (!twilioService) {
+          throw new Error("Twilio service not initialized");
+        }
+        if (!twilioService.isConnected) {
+          throw new Error("Webhook server is not running");
+        }
+        const webhookPort = runtime.getSetting("TWILIO_WEBHOOK_PORT") || "3000";
+        logger6.info(`\u2705 Webhook server is running on port ${webhookPort}`);
+        const webhookUrl = runtime.getSetting("TWILIO_WEBHOOK_URL");
+        if (webhookUrl && webhookUrl.includes("localhost")) {
+          try {
+            const smsResponse = await axios.post(
+              `http://localhost:${webhookPort}/webhooks/twilio/sms`,
+              {
+                MessageSid: "TEST123",
+                From: "+18885551234",
+                To: twilioService.phoneNumber,
+                Body: "Test webhook message"
+              },
+              {
+                headers: {
+                  "Content-Type": "application/x-www-form-urlencoded"
+                }
+              }
+            );
+            if (smsResponse.status === 200) {
+              logger6.info("\u2705 SMS webhook endpoint is responding");
+            }
+            const voiceResponse = await axios.post(
+              `http://localhost:${webhookPort}/webhooks/twilio/voice`,
+              {
+                CallSid: "CATEST123",
+                From: "+18885551234",
+                To: twilioService.phoneNumber,
+                CallStatus: "ringing"
+              },
+              {
+                headers: {
+                  "Content-Type": "application/x-www-form-urlencoded"
+                }
+              }
+            );
+            if (voiceResponse.status === 200) {
+              logger6.info("\u2705 Voice webhook endpoint is responding");
+            }
+          } catch (error) {
+            logger6.warn(
+              { error: String(error) },
+              "Could not test webhook endpoints locally"
+            );
+          }
+        }
+      }
+    },
+    {
+      name: "Conversation History Test",
+      fn: async (runtime) => {
+        const twilioService = runtime.getService(
+          TWILIO_SERVICE_NAME
+        );
+        if (!twilioService) {
+          throw new Error("Twilio service not initialized");
+        }
+        const testNumber = runtime.getSetting("TWILIO_TEST_PHONE_NUMBER");
+        if (!testNumber) {
+          logger6.warn(
+            "TWILIO_TEST_PHONE_NUMBER not set, skipping conversation history test"
+          );
+          return;
+        }
+        await twilioService.sendSms(testNumber, "History test message");
+        const history = twilioService.getConversationHistory(testNumber, 5);
+        if (history.length > 0) {
+          logger6.info(
+            `\u2705 Conversation history retrieved: ${history.length} messages`
+          );
+          logger6.info(`   Latest message: ${history[history.length - 1].body}`);
+        } else {
+          logger6.info(
+            "\u2705 Conversation history is empty (expected for new number)"
+          );
+        }
+      }
+    },
+    {
+      name: "Error Handling Test",
+      fn: async (runtime) => {
+        const twilioService = runtime.getService(
+          TWILIO_SERVICE_NAME
+        );
+        if (!twilioService) {
+          throw new Error("Twilio service not initialized");
+        }
+        try {
+          await twilioService.sendSms("invalid-number", "Test");
+          throw new Error("Expected error for invalid phone number");
+        } catch (error) {
+          if (error.message.includes("Invalid phone number")) {
+            logger6.info("\u2705 Invalid phone number error handled correctly");
+          } else {
+            throw error;
+          }
+        }
+        try {
+          await twilioService.sendSms("+18885551234", "");
+          logger6.info("\u2705 Empty message handled");
+        } catch (error) {
+          logger6.info("\u2705 Empty message error handled correctly");
+        }
+      }
+    },
+    {
+      name: "Interactive Test Mode",
+      fn: async (runtime) => {
+        const twilioService = runtime.getService(
+          TWILIO_SERVICE_NAME
+        );
+        if (!twilioService) {
+          throw new Error("Twilio service not initialized");
+        }
+        const phoneNumber = runtime.getSetting("TWILIO_PHONE_NUMBER");
+        const testNumber = runtime.getSetting("TWILIO_TEST_PHONE_NUMBER");
+        if (!phoneNumber || !testNumber) {
+          throw new Error(
+            "TWILIO_PHONE_NUMBER and TWILIO_TEST_PHONE_NUMBER must be set for interactive testing"
+          );
+        }
+        logger6.info("\n\u{1F3AE} INTERACTIVE TWILIO TEST MODE");
+        logger6.info("================================");
+        logger6.info(`\u{1F4F1} Your Twilio Number: ${phoneNumber}`);
+        logger6.info(`\u{1F4F1} Test Target Number: ${testNumber}`);
+        logger6.info("\n\u{1F4CB} Instructions:");
+        logger6.info(
+          "1. The webhook server is running and listening for incoming messages"
+        );
+        logger6.info(
+          "2. Text or call your Twilio number to test incoming messages"
+        );
+        logger6.info("3. The test will send a test SMS and make a test call");
+        logger6.info("4. Watch the console for incoming message logs");
+        logger6.info("\nPress Enter to start the interactive test...");
+        await new Promise((resolve) => {
+          const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+          });
+          rl.question("", () => {
+            rl.close();
+            resolve();
+          });
+        });
+        logger6.info("\n\u{1F4E4} Test 1: Sending SMS...");
+        try {
+          const smsResult = await twilioService.sendSms(
+            testNumber,
+            "\u{1F389} Interactive test SMS from ElizaOS! Reply to test two-way messaging."
+          );
+          logger6.info(`\u2705 SMS sent! SID: ${smsResult.sid}`);
+          logger6.info(`   Status: ${smsResult.status}`);
+        } catch (error) {
+          logger6.error(`\u274C SMS failed: ${error}`);
+        }
+        await new Promise((resolve) => setTimeout(resolve, 2e3));
+        logger6.info("\n\u{1F4E4} Test 2: Making call...");
+        try {
+          const twiml = `<?xml version="1.0" encoding="UTF-8"?>
+<Response>
+    <Say voice="alice">Hello from ElizaOS interactive test! This call confirms your Twilio integration is working.</Say>
+    <Play>https://api.twilio.com/cowbell.mp3</Play>
+    <Say voice="alice">Thank you for testing. Goodbye!</Say>
+</Response>`;
+          const callResult = await twilioService.makeCall(testNumber, twiml);
+          logger6.info(`\u2705 Call initiated! SID: ${callResult.sid}`);
+          logger6.info(`   Status: ${callResult.status}`);
+        } catch (error) {
+          logger6.error(`\u274C Call failed: ${error}`);
+        }
+        logger6.info("\n\u{1F4E5} Test 3: Waiting for incoming messages...");
+        logger6.info("   Text your Twilio number now!");
+        logger6.info("   The server will log any incoming SMS");
+        logger6.info("\n\u23F1\uFE0F  Test will continue for 30 seconds...");
+        await new Promise((resolve) => setTimeout(resolve, 3e4));
+        logger6.info("\n\u2728 Interactive test complete!");
+        logger6.info("Check logs for detailed results.");
+      }
+    }
+  ];
+};
+
+// src/index.ts
+var twilioPlugin = {
+  name: "twilio",
+  description: "Twilio plugin for bidirectional voice and text messaging integration",
+  services: [TwilioService],
+  actions: [sendSms_default, makeCall_default, sendMms_default],
+  providers: [conversationHistory_default, callState_default],
+  tests: [new TwilioTestSuite()],
+  init: async (config, runtime) => {
+    const accountSid = runtime.getSetting("TWILIO_ACCOUNT_SID");
+    const authToken = runtime.getSetting("TWILIO_AUTH_TOKEN");
+    const phoneNumber = runtime.getSetting("TWILIO_PHONE_NUMBER");
+    const webhookUrl = runtime.getSetting("TWILIO_WEBHOOK_URL");
+    if (!accountSid || accountSid.trim() === "") {
+      logger7.warn(
+        "Twilio Account SID not provided - Twilio plugin is loaded but will not be functional"
+      );
+      logger7.warn(
+        "To enable Twilio functionality, please provide TWILIO_ACCOUNT_SID in your .env file"
+      );
+      return;
+    }
+    if (!authToken || authToken.trim() === "") {
+      logger7.warn(
+        "Twilio Auth Token not provided - Twilio plugin is loaded but will not be functional"
+      );
+      logger7.warn(
+        "To enable Twilio functionality, please provide TWILIO_AUTH_TOKEN in your .env file"
+      );
+      return;
+    }
+    if (!phoneNumber || phoneNumber.trim() === "") {
+      logger7.warn(
+        "Twilio Phone Number not provided - Twilio plugin is loaded but will not be functional"
+      );
+      logger7.warn(
+        "To enable Twilio functionality, please provide TWILIO_PHONE_NUMBER in your .env file"
+      );
+      return;
+    }
+    if (!webhookUrl || webhookUrl.trim() === "") {
+      logger7.warn(
+        "Twilio Webhook URL not provided - Twilio will not be able to receive incoming messages or calls"
+      );
+      logger7.warn(
+        "To enable incoming communication, please provide TWILIO_WEBHOOK_URL in your .env file"
+      );
+    }
+    logger7.info("Twilio plugin initialized successfully");
+  }
+};
+var index_default = twilioPlugin;
+export {
+  index_default as default
+};
+//# sourceMappingURL=index.js.map