@sendly/mcp 1.3.0 → 2.0.1

package/dist/index.js

@@ -3,8 +3,1360 @@
 // src/index.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/tools.ts
 import { z } from "zod";
-var VERSION = "1.2.0";
+function ok(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+  };
+}
+function err(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return {
+    content: [{ type: "text", text: `Error: ${message}` }],
+    isError: true
+  };
+}
+function registerAllTools(server2, api2) {
+  server2.tool(
+    "send_sms",
+    "Send an SMS message to a phone number. Returns the message with delivery status. Use 'transactional' for alerts/OTP (bypasses quiet hours), 'marketing' for promotions.",
+    {
+      to: z.string().describe("Recipient phone number in E.164 format (+14155551234)"),
+      text: z.string().describe("Message text content"),
+      messageType: z.enum(["marketing", "transactional"]).optional().describe("Message type (default: marketing)"),
+      metadata: z.record(z.string(), z.any()).optional().describe("Custom key-value metadata to attach")
+    },
+    async ({ to, text, messageType, metadata }) => {
+      try {
+        const body = { to, text };
+        if (messageType) body.messageType = messageType;
+        if (metadata) body.metadata = metadata;
+        return ok(await api2("POST", "/messages", body));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "list_messages",
+    "List sent and received SMS messages with pagination. Use q parameter for full-text search across message content.",
+    {
+      limit: z.number().optional().describe("Messages to return (1-100, default 50)"),
+      offset: z.number().optional().describe("Pagination offset"),
+      q: z.string().optional().describe("Full-text search query for message content")
+    },
+    async ({ limit, offset, q }) => {
+      try {
+        return ok(
+          await api2("GET", "/messages", void 0, {
+            limit: limit?.toString(),
+            offset: offset?.toString(),
+            q
+          })
+        );
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_message",
+    "Get details of a specific SMS message including delivery status, timestamps, and metadata.",
+    {
+      messageId: z.string().describe("The message ID")
+    },
+    async ({ messageId }) => {
+      try {
+        return ok(await api2("GET", `/messages/${messageId}`));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "schedule_sms",
+    "Schedule an SMS for future delivery (5 minutes to 5 days from now). Credits are reserved immediately and refunded if cancelled.",
+    {
+      to: z.string().describe("Recipient phone number in E.164 format"),
+      text: z.string().describe("Message text content"),
+      scheduledAt: z.string().describe("ISO 8601 datetime for delivery (e.g., 2026-03-16T09:00:00Z)"),
+      messageType: z.enum(["marketing", "transactional"]).optional().describe("Message type (default: marketing)")
+    },
+    async ({ to, text, scheduledAt, messageType }) => {
+      try {
+        const body = { to, text, scheduledAt };
+        if (messageType) body.messageType = messageType;
+        return ok(await api2("POST", "/messages/schedule", body));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "cancel_scheduled_message",
+    "Cancel a scheduled message before it sends. Credits are refunded automatically.",
+    {
+      messageId: z.string().describe("The scheduled message ID to cancel")
+    },
+    async ({ messageId }) => {
+      try {
+        return ok(await api2("DELETE", `/messages/scheduled/${messageId}`));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "list_scheduled_messages",
+    "List all scheduled messages that haven't been sent yet.",
+    {
+      limit: z.number().optional().describe("Messages to return (1-100, default 50)"),
+      offset: z.number().optional().describe("Pagination offset")
+    },
+    async ({ limit, offset }) => {
+      try {
+        return ok(
+          await api2("GET", "/messages/scheduled", void 0, {
+            limit: limit?.toString(),
+            offset: offset?.toString()
+          })
+        );
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "send_batch",
+    "Send multiple SMS messages in a single batch (up to 1000). More efficient than individual sends for bulk messaging.",
+    {
+      messages: z.array(z.object({
+        to: z.string().describe("Recipient phone number in E.164 format"),
+        text: z.string().describe("Message text")
+      })).describe("Array of messages to send (max 1000)"),
+      messageType: z.enum(["marketing", "transactional"]).optional().describe("Message type for all messages (default: marketing)")
+    },
+    async ({ messages, messageType }) => {
+      try {
+        const body = { messages };
+        if (messageType) body.messageType = messageType;
+        return ok(await api2("POST", "/messages/batch", body));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "preview_batch",
+    "Preview a batch without sending. Returns credit cost estimate and validation results.",
+    {
+      messages: z.array(z.object({
+        to: z.string().describe("Recipient phone number in E.164 format"),
+        text: z.string().describe("Message text")
+      })).describe("Array of messages to preview"),
+      messageType: z.enum(["marketing", "transactional"]).optional().describe("Message type (default: marketing)")
+    },
+    async ({ messages, messageType }) => {
+      try {
+        const body = { messages };
+        if (messageType) body.messageType = messageType;
+        return ok(await api2("POST", "/messages/batch/preview", body));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_batch",
+    "Get the status of a message batch including per-message delivery results.",
+    {
+      batchId: z.string().describe("The batch ID")
+    },
+    async ({ batchId }) => {
+      try {
+        return ok(await api2("GET", `/messages/batch/${batchId}`));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "list_batches",
+    "List message batches with pagination.",
+    {
+      limit: z.number().optional().describe("Batches to return (1-100, default 50)"),
+      offset: z.number().optional().describe("Pagination offset")
+    },
+    async ({ limit, offset }) => {
+      try {
+        return ok(
+          await api2("GET", "/messages/batches", void 0, {
+            limit: limit?.toString(),
+            offset: offset?.toString()
+          })
+        );
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "list_conversations",
+    "List SMS conversation threads ordered by most recent activity. Each conversation groups all messages with a specific phone number.",
+    {
+      limit: z.number().optional().describe("Conversations to return (1-100, default 50)"),
+      offset: z.number().optional().describe("Pagination offset"),
+      status: z.enum(["active", "closed"]).optional().describe("Filter by conversation status")
+    },
+    async ({ limit, offset, status }) => {
+      try {
+        return ok(
+          await api2("GET", "/conversations", void 0, {
+            limit: limit?.toString(),
+            offset: offset?.toString(),
+            status
+          })
+        );
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_conversation_context",
+    "Get LLM-ready formatted conversation context. Returns a pre-formatted text string with timestamped messages, AI classification, and business context \u2014 ready to paste into a prompt.",
+    {
+      conversationId: z.string().describe("The conversation ID"),
+      maxMessages: z.number().optional().describe("Max messages to include (default 20, max 50)")
+    },
+    async ({ conversationId, maxMessages }) => {
+      try {
+        return ok(
+          await api2("GET", `/conversations/${conversationId}/context`, void 0, {
+            max_messages: maxMessages?.toString()
+          })
+        );
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_conversation",
+    "Get a conversation thread by ID. Set includeMessages=true to load the message history.",
+    {
+      conversationId: z.string().describe("The conversation ID"),
+      includeMessages: z.boolean().optional().describe("Include message history (default false)"),
+      messageLimit: z.number().optional().describe("Number of messages to include (default 50)")
+    },
+    async ({ conversationId, includeMessages, messageLimit }) => {
+      try {
+        return ok(
+          await api2("GET", `/conversations/${conversationId}`, void 0, {
+            include_messages: includeMessages ? "true" : void 0,
+            message_limit: messageLimit?.toString()
+          })
+        );
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "reply_to_conversation",
+    "Send a reply within an existing conversation. The recipient is automatically set from the conversation's phone number.",
+    {
+      conversationId: z.string().describe("The conversation ID to reply in"),
+      text: z.string().describe("Reply message text"),
+      mediaUrls: z.array(z.string()).optional().describe("Media URLs for MMS")
+    },
+    async ({ conversationId, text, mediaUrls }) => {
+      try {
+        const body = { text };
+        if (mediaUrls?.length) body.mediaUrls = mediaUrls;
+        return ok(await api2("POST", `/conversations/${conversationId}/messages`, body));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "update_conversation",
+    "Update a conversation's metadata or tags. Use metadata for custom key-value data, tags for categorization.",
+    {
+      conversationId: z.string().describe("The conversation ID"),
+      metadata: z.record(z.string(), z.any()).optional().describe("Custom key-value metadata"),
+      tags: z.array(z.string()).optional().describe("Tags for categorization (replaces existing tags)")
+    },
+    async ({ conversationId, metadata, tags }) => {
+      try {
+        const body = {};
+        if (metadata) body.metadata = metadata;
+        if (tags) body.tags = tags;
+        return ok(await api2("PATCH", `/conversations/${conversationId}`, body));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "close_conversation",
+    "Close a conversation. Closed conversations auto-reopen when a new inbound message arrives.",
+    { conversationId: z.string().describe("The conversation ID to close") },
+    async ({ conversationId }) => {
+      try {
+        return ok(await api2("POST", `/conversations/${conversationId}/close`));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "reopen_conversation",
+    "Reopen a previously closed conversation, setting its status back to active.",
+    { conversationId: z.string().describe("The conversation ID to reopen") },
+    async ({ conversationId }) => {
+      try {
+        return ok(await api2("POST", `/conversations/${conversationId}/reopen`));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "mark_conversation_read",
+    "Mark a conversation as read, resetting the unread count to zero.",
+    { conversationId: z.string().describe("The conversation ID") },
+    async ({ conversationId }) => {
+      try {
+        return ok(await api2("POST", `/conversations/${conversationId}/mark-read`));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_suggested_replies",
+    "Get AI-generated reply suggestions for a conversation based on message history and context. Returns 2-3 suggested responses with different tones (professional, friendly, concise).",
+    { conversationId: z.string().describe("The conversation ID to generate suggestions for") },
+    async ({ conversationId }) => {
+      try {
+        return ok(await api2("POST", `/conversations/${conversationId}/suggest-replies`));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "create_contact",
+    "Create a contact with phone number and optional name, email, metadata. Contacts can be added to lists for campaigns.",
+    {
+      phoneNumber: z.string().describe("Phone number in E.164 format (+14155551234)"),
+      name: z.string().optional().describe("Contact name"),
+      email: z.string().optional().describe("Contact email address"),
+      metadata: z.record(z.string(), z.any()).optional().describe("Custom key-value metadata")
+    },
+    async ({ phoneNumber, name, email, metadata }) => {
+      try {
+        const body = { phone_number: phoneNumber };
+        if (name) body.name = name;
+        if (email) body.email = email;
+        if (metadata) body.metadata = metadata;
+        return ok(await api2("POST", "/contacts", body));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "list_contacts",
+    "List contacts with optional search and pagination. Search matches name, email, and phone number.",
+    {
+      limit: z.number().optional().describe("Contacts to return (1-100, default 50)"),
+      offset: z.number().optional().describe("Pagination offset"),
+      search: z.string().optional().describe("Search by name, email, or phone number"),
+      listId: z.string().optional().describe("Filter by contact list ID")
+    },
+    async ({ limit, offset, search, listId }) => {
+      try {
+        return ok(
+          await api2("GET", "/contacts", void 0, {
+            limit: limit?.toString(),
+            offset: offset?.toString(),
+            search,
+            list_id: listId
+          })
+        );
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_contact",
+    "Get a contact by ID including their list memberships and metadata.",
+    { contactId: z.string().describe("The contact ID") },
+    async ({ contactId }) => {
+      try {
+        return ok(await api2("GET", `/contacts/${contactId}`));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "update_contact",
+    "Update a contact's name, email, or metadata. Only provided fields are changed.",
+    {
+      contactId: z.string().describe("The contact ID"),
+      name: z.string().optional().describe("Updated name"),
+      email: z.string().optional().describe("Updated email"),
+      metadata: z.record(z.string(), z.any()).optional().describe("Updated metadata (replaces existing)")
+    },
+    async ({ contactId, name, email, metadata }) => {
+      try {
+        const body = {};
+        if (name !== void 0) body.name = name;
+        if (email !== void 0) body.email = email;
+        if (metadata) body.metadata = metadata;
+        return ok(await api2("PATCH", `/contacts/${contactId}`, body));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "delete_contact",
+    "Delete a contact by ID. Removes the contact from all lists. Does not delete messages sent to this contact.",
+    { contactId: z.string().describe("The contact ID to delete") },
+    async ({ contactId }) => {
+      try {
+        return ok(await api2("DELETE", `/contacts/${contactId}`));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "import_contacts",
+    "Bulk import contacts from an array. Optionally add all imported contacts to a list. Returns created/updated/skipped counts.",
+    {
+      contacts: z.array(z.object({
+        phone: z.string().describe("Phone in E.164 format"),
+        name: z.string().optional().describe("Contact name"),
+        email: z.string().optional().describe("Contact email")
+      })).describe("Array of contacts to import (max 10000)"),
+      listId: z.string().optional().describe("Add all imported contacts to this list")
+    },
+    async ({ contacts, listId }) => {
+      try {
+        const body = { contacts };
+        if (listId) body.listId = listId;
+        return ok(await api2("POST", "/contacts/import", body));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "create_contact_list",
+    "Create a contact list for organizing contacts and targeting campaigns.",
+    {
+      name: z.string().describe("List name (e.g., 'VIP Customers', 'Newsletter')"),
+      description: z.string().optional().describe("List description")
+    },
+    async ({ name, description }) => {
+      try {
+        const body = { name };
+        if (description) body.description = description;
+        return ok(await api2("POST", "/contact-lists", body));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "list_contact_lists",
+    "List all contact lists with their contact counts.",
+    {},
+    async () => {
+      try {
+        return ok(await api2("GET", "/contact-lists"));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_contact_list",
+    "Get a contact list by ID with its members. Use limit/offset to paginate through members.",
+    {
+      listId: z.string().describe("The contact list ID"),
+      limit: z.number().optional().describe("Max contacts to include (default 50)"),
+      offset: z.number().optional().describe("Pagination offset for contacts")
+    },
+    async ({ listId, limit, offset }) => {
+      try {
+        return ok(
+          await api2("GET", `/contact-lists/${listId}`, void 0, {
+            limit: limit?.toString(),
+            offset: offset?.toString()
+          })
+        );
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "update_contact_list",
+    "Update a contact list's name or description.",
+    {
+      listId: z.string().describe("The contact list ID"),
+      name: z.string().optional().describe("Updated name"),
+      description: z.string().optional().describe("Updated description")
+    },
+    async ({ listId, name, description }) => {
+      try {
+        const body = {};
+        if (name) body.name = name;
+        if (description !== void 0) body.description = description;
+        return ok(await api2("PATCH", `/contact-lists/${listId}`, body));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "delete_contact_list",
+    "Delete a contact list. Contacts in the list are not deleted, only the list grouping is removed.",
+    { listId: z.string().describe("The contact list ID to delete") },
+    async ({ listId }) => {
+      try {
+        return ok(await api2("DELETE", `/contact-lists/${listId}`));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "add_list_contacts",
+    "Add one or more contacts to a contact list.",
+    {
+      listId: z.string().describe("The contact list ID"),
+      contactIds: z.array(z.string()).describe("Array of contact IDs to add to the list")
+    },
+    async ({ listId, contactIds }) => {
+      try {
+        return ok(await api2("POST", `/contact-lists/${listId}/contacts`, { contact_ids: contactIds }));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "remove_list_contact",
+    "Remove a single contact from a contact list. The contact itself is not deleted.",
+    {
+      listId: z.string().describe("The contact list ID"),
+      contactId: z.string().describe("The contact ID to remove from the list")
+    },
+    async ({ listId, contactId }) => {
+      try {
+        return ok(await api2("DELETE", `/contact-lists/${listId}/contacts/${contactId}`));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "create_campaign",
+    "Create a campaign to send bulk SMS to contact lists. Created as a draft \u2014 preview and send separately. Supports {{variables}} in message text.",
+    {
+      name: z.string().describe("Campaign name"),
+      text: z.string().optional().describe("Message text with optional {{variables}}"),
+      templateId: z.string().optional().describe("Template ID to use instead of inline text"),
+      targetListId: z.string().optional().describe("Contact list ID to send to")
+    },
+    async ({ name, text, templateId, targetListId }) => {
+      try {
+        const body = { name };
+        if (text) body.messageText = text;
+        if (templateId) body.templateId = templateId;
+        if (targetListId) body.targetListId = targetListId;
+        return ok(await api2("POST", "/campaigns", body));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "list_campaigns",
+    "List campaigns with optional filtering by status.",
+    {
+      limit: z.number().optional().describe("Campaigns to return (1-100, default 50)"),
+      offset: z.number().optional().describe("Pagination offset"),
+      status: z.enum(["draft", "scheduled", "sending", "completed", "cancelled", "failed"]).optional().describe("Filter by campaign status")
+    },
+    async ({ limit, offset, status }) => {
+      try {
+        return ok(
+          await api2("GET", "/campaigns", void 0, {
+            limit: limit?.toString(),
+            offset: offset?.toString(),
+            status
+          })
+        );
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_campaign",
+    "Get a campaign by ID with delivery statistics (sent, delivered, failed counts).",
+    { campaignId: z.string().describe("The campaign ID") },
+    async ({ campaignId }) => {
+      try {
+        return ok(await api2("GET", `/campaigns/${campaignId}`));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "update_campaign",
+    "Update a campaign's name, text, or target list. Only draft and scheduled campaigns can be updated.",
+    {
+      campaignId: z.string().describe("The campaign ID"),
+      name: z.string().optional().describe("Updated campaign name"),
+      text: z.string().optional().describe("Updated message text"),
+      templateId: z.string().optional().describe("Updated template ID"),
+      targetListId: z.string().optional().describe("Updated target list ID")
+    },
+    async ({ campaignId, name, text, templateId, targetListId }) => {
+      try {
+        const body = {};
+        if (name) body.name = name;
+        if (text) body.messageText = text;
+        if (templateId) body.templateId = templateId;
+        if (targetListId) body.targetListId = targetListId;
+        return ok(await api2("PATCH", `/campaigns/${campaignId}`, body));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "delete_campaign",
+    "Delete a campaign. Only draft and cancelled campaigns can be deleted.",
+    { campaignId: z.string().describe("The campaign ID to delete") },
+    async ({ campaignId }) => {
+      try {
+        return ok(await api2("DELETE", `/campaigns/${campaignId}`));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "preview_campaign",
+    "Preview a campaign before sending. Returns recipient count, estimated credit cost, and whether you have enough credits.",
+    { campaignId: z.string().describe("The campaign ID to preview") },
+    async ({ campaignId }) => {
+      try {
+        return ok(await api2("GET", `/campaigns/${campaignId}/preview`));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "send_campaign",
+    "Send a campaign immediately to all recipients in its target lists. Credits are deducted at send time. Preview first to check costs.",
+    { campaignId: z.string().describe("The campaign ID to send") },
+    async ({ campaignId }) => {
+      try {
+        return ok(await api2("POST", `/campaigns/${campaignId}/send`));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "schedule_campaign",
+    "Schedule a campaign for future delivery at a specific date and time.",
+    {
+      campaignId: z.string().describe("The campaign ID to schedule"),
+      scheduledAt: z.string().describe("ISO 8601 datetime for delivery"),
+      timezone: z.string().optional().describe("Timezone (e.g., 'America/New_York')")
+    },
+    async ({ campaignId, scheduledAt, timezone }) => {
+      try {
+        const body = { scheduledAt };
+        if (timezone) body.timezone = timezone;
+        return ok(await api2("POST", `/campaigns/${campaignId}/schedule`, body));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "cancel_campaign",
+    "Cancel a scheduled campaign before it sends. Credits reserved for the campaign are refunded.",
+    { campaignId: z.string().describe("The campaign ID to cancel") },
+    async ({ campaignId }) => {
+      try {
+        return ok(await api2("POST", `/campaigns/${campaignId}/cancel`));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "clone_campaign",
+    "Clone a campaign to create a new draft copy with the same settings. Useful for recurring or A/B campaigns.",
+    { campaignId: z.string().describe("The campaign ID to clone") },
+    async ({ campaignId }) => {
+      try {
+        return ok(await api2("POST", `/campaigns/${campaignId}/clone`));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "create_template",
+    "Create an SMS template with {{variable}} placeholders. Templates can be used with campaigns and the Verify API.",
+    {
+      name: z.string().describe("Template name"),
+      text: z.string().describe("Template text with {{variable}} placeholders")
+    },
+    async ({ name, text }) => {
+      try {
+        return ok(await api2("POST", "/templates", { name, text }));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "list_templates",
+    "List all templates (custom and preset) with their status and variable definitions.",
+    {
+      limit: z.number().optional().describe("Templates to return (default 50)"),
+      offset: z.number().optional().describe("Pagination offset")
+    },
+    async ({ limit, offset }) => {
+      try {
+        return ok(
+          await api2("GET", "/templates", void 0, {
+            limit: limit?.toString(),
+            offset: offset?.toString()
+          })
+        );
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_template",
+    "Get a template by ID including its variable definitions and publish status.",
+    { templateId: z.string().describe("The template ID") },
+    async ({ templateId }) => {
+      try {
+        return ok(await api2("GET", `/templates/${templateId}`));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "update_template",
+    "Update a template's name or text.",
+    {
+      templateId: z.string().describe("The template ID"),
+      name: z.string().optional().describe("Updated template name"),
+      text: z.string().optional().describe("Updated template text")
+    },
+    async ({ templateId, name, text }) => {
+      try {
+        const body = {};
+        if (name) body.name = name;
+        if (text) body.text = text;
+        return ok(await api2("PATCH", `/templates/${templateId}`, body));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "delete_template",
+    "Delete a custom template. Preset templates cannot be deleted.",
+    { templateId: z.string().describe("The template ID to delete") },
+    async ({ templateId }) => {
+      try {
+        return ok(await api2("DELETE", `/templates/${templateId}`));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "publish_template",
+    "Publish a template, making it available for use with the Verify API and campaigns.",
+    { templateId: z.string().describe("The template ID to publish") },
+    async ({ templateId }) => {
+      try {
+        return ok(await api2("POST", `/templates/${templateId}/publish`));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "preview_template",
+    "Preview a template with sample variable values to see the interpolated result.",
+    {
+      templateId: z.string().describe("The template ID to preview"),
+      variables: z.record(z.string(), z.string()).optional().describe("Variable values (e.g., { app_name: 'MyApp', code: '123456' })")
+    },
+    async ({ templateId, variables }) => {
+      try {
+        const body = {};
+        if (variables) body.variables = variables;
+        return ok(await api2("POST", `/templates/${templateId}/preview`, body));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "list_template_presets",
+    "List system preset templates (OTP, 2FA, login, etc.) that can be used as-is or cloned.",
+    {},
+    async () => {
+      try {
+        return ok(await api2("GET", "/templates/presets"));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "create_label",
+    "Create a label for categorizing conversations and messages. Labels have a name and optional color.",
+    {
+      name: z.string().describe("Label name (e.g., 'urgent', 'vip', 'follow-up')"),
+      color: z.string().optional().describe("Hex color code (default: #6b7280)"),
+      description: z.string().optional().describe("Label description")
+    },
+    async ({ name, color, description }) => {
+      try {
+        const body = { name };
+        if (color) body.color = color;
+        if (description) body.description = description;
+        return ok(await api2("POST", "/labels", body));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "list_labels",
+    "List all labels available in your workspace.",
+    {},
+    async () => {
+      try {
+        return ok(await api2("GET", "/labels"));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "add_conversation_label",
+    "Add one or more labels to a conversation for categorization.",
+    {
+      conversationId: z.string().describe("The conversation ID"),
+      labelIds: z.array(z.string()).describe("Array of label IDs to add")
+    },
+    async ({ conversationId, labelIds }) => {
+      try {
+        return ok(await api2("POST", `/conversations/${conversationId}/labels`, { labelIds }));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "remove_conversation_label",
+    "Remove a label from a conversation.",
+    {
+      conversationId: z.string().describe("The conversation ID"),
+      labelId: z.string().describe("The label ID to remove")
+    },
+    async ({ conversationId, labelId }) => {
+      try {
+        return ok(await api2("DELETE", `/conversations/${conversationId}/labels/${labelId}`));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "list_rules",
+    "List auto-label rules that automatically tag conversations based on AI-detected intent and sentiment.",
+    {},
+    async () => {
+      try {
+        return ok(await api2("GET", "/rules"));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "create_rule",
+    "Create an auto-label rule. Rules automatically apply labels to conversations when conditions match.",
+    {
+      name: z.string().describe("Rule name"),
+      conditions: z.object({
+        intent: z.union([z.string(), z.array(z.string())]).optional().describe("Intent(s) to match"),
+        sentiment: z.union([z.string(), z.array(z.string())]).optional().describe("Sentiment(s) to match")
+      }).describe("Conditions that trigger the rule"),
+      actions: z.object({
+        addLabels: z.array(z.string()).describe("Label IDs to add when rule matches"),
+        closeConversation: z.boolean().optional().describe("Automatically close the conversation")
+      }).describe("Actions to take when conditions match"),
+      priority: z.number().optional().describe("Rule priority (lower runs first)")
+    },
+    async ({ name, conditions, actions, priority }) => {
+      try {
+        const body = { name, conditions, actions };
+        if (priority !== void 0) body.priority = priority;
+        return ok(await api2("POST", "/rules", body));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "update_rule",
+    "Update an auto-label rule's name, conditions, actions, or enabled status.",
+    {
+      ruleId: z.string().describe("The rule ID"),
+      name: z.string().optional().describe("Updated rule name"),
+      conditions: z.object({
+        intent: z.union([z.string(), z.array(z.string())]).optional(),
+        sentiment: z.union([z.string(), z.array(z.string())]).optional()
+      }).optional().describe("Updated conditions"),
+      actions: z.object({
+        addLabels: z.array(z.string()),
+        closeConversation: z.boolean().optional()
+      }).optional().describe("Updated actions"),
+      enabled: z.boolean().optional().describe("Enable or disable the rule")
+    },
+    async ({ ruleId, name, conditions, actions, enabled }) => {
+      try {
+        const body = {};
+        if (name) body.name = name;
+        if (conditions) body.conditions = conditions;
+        if (actions) body.actions = actions;
+        if (enabled !== void 0) body.enabled = enabled;
+        return ok(await api2("PATCH", `/rules/${ruleId}`, body));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "delete_rule",
+    "Delete an auto-label rule. Existing labels already applied by this rule are not removed.",
+    { ruleId: z.string().describe("The rule ID to delete") },
+    async ({ ruleId }) => {
+      try {
+        return ok(await api2("DELETE", `/rules/${ruleId}`));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "create_draft",
+    "Create a message draft for human review before sending. The draft must be approved before it becomes a real SMS.",
+    {
+      conversationId: z.string().describe("The conversation ID"),
+      text: z.string().describe("Draft message text"),
+      source: z.string().optional().describe("Source of the draft (default: 'ai')")
+    },
+    async ({ conversationId, text, source }) => {
+      try {
+        const body = { conversationId, text };
+        if (source) body.source = source;
+        return ok(await api2("POST", "/drafts", body));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "list_drafts",
+    "List message drafts, optionally filtered by conversation or status.",
+    {
+      conversationId: z.string().optional().describe("Filter by conversation ID"),
+      status: z.enum(["pending", "approved", "rejected", "sent", "failed"]).optional().describe("Filter by status")
+    },
+    async ({ conversationId, status }) => {
+      try {
+        return ok(
+          await api2("GET", "/drafts", void 0, {
+            conversation_id: conversationId,
+            status
+          })
+        );
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "approve_draft",
+    "Approve a pending draft and send it as a real SMS message. Runs compliance checks and deducts credits at approval time.",
+    { draftId: z.string().describe("The draft ID to approve") },
+    async ({ draftId }) => {
+      try {
+        return ok(await api2("POST", `/drafts/${draftId}/approve`));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "reject_draft",
+    "Reject a pending draft with an optional reason. The message will not be sent.",
+    {
+      draftId: z.string().describe("The draft ID to reject"),
+      reason: z.string().optional().describe("Reason for rejection")
+    },
+    async ({ draftId, reason }) => {
+      try {
+        const body = {};
+        if (reason) body.reason = reason;
+        return ok(await api2("POST", `/drafts/${draftId}/reject`, body));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "create_webhook",
+    "Create a webhook endpoint to receive real-time event notifications. Returns a signing secret (shown only once) for verifying payloads.",
+    {
+      url: z.string().describe("HTTPS endpoint URL to receive events"),
+      events: z.array(z.string()).describe("Event types to subscribe to (e.g., ['message.delivered', 'message.failed'])"),
+      description: z.string().optional().describe("Description of this webhook")
+    },
+    async ({ url, events, description }) => {
+      try {
+        const body = { url, events };
+        if (description) body.description = description;
+        return ok(await api2("POST", "/webhooks", body));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "list_webhooks",
+    "List all webhook endpoints with their status and event subscriptions.",
+    {},
+    async () => {
+      try {
+        return ok(await api2("GET", "/webhooks"));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_webhook",
+    "Get a webhook by ID with delivery statistics.",
+    { webhookId: z.string().describe("The webhook ID") },
+    async ({ webhookId }) => {
+      try {
+        return ok(await api2("GET", `/webhooks/${webhookId}`));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "update_webhook",
+    "Update a webhook's URL, events, description, or active status.",
+    {
+      webhookId: z.string().describe("The webhook ID"),
+      url: z.string().optional().describe("Updated HTTPS endpoint URL"),
+      events: z.array(z.string()).optional().describe("Updated event types"),
+      description: z.string().optional().describe("Updated description"),
+      isActive: z.boolean().optional().describe("Enable or disable the webhook")
+    },
+    async ({ webhookId, url, events, description, isActive }) => {
+      try {
+        const body = {};
+        if (url) body.url = url;
+        if (events) body.events = events;
+        if (description !== void 0) body.description = description;
+        if (isActive !== void 0) body.is_active = isActive;
+        return ok(await api2("PATCH", `/webhooks/${webhookId}`, body));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "delete_webhook",
+    "Delete a webhook endpoint. Stops all future event deliveries to this URL.",
+    { webhookId: z.string().describe("The webhook ID to delete") },
+    async ({ webhookId }) => {
+      try {
+        return ok(await api2("DELETE", `/webhooks/${webhookId}`));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "test_webhook",
+    "Send a test event to a webhook endpoint to verify it is reachable. Returns response status and latency.",
+    { webhookId: z.string().describe("The webhook ID to test") },
+    async ({ webhookId }) => {
+      try {
+        return ok(await api2("POST", `/webhooks/${webhookId}/test`));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "list_webhook_deliveries",
+    "Get delivery history for a webhook showing recent attempts, statuses, and response times.",
+    { webhookId: z.string().describe("The webhook ID") },
+    async ({ webhookId }) => {
+      try {
+        return ok(await api2("GET", `/webhooks/${webhookId}/deliveries`));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "rotate_webhook_secret",
+    "Rotate a webhook's signing secret. The old secret stops working immediately.",
+    { webhookId: z.string().describe("The webhook ID") },
+    async ({ webhookId }) => {
+      try {
+        return ok(await api2("POST", `/webhooks/${webhookId}/rotate-secret`));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "list_webhook_event_types",
+    "List all available webhook event types that can be subscribed to.",
+    {},
+    async () => {
+      try {
+        return ok(await api2("GET", "/webhooks/event-types"));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "send_otp",
+    "Send an OTP verification code via SMS. Use for phone verification, 2FA, or identity confirmation. In sandbox mode (test API key), the code is returned in the response.",
+    {
+      to: z.string().describe("Phone number to verify in E.164 format"),
+      appName: z.string().optional().describe("Your app/brand name shown in the SMS"),
+      codeLength: z.number().optional().describe("Digits in the code (default 6)"),
+      timeoutSecs: z.number().optional().describe("Code validity in seconds (default 300)"),
+      templateId: z.string().optional().describe("Custom OTP template ID")
+    },
+    async ({ to, appName, codeLength, timeoutSecs, templateId }) => {
+      try {
+        const body = { to };
+        if (appName) body.app_name = appName;
+        if (codeLength) body.code_length = codeLength;
+        if (timeoutSecs) body.timeout_secs = timeoutSecs;
+        if (templateId) body.template_id = templateId;
+        return ok(await api2("POST", "/verify", body));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "check_otp",
+    "Verify an OTP code. Returns 'verified' (correct), 'invalid_code' (wrong), 'expired', or 'max_attempts_exceeded'.",
+    {
+      verificationId: z.string().describe("The verification ID from send_otp"),
+      code: z.string().describe("The code entered by the user")
+    },
+    async ({ verificationId, code }) => {
+      try {
+        return ok(await api2("POST", `/verify/${verificationId}/check`, { code }));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_verification_status",
+    "Check the current status of an OTP verification (pending, verified, expired, failed).",
+    { verificationId: z.string().describe("The verification ID") },
+    async ({ verificationId }) => {
+      try {
+        return ok(await api2("GET", `/verify/${verificationId}`));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "resend_otp",
+    "Resend an OTP verification code. Use when the original SMS was not received.",
+    { verificationId: z.string().describe("The verification ID from send_otp") },
+    async ({ verificationId }) => {
+      try {
+        return ok(await api2("POST", `/verify/${verificationId}/resend`));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "list_verifications",
+    "List recent OTP verifications with pagination.",
+    {
+      limit: z.number().optional().describe("Verifications to return (default 50)")
+    },
+    async ({ limit }) => {
+      try {
+        return ok(
+          await api2("GET", "/verify", void 0, {
+            limit: limit?.toString()
+          })
+        );
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "create_verify_session",
+    "Create a hosted verify session with a branded UI. Returns a URL to redirect the user to for phone verification. Zero frontend code needed.",
+    {
+      successUrl: z.string().describe("URL to redirect to after successful verification"),
+      cancelUrl: z.string().optional().describe("URL to redirect to if user cancels"),
+      brandName: z.string().optional().describe("Your brand name shown on the verify page"),
+      brandColor: z.string().optional().describe("Brand color hex code (e.g., #4F46E5)"),
+      metadata: z.record(z.string(), z.any()).optional().describe("Custom metadata to attach to the session")
+    },
+    async ({ successUrl, cancelUrl, brandName, brandColor, metadata }) => {
+      try {
+        const body = { success_url: successUrl };
+        if (cancelUrl) body.cancel_url = cancelUrl;
+        if (brandName) body.brand_name = brandName;
+        if (brandColor) body.brand_color = brandColor;
+        if (metadata) body.metadata = metadata;
+        return ok(await api2("POST", "/verify/sessions", body));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "validate_verify_session",
+    "Validate a session token returned after a user completes hosted verification. Returns the verified phone number.",
+    { token: z.string().describe("The session token from the success redirect URL") },
+    async ({ token }) => {
+      try {
+        return ok(await api2("POST", "/verify/sessions/validate", { token }));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_credits",
+    "Get current credit balance including reserved credits for scheduled messages.",
+    {},
+    async () => {
+      try {
+        return ok(await api2("GET", "/credits"));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "list_credit_transactions",
+    "List credit transaction history showing purchases, usage, refunds, and transfers.",
+    {
+      limit: z.number().optional().describe("Transactions to return (default 50)")
+    },
+    async ({ limit }) => {
+      try {
+        return ok(
+          await api2("GET", "/credits/transactions", void 0, {
+            limit: limit?.toString()
+          })
+        );
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_account",
+    "Get account info: credit balance, phone number verification status, rate limits, and API key details.",
+    {},
+    async () => {
+      try {
+        return ok(await api2("GET", "/account"));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "generate_business_page",
+    "Generate a hosted business landing page for verification. Returns a URL at sendly.live/biz/{slug}. Enterprise accounts only.",
+    {
+      businessName: z.string().describe("Business name"),
+      useCase: z.string().optional().describe("Use case (e.g., Insurance Services, Appointment Reminders, 2FA)"),
+      useCaseSummary: z.string().optional().describe("Brief description of what the business does"),
+      contactEmail: z.string().optional().describe("Business contact email"),
+      contactPhone: z.string().optional().describe("Business phone number"),
+      businessAddress: z.string().optional().describe("City, State ZIP (e.g., Chicago, IL 60601)")
+    },
+    async (params) => {
+      try {
+        return ok(await api2("POST", "/enterprise/business-page/generate", params));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+}
+
+// src/index.ts
+var VERSION = "2.0.0";
 var API_KEY = process.env.SENDLY_API_KEY;
 var BASE_URL = process.env.SENDLY_BASE_URL || "https://sendly.live";
 if (!API_KEY) {
@@ -20,7 +1372,7 @@ if (!BASE_URL.startsWith("https://") && !BASE_URL.startsWith("http://localhost")
   process.exit(1);
 }
 var RATE_LIMIT_WINDOW_MS = 6e4;
-var RATE_LIMIT_MAX = 30;
+var RATE_LIMIT_MAX = 60;
 var rateLimitTokens = RATE_LIMIT_MAX;
 var rateLimitResetAt = Date.now() + RATE_LIMIT_WINDOW_MS;
 function checkRateLimit() {
@@ -66,490 +1418,10 @@ async function api(method, path, body, query) {
   }
   return data;
 }
-function ok(data) {
-  return {
-    content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
-  };
-}
-function err(error) {
-  const message = error instanceof Error ? error.message : String(error);
-  return {
-    content: [{ type: "text", text: `Error: ${message}` }],
-    isError: true
-  };
-}
 var server = new McpServer({
   name: "sendly",
   version: VERSION
 });
-server.tool(
-  "send_sms",
-  "Send an SMS message to a phone number. Returns the message with delivery status. Use 'transactional' for alerts/OTP (bypasses quiet hours), 'marketing' for promotions.",
-  {
-    to: z.string().describe("Recipient phone number in E.164 format (+14155551234)"),
-    text: z.string().describe("Message text content"),
-    messageType: z.enum(["marketing", "transactional"]).optional().describe("Message type (default: marketing)"),
-    metadata: z.record(z.string(), z.any()).optional().describe("Custom key-value metadata to attach")
-  },
-  async ({ to, text, messageType, metadata }) => {
-    try {
-      const body = { to, text };
-      if (messageType) body.messageType = messageType;
-      if (metadata) body.metadata = metadata;
-      return ok(await api("POST", "/messages", body));
-    } catch (e) {
-      return err(e);
-    }
-  }
-);
-server.tool(
-  "list_messages",
-  "List sent and received SMS messages with pagination, ordered by creation date.",
-  {
-    limit: z.number().optional().describe("Messages to return (1-100, default 50)"),
-    offset: z.number().optional().describe("Pagination offset"),
-    status: z.enum(["queued", "sent", "delivered", "failed"]).optional().describe("Filter by delivery status")
-  },
-  async ({ limit, offset, status }) => {
-    try {
-      return ok(
-        await api("GET", "/messages", void 0, {
-          limit: limit?.toString(),
-          offset: offset?.toString(),
-          status
-        })
-      );
-    } catch (e) {
-      return err(e);
-    }
-  }
-);
-server.tool(
-  "get_message",
-  "Get details of a specific SMS message including delivery status, timestamps, and metadata.",
-  {
-    messageId: z.string().describe("The message ID")
-  },
-  async ({ messageId }) => {
-    try {
-      return ok(await api("GET", `/messages/${messageId}`));
-    } catch (e) {
-      return err(e);
-    }
-  }
-);
-server.tool(
-  "schedule_sms",
-  "Schedule an SMS for future delivery (5 minutes to 5 days from now). Credits are reserved immediately and refunded if cancelled.",
-  {
-    to: z.string().describe("Recipient phone number in E.164 format"),
-    text: z.string().describe("Message text content"),
-    scheduledAt: z.string().describe("ISO 8601 datetime for delivery (e.g., 2026-03-16T09:00:00Z)"),
-    messageType: z.enum(["marketing", "transactional"]).optional().describe("Message type (default: marketing)")
-  },
-  async ({ to, text, scheduledAt, messageType }) => {
-    try {
-      const body = { to, text, scheduledAt };
-      if (messageType) body.messageType = messageType;
-      return ok(await api("POST", "/messages/schedule", body));
-    } catch (e) {
-      return err(e);
-    }
-  }
-);
-server.tool(
-  "cancel_scheduled_message",
-  "Cancel a scheduled message before it sends. Credits are refunded automatically.",
-  {
-    messageId: z.string().describe("The scheduled message ID to cancel")
-  },
-  async ({ messageId }) => {
-    try {
-      return ok(await api("DELETE", `/messages/scheduled/${messageId}`));
-    } catch (e) {
-      return err(e);
-    }
-  }
-);
-server.tool(
-  "list_conversations",
-  "List SMS conversation threads ordered by most recent activity. Each conversation groups all messages with a specific phone number.",
-  {
-    limit: z.number().optional().describe("Conversations to return (1-100, default 50)"),
-    offset: z.number().optional().describe("Pagination offset"),
-    status: z.enum(["active", "closed"]).optional().describe("Filter by conversation status")
-  },
-  async ({ limit, offset, status }) => {
-    try {
-      return ok(
-        await api("GET", "/conversations", void 0, {
-          limit: limit?.toString(),
-          offset: offset?.toString(),
-          status
-        })
-      );
-    } catch (e) {
-      return err(e);
-    }
-  }
-);
-server.tool(
-  "get_conversation_context",
-  "Get LLM-ready formatted conversation context. Returns a pre-formatted text string with timestamped messages, AI classification, and business context \u2014 ready to paste into a prompt. More efficient than get_conversation for AI agents.",
-  {
-    conversationId: z.string().describe("The conversation ID"),
-    maxMessages: z.number().optional().describe("Max messages to include (default 20, max 50)")
-  },
-  async ({ conversationId, maxMessages }) => {
-    try {
-      return ok(
-        await api("GET", `/conversations/${conversationId}/context`, void 0, {
-          max_messages: maxMessages?.toString()
-        })
-      );
-    } catch (e) {
-      return err(e);
-    }
-  }
-);
-server.tool(
-  "get_conversation",
-  "Get a conversation thread by ID. Set includeMessages=true to load the message history.",
-  {
-    conversationId: z.string().describe("The conversation ID"),
-    includeMessages: z.boolean().optional().describe("Include message history (default false)"),
-    messageLimit: z.number().optional().describe("Number of messages to include (default 50)")
-  },
-  async ({ conversationId, includeMessages, messageLimit }) => {
-    try {
-      return ok(
-        await api("GET", `/conversations/${conversationId}`, void 0, {
-          include_messages: includeMessages ? "true" : void 0,
-          message_limit: messageLimit?.toString()
-        })
-      );
-    } catch (e) {
-      return err(e);
-    }
-  }
-);
-server.tool(
-  "reply_to_conversation",
-  "Send a reply within an existing conversation. The recipient is automatically set from the conversation's phone number.",
-  {
-    conversationId: z.string().describe("The conversation ID to reply in"),
-    text: z.string().describe("Reply message text"),
-    mediaUrls: z.array(z.string()).optional().describe("Media URLs for MMS")
-  },
-  async ({ conversationId, text, mediaUrls }) => {
-    try {
-      const body = { text };
-      if (mediaUrls?.length) body.mediaUrls = mediaUrls;
-      return ok(
-        await api("POST", `/conversations/${conversationId}/messages`, body)
-      );
-    } catch (e) {
-      return err(e);
-    }
-  }
-);
-server.tool(
-  "update_conversation",
-  "Update a conversation's metadata or tags. Use metadata for custom key-value data, tags for categorization.",
-  {
-    conversationId: z.string().describe("The conversation ID"),
-    metadata: z.record(z.string(), z.any()).optional().describe("Custom key-value metadata"),
-    tags: z.array(z.string()).optional().describe("Tags for categorization (replaces existing tags)")
-  },
-  async ({ conversationId, metadata, tags }) => {
-    try {
-      const body = {};
-      if (metadata) body.metadata = metadata;
-      if (tags) body.tags = tags;
-      return ok(await api("PATCH", `/conversations/${conversationId}`, body));
-    } catch (e) {
-      return err(e);
-    }
-  }
-);
-server.tool(
-  "close_conversation",
-  "Close a conversation. Closed conversations auto-reopen when a new inbound message arrives.",
-  {
-    conversationId: z.string().describe("The conversation ID to close")
-  },
-  async ({ conversationId }) => {
-    try {
-      return ok(await api("POST", `/conversations/${conversationId}/close`));
-    } catch (e) {
-      return err(e);
-    }
-  }
-);
-server.tool(
-  "reopen_conversation",
-  "Reopen a previously closed conversation, setting its status back to active.",
-  {
-    conversationId: z.string().describe("The conversation ID to reopen")
-  },
-  async ({ conversationId }) => {
-    try {
-      return ok(await api("POST", `/conversations/${conversationId}/reopen`));
-    } catch (e) {
-      return err(e);
-    }
-  }
-);
-server.tool(
-  "mark_conversation_read",
-  "Mark a conversation as read, resetting the unread count to zero.",
-  {
-    conversationId: z.string().describe("The conversation ID")
-  },
-  async ({ conversationId }) => {
-    try {
-      return ok(
-        await api("POST", `/conversations/${conversationId}/mark-read`)
-      );
-    } catch (e) {
-      return err(e);
-    }
-  }
-);
-server.tool(
-  "get_suggested_replies",
-  "Get AI-generated reply suggestions for a conversation based on message history and context. Returns 2-3 suggested responses with different tones (professional, friendly, concise).",
-  {
-    conversationId: z.string().describe("The conversation ID to generate suggestions for")
-  },
-  async ({ conversationId }) => {
-    try {
-      return ok(
-        await api("POST", `/conversations/${conversationId}/suggest-replies`)
-      );
-    } catch (e) {
-      return err(e);
-    }
-  }
-);
-server.tool(
-  "create_label",
-  "Create a label for categorizing conversations and messages. Labels have a name and optional color.",
-  {
-    name: z.string().describe("Label name (e.g., 'urgent', 'vip', 'follow-up')"),
-    color: z.string().optional().describe("Hex color code (default: #6b7280)"),
-    description: z.string().optional().describe("Label description")
-  },
-  async ({ name, color, description }) => {
-    try {
-      const body = { name };
-      if (color) body.color = color;
-      if (description) body.description = description;
-      return ok(await api("POST", "/labels", body));
-    } catch (e) {
-      return err(e);
-    }
-  }
-);
-server.tool(
-  "list_labels",
-  "List all labels available in your workspace.",
-  {},
-  async () => {
-    try {
-      return ok(await api("GET", "/labels"));
-    } catch (e) {
-      return err(e);
-    }
-  }
-);
-server.tool(
-  "add_conversation_label",
-  "Add one or more labels to a conversation for categorization.",
-  {
-    conversationId: z.string().describe("The conversation ID"),
-    labelIds: z.array(z.string()).describe("Array of label IDs to add")
-  },
-  async ({ conversationId, labelIds }) => {
-    try {
-      return ok(
-        await api("POST", `/conversations/${conversationId}/labels`, {
-          labelIds
-        })
-      );
-    } catch (e) {
-      return err(e);
-    }
-  }
-);
-server.tool(
-  "remove_conversation_label",
-  "Remove a label from a conversation.",
-  {
-    conversationId: z.string().describe("The conversation ID"),
-    labelId: z.string().describe("The label ID to remove")
-  },
-  async ({ conversationId, labelId }) => {
-    try {
-      return ok(
-        await api("DELETE", `/conversations/${conversationId}/labels/${labelId}`)
-      );
-    } catch (e) {
-      return err(e);
-    }
-  }
-);
-server.tool(
-  "create_draft",
-  "Create a message draft for human review before sending. The draft must be approved before it becomes a real SMS.",
-  {
-    conversationId: z.string().describe("The conversation ID"),
-    text: z.string().describe("Draft message text"),
-    source: z.string().optional().describe("Source of the draft (default: 'ai')")
-  },
-  async ({ conversationId, text, source }) => {
-    try {
-      const body = { conversationId, text };
-      if (source) body.source = source;
-      return ok(await api("POST", "/drafts", body));
-    } catch (e) {
-      return err(e);
-    }
-  }
-);
-server.tool(
-  "list_drafts",
-  "List message drafts, optionally filtered by conversation or status.",
-  {
-    conversationId: z.string().optional().describe("Filter by conversation ID"),
-    status: z.enum(["pending", "approved", "rejected", "sent", "failed"]).optional().describe("Filter by status")
-  },
-  async ({ conversationId, status }) => {
-    try {
-      return ok(
-        await api("GET", "/drafts", void 0, {
-          conversation_id: conversationId,
-          status
-        })
-      );
-    } catch (e) {
-      return err(e);
-    }
-  }
-);
-server.tool(
-  "approve_draft",
-  "Approve a pending draft and send it as a real SMS message. Runs compliance checks and deducts credits at approval time.",
-  {
-    draftId: z.string().describe("The draft ID to approve")
-  },
-  async ({ draftId }) => {
-    try {
-      return ok(await api("POST", `/drafts/${draftId}/approve`));
-    } catch (e) {
-      return err(e);
-    }
-  }
-);
-server.tool(
-  "reject_draft",
-  "Reject a pending draft with an optional reason. The message will not be sent.",
-  {
-    draftId: z.string().describe("The draft ID to reject"),
-    reason: z.string().optional().describe("Reason for rejection")
-  },
-  async ({ draftId, reason }) => {
-    try {
-      const body = {};
-      if (reason) body.reason = reason;
-      return ok(await api("POST", `/drafts/${draftId}/reject`, body));
-    } catch (e) {
-      return err(e);
-    }
-  }
-);
-server.tool(
-  "send_otp",
-  "Send an OTP verification code via SMS. Use for phone verification, 2FA, or identity confirmation. Returns a verification ID to check the code against. In sandbox mode (test API key), the code is returned in the response for testing.",
-  {
-    to: z.string().describe("Phone number to verify in E.164 format"),
-    appName: z.string().optional().describe("Your app/brand name shown in the SMS"),
-    codeLength: z.number().optional().describe("Digits in the code (default 6)"),
-    timeoutSecs: z.number().optional().describe("Code validity in seconds (default 300)")
-  },
-  async ({ to, appName, codeLength, timeoutSecs }) => {
-    try {
-      const body = { to };
-      if (appName) body.appName = appName;
-      if (codeLength) body.codeLength = codeLength;
-      if (timeoutSecs) body.timeoutSecs = timeoutSecs;
-      return ok(await api("POST", "/verify", body));
-    } catch (e) {
-      return err(e);
-    }
-  }
-);
-server.tool(
-  "check_otp",
-  "Verify an OTP code. Returns the verification status: 'verified' (correct), 'invalid_code' (wrong code, shows remaining attempts), 'expired', or 'max_attempts_exceeded'.",
-  {
-    verificationId: z.string().describe("The verification ID from send_otp"),
-    code: z.string().describe("The code entered by the user")
-  },
-  async ({ verificationId, code }) => {
-    try {
-      return ok(await api("POST", `/verify/${verificationId}/check`, { code }));
-    } catch (e) {
-      return err(e);
-    }
-  }
-);
-server.tool(
-  "get_verification_status",
-  "Check the current status of an OTP verification (pending, verified, expired, failed).",
-  {
-    verificationId: z.string().describe("The verification ID")
-  },
-  async ({ verificationId }) => {
-    try {
-      return ok(await api("GET", `/verify/${verificationId}`));
-    } catch (e) {
-      return err(e);
-    }
-  }
-);
-server.tool(
-  "get_account",
-  "Get account info: credit balance, phone number verification status, rate limits, and API key details. Check this to understand available credits and sending capabilities.",
-  {},
-  async () => {
-    try {
-      return ok(await api("GET", "/account"));
-    } catch (e) {
-      return err(e);
-    }
-  }
-);
-server.tool(
-  "generate_business_page",
-  "Generate a hosted business landing page for verification. Use when a business doesn't have their own website. Returns a URL at sendly.live/biz/{slug} that satisfies carrier website requirements.",
-  {
-    businessName: z.string().describe("Business name"),
-    useCase: z.string().optional().describe("Use case (e.g., Insurance Services, Appointment Reminders, 2FA)"),
-    useCaseSummary: z.string().optional().describe("Brief description of what the business does"),
-    contactEmail: z.string().optional().describe("Business contact email"),
-    contactPhone: z.string().optional().describe("Business phone number"),
-    businessAddress: z.string().optional().describe("City, State ZIP (e.g., Chicago, IL 60601)")
-  },
-  async (params) => {
-    try {
-      return ok(
-        await api("POST", "/enterprise/business-page/generate", params)
-      );
-    } catch (e) {
-      return err(e);
-    }
-  }
-);
+registerAllTools(server, api);
 var transport = new StdioServerTransport();
 await server.connect(transport);