@buzzposter/mcp 0.1.12 → 0.1.14

package/dist/tools.js

@@ -95,23 +95,6 @@ var BuzzPosterClient = class {
     });
   }
   // Media
-  async uploadMediaMultipart(filename, buffer, mimeType) {
-    const formData = new FormData();
-    formData.append("file", new Blob([buffer], { type: mimeType }), filename);
-    const url = new URL(`${this.baseUrl}/api/v1/media/upload`);
-    const res = await fetch(url, {
-      method: "POST",
-      headers: { Authorization: `Bearer ${this.apiKey}` },
-      body: formData
-    });
-    if (!res.ok) {
-      const errorBody = await res.json().catch(() => ({ message: res.statusText }));
-      const message = typeof errorBody === "object" && errorBody !== null && "message" in errorBody ? String(errorBody.message) : `API error (${res.status})`;
-      throw new Error(`BuzzPoster API error (${res.status}): ${message}`);
-    }
-    const text = await res.text();
-    return text ? JSON.parse(text) : void 0;
-  }
   async uploadFromUrl(data) {
     return this.request("POST", "/api/v1/media/upload-from-url", data);
   }
@@ -262,6 +245,12 @@ var BuzzPosterClient = class {
   async updateAudience(id, data) {
     return this.request("PUT", `/api/v1/audiences/${id}`, data);
   }
+  async listAudiences() {
+    return this.request("GET", "/api/v1/audiences");
+  }
+  async deleteAudience(id) {
+    return this.request("DELETE", `/api/v1/audiences/${id}`);
+  }
   // Newsletter Templates
   async getTemplate(id) {
     if (id) return this.request("GET", `/api/v1/templates/${id}`);
@@ -270,6 +259,18 @@ var BuzzPosterClient = class {
   async listTemplates() {
     return this.request("GET", "/api/v1/templates");
   }
+  async createTemplate(data) {
+    return this.request("POST", "/api/v1/templates", data);
+  }
+  async updateTemplate(id, data) {
+    return this.request("PUT", "/api/v1/templates/" + id, data);
+  }
+  async deleteTemplate(id) {
+    return this.request("DELETE", "/api/v1/templates/" + id);
+  }
+  async duplicateTemplate(id) {
+    return this.request("POST", "/api/v1/templates/" + id + "/duplicate");
+  }
   // Newsletter Archive
   async listNewsletterArchive(params) {
     return this.request("GET", "/api/v1/newsletter-archive", void 0, params);
@@ -373,6 +374,92 @@ var BuzzPosterClient = class {
   async previewCarousel(data) {
     return this.request("POST", "/api/v1/carousel-templates/preview", data);
   }
+  // Canva
+  async getCanvaStatus() {
+    return this.request("GET", "/api/v1/canva/status");
+  }
+  async canvaUploadAsset(data) {
+    return this.request("POST", "/api/v1/canva/upload-asset", data);
+  }
+  async canvaCreateDesign(data) {
+    return this.request("POST", "/api/v1/canva/designs", data);
+  }
+  async canvaExportDesign(data) {
+    return this.request("POST", "/api/v1/canva/exports", data);
+  }
+  async canvaSearchDesigns(query) {
+    return this.request("GET", "/api/v1/canva/designs", void 0, { query });
+  }
+  async canvaGetDesign(designId) {
+    return this.request("GET", `/api/v1/canva/designs/${designId}`);
+  }
+  // SendGrid Newsletter (BuzzPoster-managed)
+  async sgListLists() {
+    return this.request("GET", "/api/v1/newsletter/lists");
+  }
+  async sgCreateList(data) {
+    return this.request("POST", "/api/v1/newsletter/lists", data);
+  }
+  async sgUpdateList(id, data) {
+    return this.request("PUT", `/api/v1/newsletter/lists/${id}`, data);
+  }
+  async sgDeleteList(id) {
+    return this.request("DELETE", `/api/v1/newsletter/lists/${id}`);
+  }
+  async sgListSubscribers(params) {
+    return this.request("GET", "/api/v1/newsletter/subscribers", void 0, params);
+  }
+  async sgAddSubscriber(data) {
+    return this.request("POST", "/api/v1/newsletter/subscribers", data);
+  }
+  async sgGetSubscriber(id) {
+    return this.request("GET", `/api/v1/newsletter/subscribers/${id}`);
+  }
+  async sgUpdateSubscriber(id, data) {
+    return this.request("PUT", `/api/v1/newsletter/subscribers/${id}`, data);
+  }
+  async sgRemoveSubscriber(id) {
+    return this.request("DELETE", `/api/v1/newsletter/subscribers/${id}`);
+  }
+  async sgBulkImportSubscribers(data) {
+    return this.request("POST", "/api/v1/newsletter/subscribers/bulk", data);
+  }
+  async sgListSends(params) {
+    return this.request("GET", "/api/v1/newsletter/sends", void 0, params);
+  }
+  async sgGetSend(id) {
+    return this.request("GET", `/api/v1/newsletter/sends/${id}`);
+  }
+  async sgCreateSend(data) {
+    return this.request("POST", "/api/v1/newsletter/sends", data);
+  }
+  async sgUpdateSend(id, data) {
+    return this.request("PUT", `/api/v1/newsletter/sends/${id}`, data);
+  }
+  async sgDeleteSend(id) {
+    return this.request("DELETE", `/api/v1/newsletter/sends/${id}`);
+  }
+  async sgSendNewsletter(id) {
+    return this.request("POST", `/api/v1/newsletter/sends/${id}/send`);
+  }
+  async sgTestSend(id, data) {
+    return this.request("POST", `/api/v1/newsletter/sends/${id}/test`, data);
+  }
+  async sgScheduleSend(id, data) {
+    return this.request("POST", `/api/v1/newsletter/sends/${id}/schedule`, data);
+  }
+  async sgCancelSend(id) {
+    return this.request("POST", `/api/v1/newsletter/sends/${id}/cancel`);
+  }
+  async sgAuthenticateDomain(domain) {
+    return this.request("POST", "/api/v1/newsletter/domains/authenticate", { domain });
+  }
+  async sgValidateDomain(domainId) {
+    return this.request("POST", `/api/v1/newsletter/domains/${domainId}/validate`);
+  }
+  async sgListDomains() {
+    return this.request("GET", "/api/v1/newsletter/domains");
+  }
 };
 
 // src/tools/posts.ts
@@ -1155,44 +1242,7 @@ This will post a public reply to the review. Call this tool again with confirmed
 
 // src/tools/media.ts
 import { z as z4 } from "zod";
-import { readFile } from "fs/promises";
 function registerMediaTools(server, client) {
-  server.tool(
-    "upload_media",
-    "Upload an image or video file from a local file path. Returns a CDN URL that can be used in posts.",
-    {
-      file_path: z4.string().describe("Absolute path to the file on the local filesystem")
-    },
-    {
-      title: "Upload Media File",
-      readOnlyHint: false,
-      destructiveHint: false,
-      idempotentHint: false,
-      openWorldHint: false
-    },
-    async (args) => {
-      const buffer = Buffer.from(await readFile(args.file_path));
-      const filename = args.file_path.split("/").pop() ?? "upload";
-      const ext = filename.split(".").pop()?.toLowerCase() ?? "";
-      const mimeMap = {
-        jpg: "image/jpeg",
-        jpeg: "image/jpeg",
-        png: "image/png",
-        gif: "image/gif",
-        webp: "image/webp",
-        mp4: "video/mp4",
-        mov: "video/quicktime",
-        avi: "video/x-msvideo",
-        webm: "video/webm",
-        pdf: "application/pdf"
-      };
-      const mimeType = mimeMap[ext] ?? "application/octet-stream";
-      const result = await client.uploadMediaMultipart(filename, buffer, mimeType);
-      return {
-        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
-      };
-    }
-  );
   server.tool(
     "upload_from_url",
     "Upload media from a public URL. The server fetches the image/video and uploads it to storage. Returns a CDN URL that can be used in posts. Supports JPEG, PNG, GIF, WebP, MP4, MOV, WebM up to 25MB.",
@@ -1214,8 +1264,12 @@ function registerMediaTools(server, client) {
         filename: args.filename,
         folder: args.folder
       });
+      const item = result;
       return {
-        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        content: [
+          { type: "text", text: JSON.stringify(result, null, 2) },
+          ...item.type === "image" && item.url && item.mimeType && !item.mimeType.startsWith("video/") ? [{ type: "image", url: item.url, mimeType: item.mimeType }] : []
+        ]
       };
     }
   );
@@ -1256,8 +1310,13 @@ function registerMediaTools(server, client) {
     },
     async () => {
       const result = await client.listMedia();
+      const media = Array.isArray(result) ? result : result?.media ?? [];
+      const imageBlocks = media.filter((m) => m.type === "image" && m.url && m.mimeType && !m.mimeType.startsWith("video/")).map((m) => ({ type: "image", url: m.url, mimeType: m.mimeType }));
       return {
-        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        content: [
+          { type: "text", text: JSON.stringify(result, null, 2) },
+          ...imageBlocks
+        ]
       };
     }
   );
@@ -1372,7 +1431,11 @@ function registerNewsletterTools(server, client, options = {}) {
         previewText: args.preview_text
       });
       return {
-        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        content: [
+          { type: "text", text: JSON.stringify(result, null, 2) },
+          ...args.content ? [{ type: "text", text: `NEWSLETTER_HTML_PREVIEW:
+${args.content}` }] : []
+        ]
       };
     }
   );
@@ -1399,7 +1462,11 @@ function registerNewsletterTools(server, client, options = {}) {
       if (args.preview_text) data.previewText = args.preview_text;
       const result = await client.updateBroadcast(args.broadcast_id, data);
       return {
-        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        content: [
+          { type: "text", text: JSON.stringify(result, null, 2) },
+          ...args.content ? [{ type: "text", text: `NEWSLETTER_HTML_PREVIEW:
+${args.content}` }] : []
+        ]
       };
     }
   );
@@ -1574,9 +1641,13 @@ Call this tool again with confirmed=true to schedule.`;
   );
   server.tool(
     "list_newsletters",
-    "List all newsletters/broadcasts with their status.",
+    "List all newsletters/broadcasts with their id, subject, status (draft, sent, or scheduled), createdAt, and sentAt. Supports filtering by status, date range, and subject keyword search.",
     {
-      page: z5.string().optional().describe("Page number for pagination")
+      page: z5.string().optional().describe("Page number for pagination"),
+      status: z5.enum(["draft", "sent", "scheduled"]).optional().describe("Filter by status: draft, sent, or scheduled"),
+      from_date: z5.string().optional().describe("ISO date to filter from, e.g. 2024-01-01"),
+      to_date: z5.string().optional().describe("ISO date to filter to, e.g. 2024-01-31"),
+      subject: z5.string().optional().describe("Keyword to search in subject lines (case-insensitive)")
     },
     {
       title: "List Newsletters",
@@ -1588,9 +1659,31 @@ Call this tool again with confirmed=true to schedule.`;
     async (args) => {
       const params = {};
       if (args.page) params.page = args.page;
+      if (args.status) params.status = args.status;
+      if (args.from_date) params.fromDate = args.from_date;
+      if (args.to_date) params.toDate = args.to_date;
+      if (args.subject) params.subject = args.subject;
       const result = await client.listBroadcasts(params);
+      const broadcasts = result?.broadcasts ?? [];
+      if (broadcasts.length === 0) {
+        return {
+          content: [{ type: "text", text: "No newsletters found matching your filters." }]
+        };
+      }
+      let text = `## Newsletters (${broadcasts.length}`;
+      if (result?.totalCount != null) text += ` of ${result.totalCount}`;
+      text += ")\n\n";
+      for (const b of broadcasts) {
+        const status = (b.status ?? "unknown").toUpperCase();
+        const date = b.sentAt ? new Date(b.sentAt).toLocaleString() : b.createdAt ? new Date(b.createdAt).toLocaleString() : "";
+        text += `- **[${status}]** "${b.subject ?? "(no subject)"}"
+`;
+        text += `  ID: ${b.id}`;
+        if (date) text += ` | ${b.sentAt ? "Sent" : "Created"}: ${date}`;
+        text += "\n";
+      }
       return {
-        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        content: [{ type: "text", text }]
       };
     }
   );
@@ -3040,6 +3133,89 @@ USAGE GUIDELINES:
       };
     }
   );
+  server.tool(
+    "delete_audience",
+    `Permanently delete a target audience profile by ID. This action cannot be undone.
+
+REQUIRED WORKFLOW:
+1. ALWAYS call with confirmed=false first to preview which audience will be deleted
+2. Show the user the audience name and details
+3. Only call again with confirmed=true after explicit user approval
+
+SAFETY: Cannot delete the default audience if it is the only audience profile. The customer must create another audience first.`,
+    {
+      audience_id: z10.string().describe("The ID of the audience profile to delete"),
+      confirmed: z10.boolean().default(false).describe(
+        "Set to true to confirm deletion after previewing. If false or missing, returns a preview for user approval."
+      )
+    },
+    {
+      title: "Delete Audience Profile",
+      readOnlyHint: false,
+      destructiveHint: true,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    async (args) => {
+      let audience;
+      try {
+        audience = await client.getAudience(args.audience_id);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        if (message.includes("404") || message.includes("not found")) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Audience with ID ${args.audience_id} not found.`
+              }
+            ],
+            isError: true
+          };
+        }
+        throw error;
+      }
+      if (audience.isDefault) {
+        const allAudiences = await client.listAudiences();
+        if (allAudiences.length <= 1) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Cannot delete "${audience.name}" because it is the only audience profile. Create another audience before deleting this one.`
+              }
+            ],
+            isError: true
+          };
+        }
+      }
+      if (args.confirmed !== true) {
+        const lines = [];
+        lines.push("## Delete Audience Confirmation");
+        lines.push("");
+        lines.push(`**Name:** ${audience.name}`);
+        lines.push(`**ID:** ${audience.id}`);
+        if (audience.isDefault) lines.push("**Default:** Yes");
+        if (audience.description) lines.push(`**Description:** ${audience.description}`);
+        lines.push("");
+        lines.push(
+          "**This action is permanent and cannot be undone.** Call this tool again with confirmed=true to proceed."
+        );
+        return {
+          content: [{ type: "text", text: lines.join("\n") }]
+        };
+      }
+      await client.deleteAudience(args.audience_id);
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Audience "${audience.name}" (ID: ${audience.id}) has been permanently deleted.`
+          }
+        ]
+      };
+    }
+  );
 }
 
 // src/tools/newsletter-template.ts
@@ -3178,6 +3354,15 @@ function registerNewsletterTemplateTools(server, client) {
           );
           lines.push("");
         }
+        if (template.htmlContent) {
+          lines.push("### HTML Template:");
+          lines.push("The following HTML skeleton contains {{placeholder}} variables. Fill in the placeholders with real content when generating the newsletter.");
+          lines.push("");
+          lines.push("```html");
+          lines.push(template.htmlContent);
+          lines.push("```");
+          lines.push("");
+        }
         if (template.rssFeedUrls && template.rssFeedUrls.length > 0) {
           lines.push("### Linked RSS Feeds:");
           for (const url of template.rssFeedUrls) {
@@ -3268,8 +3453,13 @@ function registerNewsletterTemplateTools(server, client) {
           );
           lines.push("");
         }
+        const mostRecent = newsletters[0];
         return {
-          content: [{ type: "text", text: lines.join("\n") }]
+          content: [
+            { type: "text", text: lines.join("\n") },
+            ...mostRecent?.contentHtml ? [{ type: "text", text: `NEWSLETTER_HTML_PREVIEW:
+${mostRecent.contentHtml}` }] : []
+          ]
         };
       } catch (error) {
         const message = error instanceof Error ? error.message : "Unknown error";
@@ -3303,7 +3493,11 @@ function registerNewsletterTemplateTools(server, client) {
         lines.push("### Full HTML Content:");
         lines.push(newsletter.contentHtml);
         return {
-          content: [{ type: "text", text: lines.join("\n") }]
+          content: [
+            { type: "text", text: lines.join("\n") },
+            ...newsletter.contentHtml ? [{ type: "text", text: `NEWSLETTER_HTML_PREVIEW:
+${newsletter.contentHtml}` }] : []
+          ]
         };
       } catch (error) {
         const message = error instanceof Error ? error.message : "Unknown error";
@@ -3353,7 +3547,9 @@ function registerNewsletterTemplateTools(server, client) {
             {
               type: "text",
               text: `Newsletter "${subject}" has been saved to the archive successfully.`
-            }
+            },
+            ...contentHtml ? [{ type: "text", text: `NEWSLETTER_HTML_PREVIEW:
+${contentHtml}` }] : []
           ]
         };
       } catch (error) {
@@ -3362,6 +3558,210 @@ function registerNewsletterTemplateTools(server, client) {
       }
     }
   );
+  server.tool(
+    "save_newsletter_template",
+    "Save or update a newsletter HTML template. The template contains the HTML skeleton with {{placeholder}} variables that Claude fills in when generating newsletters. If template_id is provided, updates the existing template. Otherwise creates a new one.",
+    {
+      template_id: z11.string().optional().describe(
+        "If provided, updates this existing template. Otherwise creates a new one."
+      ),
+      name: z11.string().min(1).max(255).describe("Template name, e.g. 'BOQtoday Daily'"),
+      description: z11.string().max(2e3).optional().describe(
+        "What this template is for, e.g. 'Local news digest with 6 stories, events, pet of the week'"
+      ),
+      html_content: z11.string().min(1).describe(
+        "Full HTML template with {{placeholder}} variables. This is the email body HTML with inline styles."
+      ),
+      sections: z11.array(
+        z11.object({
+          name: z11.string().describe("Section identifier, e.g. 'intro'"),
+          label: z11.string().describe("Display label, e.g. 'Intro/Greeting'"),
+          required: z11.boolean().optional().describe("Whether this section is required"),
+          item_count: z11.number().optional().describe("Number of items in this section, if applicable")
+        })
+      ).optional().describe("Array of section metadata describing the template structure"),
+      style_config: z11.object({
+        primary_color: z11.string().optional(),
+        accent_color: z11.string().optional(),
+        link_color: z11.string().optional(),
+        background_color: z11.string().optional(),
+        font_family: z11.string().optional(),
+        max_width: z11.string().optional()
+      }).optional().describe("Colors, fonts, and brand configuration"),
+      is_default: z11.boolean().optional().describe(
+        "Set as the default template for this customer. Only one default per customer."
+      )
+    },
+    {
+      title: "Save Newsletter Template",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: false
+    },
+    async ({
+      template_id,
+      name,
+      description,
+      html_content,
+      sections,
+      style_config,
+      is_default
+    }) => {
+      try {
+        const data = {
+          name,
+          htmlContent: html_content
+        };
+        if (description !== void 0) data.description = description;
+        if (sections !== void 0) {
+          data.sections = sections.map((s) => ({
+            id: s.name,
+            type: "custom",
+            label: s.label,
+            required: s.required ?? true,
+            count: s.item_count
+          }));
+        }
+        if (style_config !== void 0) {
+          data.style = {
+            primary_color: style_config.primary_color,
+            accent_color: style_config.accent_color,
+            link_color: style_config.link_color,
+            background_color: style_config.background_color,
+            font_family: style_config.font_family,
+            content_width: style_config.max_width
+          };
+        }
+        if (is_default !== void 0) data.isDefault = is_default;
+        let result;
+        if (template_id) {
+          result = await client.updateTemplate(
+            template_id,
+            data
+          );
+        } else {
+          result = await client.createTemplate(data);
+        }
+        const action = template_id ? "updated" : "created";
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Newsletter template "${result.name}" ${action} successfully (ID: ${result.id}).${result.isDefault ? " Set as default." : ""}`
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        throw new Error(`Failed to save newsletter template: ${message}`);
+      }
+    }
+  );
+  server.tool(
+    "list_newsletter_templates",
+    "List all saved newsletter templates for this customer. Returns template names, descriptions, whether they have HTML content, and which one is the default.",
+    {},
+    {
+      title: "List Newsletter Templates",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    async () => {
+      try {
+        const templates = await client.listTemplates();
+        if (!templates || templates.length === 0) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "No newsletter templates found. Use save_newsletter_template to create one."
+              }
+            ]
+          };
+        }
+        const lines = [];
+        lines.push(`## Newsletter Templates (${templates.length})`);
+        lines.push("");
+        for (const t of templates) {
+          const badges = [];
+          if (t.isDefault) badges.push("DEFAULT");
+          if (t.htmlContent) badges.push("HAS HTML");
+          const badgeStr = badges.length > 0 ? ` [${badges.join(", ")}]` : "";
+          lines.push(`**${t.name}** (ID: ${t.id})${badgeStr}`);
+          if (t.description) lines.push(`  ${t.description}`);
+          if (t.sections && t.sections.length > 0) {
+            lines.push(
+              `  Sections: ${t.sections.map((s) => s.label).join(", ")}`
+            );
+          }
+          lines.push("");
+        }
+        return {
+          content: [{ type: "text", text: lines.join("\n") }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        throw new Error(`Failed to list newsletter templates: ${message}`);
+      }
+    }
+  );
+  server.tool(
+    "delete_newsletter_template",
+    "Delete a newsletter template. Requires confirmation -- set confirmed=true to proceed with deletion.",
+    {
+      template_id: z11.string().describe("The ID of the newsletter template to delete."),
+      confirmed: z11.boolean().default(false).describe(
+        "Must be true to actually delete. If false, returns a confirmation prompt."
+      )
+    },
+    {
+      title: "Delete Newsletter Template",
+      readOnlyHint: false,
+      destructiveHint: true,
+      idempotentHint: false,
+      openWorldHint: false
+    },
+    async ({ template_id, confirmed }) => {
+      try {
+        if (!confirmed) {
+          const template = await client.getTemplate(template_id);
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Are you sure you want to delete the template "${template.name}" (ID: ${template.id})? This action cannot be undone. Call delete_newsletter_template again with confirmed=true to proceed.`
+              }
+            ]
+          };
+        }
+        await client.deleteTemplate(template_id);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Newsletter template (ID: ${template_id}) has been deleted.`
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        if (message.includes("404")) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Template not found. It may have already been deleted."
+              }
+            ]
+          };
+        }
+        throw new Error(`Failed to delete newsletter template: ${message}`);
+      }
+    }
+  );
 }
 
 // src/tools/calendar.ts
@@ -3486,7 +3886,8 @@ function registerCalendarTools(server, client) {
         for (const slot of slots) {
           const day = dayNames[slot.dayOfWeek] ?? `Day ${slot.dayOfWeek}`;
           const platforms = (slot.platforms ?? []).map((p) => `[${p}]`).join(" ");
-          text += `${day}: ${slot.time} ${platforms}
+          const slotId = slot.id ?? slot._id ?? `${slot.dayOfWeek}_${slot.time}`;
+          text += `${day}: ${slot.time} ${platforms} (id: ${slotId})
 `;
         }
       }
@@ -3507,7 +3908,9 @@ Next slot: ${slotDate.toLocaleString()} (${dayNames[slotDate.getDay()]})
   );
   server.tool(
     "schedule_to_queue",
-    `Add a post to the customer's content queue for automatic scheduling.
+    `Before calling this tool, always check get_queue first. If the queue is inactive or has no time slots configured, warn the user and do not attempt to schedule.
+
+Add a post to the customer's content queue for automatic scheduling.
 
 Always show the user a preview of the content before calling this tool. Call get_brand_voice and get_audience before composing if not already loaded this session. Never call with confirmed=true without explicit user approval.
 
@@ -4238,6 +4641,1236 @@ USAGE:
     }
   );
 }
+
+// src/tools/queue.ts
+import { z as z17 } from "zod";
+var DAY_NAMES = [
+  "sunday",
+  "monday",
+  "tuesday",
+  "wednesday",
+  "thursday",
+  "friday",
+  "saturday"
+];
+var DAY_ENUM = z17.enum([
+  "monday",
+  "tuesday",
+  "wednesday",
+  "thursday",
+  "friday",
+  "saturday",
+  "sunday"
+]);
+function dayNameToNumber(name) {
+  const idx = DAY_NAMES.indexOf(name.toLowerCase());
+  return idx === -1 ? 0 : idx;
+}
+function dayNumberToName(num) {
+  return (DAY_NAMES[num] ?? "sunday").charAt(0).toUpperCase() + (DAY_NAMES[num] ?? "sunday").slice(1);
+}
+function getSlotId(slot) {
+  if (slot.id) return String(slot.id);
+  if (slot._id) return String(slot._id);
+  return `${slot.dayOfWeek}_${slot.time}`;
+}
+function formatSlot(slot) {
+  const day = dayNumberToName(slot.dayOfWeek);
+  const platforms = (slot.platforms ?? []).join(", ");
+  return `${day} ${slot.time} [${platforms}]`;
+}
+function registerQueueTools(server, client) {
+  server.tool(
+    "create_queue_slot",
+    "Create a new recurring time slot in the posting queue. Each slot fires once per week at the specified day and time. Use get_queue first to see existing slots and avoid duplicates.",
+    {
+      day_of_week: DAY_ENUM.describe("Day of the week for this slot"),
+      time: z17.string().regex(/^\d{2}:\d{2}$/, "Must be HH:MM format (24-hour)").describe("Time in HH:MM 24-hour format, e.g. '09:00' or '14:30'"),
+      timezone: z17.string().default("UTC").describe("IANA timezone, e.g. 'America/New_York'. Defaults to UTC."),
+      platforms: z17.array(z17.string()).min(1).describe('Platforms for this slot, e.g. ["twitter", "linkedin"]'),
+      confirmed: z17.boolean().default(false).describe(
+        "Set to true to confirm creation. If false, returns a preview."
+      )
+    },
+    {
+      title: "Create Queue Slot",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: true
+    },
+    async (args) => {
+      const dayNum = dayNameToNumber(args.day_of_week);
+      if (args.confirmed !== true) {
+        let text = "## Create Queue Slot Preview\n\n";
+        text += `**Day:** ${dayNumberToName(dayNum)}
+`;
+        text += `**Time:** ${args.time}
+`;
+        text += `**Timezone:** ${args.timezone}
+`;
+        text += `**Platforms:** ${args.platforms.join(", ")}
+
+`;
+        try {
+          const data2 = await client.getQueue();
+          const slots = data2?.slots ?? [];
+          if (slots.length > 0) {
+            text += "### Existing slots\n";
+            for (const slot of slots) {
+              text += `- ${formatSlot(slot)}
+`;
+            }
+            text += "\n";
+          }
+        } catch {
+        }
+        text += "Call this tool again with confirmed=true to create the slot.";
+        return { content: [{ type: "text", text }] };
+      }
+      const data = await client.getQueue();
+      const existingSlots = data?.slots ?? [];
+      const duplicate = existingSlots.find(
+        (s) => s.dayOfWeek === dayNum && s.time === args.time
+      );
+      if (duplicate) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `A slot already exists for ${dayNumberToName(dayNum)} at ${args.time}. Use update_queue_slot to modify it.`
+            }
+          ]
+        };
+      }
+      const updatedSlots = [
+        ...existingSlots.map((s) => ({
+          dayOfWeek: s.dayOfWeek,
+          time: s.time,
+          platforms: s.platforms
+        })),
+        {
+          dayOfWeek: dayNum,
+          time: args.time,
+          platforms: args.platforms
+        }
+      ];
+      await client.updateQueue({
+        slots: updatedSlots,
+        active: data?.active,
+        timezone: args.timezone
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Queue slot created: ${dayNumberToName(dayNum)} at ${args.time} for ${args.platforms.join(", ")}. The queue now has ${updatedSlots.length} slot(s).`
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "update_queue_slot",
+    "Update an existing queue slot. Use get_queue first to see slot IDs. Only the fields you provide will be changed; omitted fields keep their current values.",
+    {
+      slot_id: z17.string().describe(
+        "ID of the slot to update (shown by get_queue). Can be the Late API id or a dayOfWeek_time key like '1_09:00'."
+      ),
+      day_of_week: DAY_ENUM.optional().describe("New day of the week"),
+      time: z17.string().regex(/^\d{2}:\d{2}$/, "Must be HH:MM format (24-hour)").optional().describe("New time in HH:MM 24-hour format"),
+      timezone: z17.string().optional().describe("New IANA timezone for the queue"),
+      platforms: z17.array(z17.string()).min(1).optional().describe("New platforms list"),
+      confirmed: z17.boolean().default(false).describe(
+        "Set to true to confirm the update. If false, returns a preview."
+      )
+    },
+    {
+      title: "Update Queue Slot",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true
+    },
+    async (args) => {
+      const data = await client.getQueue();
+      const slots = data?.slots ?? [];
+      const slotIndex = slots.findIndex(
+        (s) => getSlotId(s) === args.slot_id
+      );
+      if (slotIndex === -1) {
+        const available = slots.map((s) => `${getSlotId(s)} (${formatSlot(s)})`).join("\n- ");
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Slot "${args.slot_id}" not found.
+
+Available slots:
+- ${available || "(none)"}`
+            }
+          ]
+        };
+      }
+      const current = slots[slotIndex];
+      const newDay = args.day_of_week !== void 0 ? dayNameToNumber(args.day_of_week) : current.dayOfWeek;
+      const newTime = args.time ?? current.time;
+      const newPlatforms = args.platforms ?? current.platforms;
+      if (args.confirmed !== true) {
+        let text = "## Update Queue Slot Preview\n\n";
+        text += `**Current:** ${formatSlot(current)}
+`;
+        text += `**Updated:** ${dayNumberToName(newDay)} ${newTime} [${(newPlatforms ?? []).join(", ")}]
+`;
+        if (args.timezone) text += `**Timezone:** ${args.timezone}
+`;
+        text += "\nCall this tool again with confirmed=true to apply the update.";
+        return { content: [{ type: "text", text }] };
+      }
+      const updatedSlots = slots.map((s, i) => {
+        if (i === slotIndex) {
+          return {
+            dayOfWeek: newDay,
+            time: newTime,
+            platforms: newPlatforms
+          };
+        }
+        return {
+          dayOfWeek: s.dayOfWeek,
+          time: s.time,
+          platforms: s.platforms
+        };
+      });
+      await client.updateQueue({
+        slots: updatedSlots,
+        active: data?.active,
+        ...args.timezone ? { timezone: args.timezone } : {}
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Slot updated: ${dayNumberToName(newDay)} at ${newTime} for ${(newPlatforms ?? []).join(", ")}.`
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "delete_queue_slot",
+    "Delete a queue slot by ID. Use get_queue first to see slot IDs. This removes the recurring time slot -- any posts already scheduled for this slot are not affected.",
+    {
+      slot_id: z17.string().describe(
+        "ID of the slot to delete (shown by get_queue)."
+      ),
+      confirmed: z17.boolean().default(false).describe(
+        "Set to true to confirm deletion. If false, shows slot details for review."
+      )
+    },
+    {
+      title: "Delete Queue Slot",
+      readOnlyHint: false,
+      destructiveHint: true,
+      idempotentHint: true,
+      openWorldHint: true
+    },
+    async (args) => {
+      const data = await client.getQueue();
+      const slots = data?.slots ?? [];
+      const slotIndex = slots.findIndex(
+        (s) => getSlotId(s) === args.slot_id
+      );
+      if (slotIndex === -1) {
+        const available = slots.map((s) => `${getSlotId(s)} (${formatSlot(s)})`).join("\n- ");
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Slot "${args.slot_id}" not found.
+
+Available slots:
+- ${available || "(none)"}`
+            }
+          ]
+        };
+      }
+      const target = slots[slotIndex];
+      if (args.confirmed !== true) {
+        let text = "## Delete Queue Slot\n\n";
+        text += `**Slot:** ${formatSlot(target)}
+`;
+        text += `**ID:** ${getSlotId(target)}
+
+`;
+        text += `This will remove this recurring time slot. Posts already scheduled are not affected.
+
+`;
+        text += `The queue will have ${slots.length - 1} slot(s) remaining.
+
+`;
+        text += "Call this tool again with confirmed=true to delete.";
+        return { content: [{ type: "text", text }] };
+      }
+      const updatedSlots = slots.filter((_, i) => i !== slotIndex).map((s) => ({
+        dayOfWeek: s.dayOfWeek,
+        time: s.time,
+        platforms: s.platforms
+      }));
+      await client.updateQueue({
+        slots: updatedSlots,
+        active: data?.active
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Slot deleted: ${formatSlot(target)}. The queue now has ${updatedSlots.length} slot(s).`
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "toggle_queue",
+    `Enable or disable the entire posting queue. When disabled, no posts will be auto-scheduled to queue slots. Existing scheduled posts are not affected.
+
+If the user tries to schedule_to_queue while the queue is inactive, warn them and suggest enabling it with this tool first.`,
+    {
+      active: z17.boolean().describe("true to enable the queue, false to disable it"),
+      confirmed: z17.boolean().default(false).describe(
+        "Set to true to confirm the change. If false, returns a preview."
+      )
+    },
+    {
+      title: "Toggle Queue",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true
+    },
+    async (args) => {
+      const data = await client.getQueue();
+      const currentActive = data?.active ?? false;
+      const slots = data?.slots ?? [];
+      if (currentActive === args.active) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `The queue is already ${args.active ? "enabled" : "disabled"}. No change needed.`
+            }
+          ]
+        };
+      }
+      if (args.confirmed !== true) {
+        let text = `## Toggle Queue
+
+`;
+        text += `**Current status:** ${currentActive ? "Enabled" : "Disabled"}
+`;
+        text += `**New status:** ${args.active ? "Enabled" : "Disabled"}
+`;
+        text += `**Slots configured:** ${slots.length}
+
+`;
+        if (args.active && slots.length === 0) {
+          text += "**Warning:** Enabling the queue with no slots configured will have no effect. Create slots first with create_queue_slot.\n\n";
+        }
+        if (!args.active && slots.length > 0) {
+          text += "**Note:** Disabling the queue will stop auto-scheduling. Existing scheduled posts will still go out.\n\n";
+        }
+        text += "Call this tool again with confirmed=true to apply.";
+        return { content: [{ type: "text", text }] };
+      }
+      const updatedSlots = slots.map((s) => ({
+        dayOfWeek: s.dayOfWeek,
+        time: s.time,
+        platforms: s.platforms
+      }));
+      await client.updateQueue({
+        slots: updatedSlots,
+        active: args.active
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Queue ${args.active ? "enabled" : "disabled"} successfully.${args.active && slots.length === 0 ? " Note: no slots are configured yet -- use create_queue_slot to add time slots." : ""}`
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/tools/canva.ts
+import { z as z18 } from "zod";
+var CANVA_NOT_CONNECTED = "Canva is not connected. Visit BuzzPoster settings to connect your Canva account.";
+function isNotConnectedError(error) {
+  if (error instanceof Error) {
+    return error.message.includes("Canva is not connected") || error.message.includes("400");
+  }
+  return false;
+}
+function registerCanvaTools(server, client) {
+  server.tool(
+    "canva_upload_asset",
+    "Upload an image to Canva from a URL. Returns the Canva asset ID and thumbnail URL. Use this to import images into Canva for use in designs.",
+    {
+      image_url: z18.string().url().describe("The URL of the image to upload to Canva."),
+      name: z18.string().min(1).max(255).describe("A name for the uploaded asset.")
+    },
+    {
+      title: "Upload Asset to Canva",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: true
+    },
+    async ({ image_url, name }) => {
+      try {
+        const result = await client.canvaUploadAsset({
+          imageUrl: image_url,
+          name
+        });
+        const lines = [`Asset uploaded to Canva successfully.`];
+        lines.push(`Asset ID: ${result.assetId}`);
+        if (result.thumbnailUrl) {
+          lines.push(`Thumbnail: ${result.thumbnailUrl}`);
+        }
+        return {
+          content: [{ type: "text", text: lines.join("\n") }]
+        };
+      } catch (error) {
+        if (isNotConnectedError(error)) {
+          return {
+            content: [{ type: "text", text: CANVA_NOT_CONNECTED }]
+          };
+        }
+        const message = error instanceof Error ? error.message : "Unknown error";
+        throw new Error(`Failed to upload asset to Canva: ${message}`);
+      }
+    }
+  );
+  server.tool(
+    "canva_create_design",
+    "Create a new Canva design. Returns the design ID and an edit URL the user can open to customize the design in Canva's editor.",
+    {
+      title: z18.string().min(1).max(255).describe("Title for the new design."),
+      design_type: z18.enum([
+        "instagram_post",
+        "facebook_post",
+        "presentation",
+        "poster",
+        "story"
+      ]).describe("The type of design to create, which determines dimensions."),
+      asset_id: z18.string().optional().describe(
+        "Optional Canva asset ID to include in the design."
+      )
+    },
+    {
+      title: "Create Canva Design",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: true
+    },
+    async ({ title, design_type, asset_id }) => {
+      try {
+        const result = await client.canvaCreateDesign({
+          title,
+          designType: design_type,
+          assetId: asset_id
+        });
+        const lines = [`Canva design created successfully.`];
+        lines.push(`Design ID: ${result.designId}`);
+        lines.push(`Edit URL: ${result.editUrl}`);
+        if (result.thumbnailUrl) {
+          lines.push(`Thumbnail: ${result.thumbnailUrl}`);
+        }
+        return {
+          content: [{ type: "text", text: lines.join("\n") }]
+        };
+      } catch (error) {
+        if (isNotConnectedError(error)) {
+          return {
+            content: [{ type: "text", text: CANVA_NOT_CONNECTED }]
+          };
+        }
+        const message = error instanceof Error ? error.message : "Unknown error";
+        throw new Error(`Failed to create Canva design: ${message}`);
+      }
+    }
+  );
+  server.tool(
+    "canva_export_design",
+    "Export a Canva design to a downloadable file. Polls until the export is complete and returns the download URL.",
+    {
+      design_id: z18.string().min(1).describe("The Canva design ID to export."),
+      format: z18.enum(["png", "pdf", "jpg"]).default("png").describe("Export format. Defaults to PNG.")
+    },
+    {
+      title: "Export Canva Design",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true
+    },
+    async ({ design_id, format }) => {
+      try {
+        const result = await client.canvaExportDesign({
+          designId: design_id,
+          format
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Design exported successfully.
+Download URL: ${result.downloadUrl}`
+            }
+          ]
+        };
+      } catch (error) {
+        if (isNotConnectedError(error)) {
+          return {
+            content: [{ type: "text", text: CANVA_NOT_CONNECTED }]
+          };
+        }
+        const message = error instanceof Error ? error.message : "Unknown error";
+        throw new Error(`Failed to export Canva design: ${message}`);
+      }
+    }
+  );
+  server.tool(
+    "canva_search_designs",
+    "Search the customer's Canva designs by keyword. Returns matching designs with their IDs, titles, thumbnails, and edit URLs.",
+    {
+      query: z18.string().min(1).describe("Search keyword to find designs.")
+    },
+    {
+      title: "Search Canva Designs",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true
+    },
+    async ({ query }) => {
+      try {
+        const designs = await client.canvaSearchDesigns(query);
+        if (!designs || designs.length === 0) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `No Canva designs found matching "${query}".`
+              }
+            ]
+          };
+        }
+        const lines = [`## Canva Designs (${designs.length} results)`];
+        lines.push("");
+        for (const d of designs) {
+          lines.push(`**${d.title}** (ID: ${d.id})`);
+          lines.push(`  Edit: ${d.editUrl}`);
+          if (d.thumbnailUrl) lines.push(`  Thumbnail: ${d.thumbnailUrl}`);
+          lines.push("");
+        }
+        return {
+          content: [{ type: "text", text: lines.join("\n") }]
+        };
+      } catch (error) {
+        if (isNotConnectedError(error)) {
+          return {
+            content: [{ type: "text", text: CANVA_NOT_CONNECTED }]
+          };
+        }
+        const message = error instanceof Error ? error.message : "Unknown error";
+        throw new Error(`Failed to search Canva designs: ${message}`);
+      }
+    }
+  );
+  server.tool(
+    "canva_get_design",
+    "Get details about a specific Canva design by ID. Returns the design's title, edit URL, thumbnail, and metadata.",
+    {
+      design_id: z18.string().min(1).describe("The Canva design ID to retrieve.")
+    },
+    {
+      title: "Get Canva Design",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true
+    },
+    async ({ design_id }) => {
+      try {
+        const design = await client.canvaGetDesign(design_id);
+        const lines = [`## ${design.title}`];
+        lines.push(`Design ID: ${design.id}`);
+        lines.push(`Edit URL: ${design.editUrl}`);
+        lines.push(`View URL: ${design.viewUrl}`);
+        if (design.thumbnailUrl) {
+          lines.push(`Thumbnail: ${design.thumbnailUrl}`);
+        }
+        if (design.createdAt) lines.push(`Created: ${design.createdAt}`);
+        if (design.updatedAt) lines.push(`Updated: ${design.updatedAt}`);
+        return {
+          content: [{ type: "text", text: lines.join("\n") }]
+        };
+      } catch (error) {
+        if (isNotConnectedError(error)) {
+          return {
+            content: [{ type: "text", text: CANVA_NOT_CONNECTED }]
+          };
+        }
+        const message = error instanceof Error ? error.message : "Unknown error";
+        throw new Error(`Failed to get Canva design: ${message}`);
+      }
+    }
+  );
+}
+
+// src/tools/sendgrid-newsletter.ts
+import { z as z19 } from "zod";
+function registerSendGridNewsletterTools(server, client, options) {
+  const allowDirectSend = options?.allowDirectSend ?? false;
+  server.tool(
+    "sg_list_lists",
+    "List all SendGrid subscriber lists for the account. Returns list names, IDs, and descriptions.",
+    {},
+    {
+      title: "List Subscriber Lists",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    async () => {
+      const lists = await client.sgListLists();
+      if (!lists || lists.length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "No subscriber lists found. Create one with sg_create_list."
+            }
+          ]
+        };
+      }
+      const lines = [`## Subscriber Lists (${lists.length})`];
+      for (const l of lists) {
+        lines.push(`- **${l.name}** (ID: ${l.id})${l.description ? ` \u2014 ${l.description}` : ""}`);
+      }
+      return {
+        content: [{ type: "text", text: lines.join("\n") }]
+      };
+    }
+  );
+  server.tool(
+    "sg_create_list",
+    "Create a new subscriber list for organizing newsletter recipients.",
+    {
+      name: z19.string().min(1).max(255).describe("Name of the subscriber list."),
+      description: z19.string().max(1e3).optional().describe("Optional description of the list.")
+    },
+    {
+      title: "Create Subscriber List",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: false
+    },
+    async ({ name, description }) => {
+      const list = await client.sgCreateList({ name, description });
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Subscriber list created.
+Name: ${list.name}
+ID: ${list.id}`
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "sg_delete_list",
+    "Delete a subscriber list. This removes the list and all memberships (subscribers themselves are not deleted). Requires confirmation.",
+    {
+      list_id: z19.number().int().describe("ID of the list to delete."),
+      confirmed: z19.boolean().describe(
+        "Must be true to confirm deletion. Show the list name to the user and ask for confirmation first."
+      )
+    },
+    {
+      title: "Delete Subscriber List",
+      readOnlyHint: false,
+      destructiveHint: true,
+      idempotentHint: false,
+      openWorldHint: false
+    },
+    async ({ list_id, confirmed }) => {
+      if (!confirmed) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "Deletion not confirmed. Set confirmed=true to proceed."
+            }
+          ]
+        };
+      }
+      await client.sgDeleteList(list_id);
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Subscriber list ${list_id} deleted successfully.`
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "sg_list_subscribers",
+    "List SendGrid-managed subscribers. Can filter by list ID and status (active, unsubscribed, bounced, complained). Supports pagination.",
+    {
+      list_id: z19.number().int().optional().describe("Optional list ID to filter subscribers by list membership."),
+      status: z19.enum(["active", "unsubscribed", "bounced", "complained"]).optional().describe("Optional status filter."),
+      page: z19.number().int().min(1).default(1).describe("Page number."),
+      limit: z19.number().int().min(1).max(100).default(50).describe("Results per page.")
+    },
+    {
+      title: "List Subscribers",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    async ({ list_id, status, page, limit }) => {
+      const params = {
+        page: String(page),
+        limit: String(limit)
+      };
+      if (list_id !== void 0) params.listId = String(list_id);
+      if (status) params.status = status;
+      const result = await client.sgListSubscribers(params);
+      if (!result.subscribers || result.subscribers.length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "No subscribers found matching the criteria."
+            }
+          ]
+        };
+      }
+      const lines = [`## Subscribers (page ${result.page})`];
+      for (const s of result.subscribers) {
+        const name = [s.firstName, s.lastName].filter(Boolean).join(" ");
+        lines.push(
+          `- ${s.email}${name ? ` (${name})` : ""} \u2014 ${s.status} (ID: ${s.id})`
+        );
+      }
+      return {
+        content: [{ type: "text", text: lines.join("\n") }]
+      };
+    }
+  );
+  server.tool(
+    "sg_add_subscriber",
+    "Add or update a subscriber in the SendGrid-managed subscriber list. Optionally assign to one or more lists.",
+    {
+      email: z19.string().email().describe("Subscriber's email address."),
+      first_name: z19.string().optional().describe("Subscriber's first name."),
+      last_name: z19.string().optional().describe("Subscriber's last name."),
+      list_ids: z19.array(z19.number().int()).optional().describe("Optional list IDs to add the subscriber to.")
+    },
+    {
+      title: "Add Subscriber",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    async ({ email, first_name, last_name, list_ids }) => {
+      const subscriber = await client.sgAddSubscriber({
+        email,
+        firstName: first_name,
+        lastName: last_name,
+        listIds: list_ids
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Subscriber added/updated.
+Email: ${subscriber.email}
+ID: ${subscriber.id}`
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "sg_remove_subscriber",
+    "Remove a subscriber (marks as unsubscribed). Requires confirmation.",
+    {
+      subscriber_id: z19.number().int().describe("ID of the subscriber to remove."),
+      confirmed: z19.boolean().describe(
+        "Must be true to confirm. Show the subscriber email to the user first."
+      )
+    },
+    {
+      title: "Remove Subscriber",
+      readOnlyHint: false,
+      destructiveHint: true,
+      idempotentHint: false,
+      openWorldHint: false
+    },
+    async ({ subscriber_id, confirmed }) => {
+      if (!confirmed) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "Removal not confirmed. Set confirmed=true to proceed."
+            }
+          ]
+        };
+      }
+      const result = await client.sgRemoveSubscriber(subscriber_id);
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Subscriber ${result.email} marked as unsubscribed.`
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "sg_list_sends",
+    "List newsletter sends (drafts, scheduled, sent). Filter by status.",
+    {
+      status: z19.enum(["draft", "scheduled", "sending", "sent", "cancelled"]).optional().describe("Optional status filter."),
+      page: z19.number().int().min(1).default(1).describe("Page number."),
+      limit: z19.number().int().min(1).max(100).default(20).describe("Results per page.")
+    },
+    {
+      title: "List Newsletter Sends",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    async ({ status, page, limit }) => {
+      const params = {
+        page: String(page),
+        limit: String(limit)
+      };
+      if (status) params.status = status;
+      const result = await client.sgListSends(params);
+      if (!result.sends || result.sends.length === 0) {
+        return {
+          content: [
+            { type: "text", text: "No newsletter sends found." }
+          ]
+        };
+      }
+      const lines = [`## Newsletter Sends (${result.sends.length})`];
+      for (const s of result.sends) {
+        lines.push(
+          `- **${s.subject}** (ID: ${s.id}) \u2014 ${s.status}${s.sentAt ? `, sent ${s.sentAt}` : ""}${s.scheduledAt ? `, scheduled ${s.scheduledAt}` : ""}`
+        );
+        if (s.status === "sent") {
+          lines.push(`  Delivered: ${s.delivered} | Opened: ${s.opened}`);
+        }
+      }
+      return {
+        content: [{ type: "text", text: lines.join("\n") }]
+      };
+    }
+  );
+  server.tool(
+    "sg_get_send",
+    "Get details and delivery stats for a specific newsletter send.",
+    {
+      send_id: z19.number().int().describe("ID of the newsletter send.")
+    },
+    {
+      title: "Get Newsletter Send",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    async ({ send_id }) => {
+      const send = await client.sgGetSend(send_id);
+      const lines = [
+        `## ${send.subject}`,
+        `ID: ${send.id}`,
+        `From: ${send.fromName ? `${send.fromName} <${send.fromEmail}>` : send.fromEmail}`,
+        `Status: ${send.status}`
+      ];
+      if (send.sentAt) lines.push(`Sent: ${send.sentAt}`);
+      if (send.scheduledAt) lines.push(`Scheduled: ${send.scheduledAt}`);
+      lines.push("", "### Delivery Stats");
+      lines.push(`Delivered: ${send.delivered}`);
+      lines.push(`Opened: ${send.opened}`);
+      lines.push(`Clicked: ${send.clicked}`);
+      lines.push(`Bounced: ${send.bounced}`);
+      lines.push(`Complaints: ${send.complained}`);
+      lines.push(`Unsubscribed: ${send.unsubscribed}`);
+      lines.push("");
+      lines.push(`NEWSLETTER_HTML_PREVIEW: ${send.htmlContent}`);
+      return {
+        content: [{ type: "text", text: lines.join("\n") }]
+      };
+    }
+  );
+  server.tool(
+    "sg_create_send",
+    "Create a new newsletter send draft. Must specify subject, HTML content, and from email.",
+    {
+      subject: z19.string().min(1).max(500).describe("Email subject line."),
+      html_content: z19.string().min(1).describe("HTML content of the newsletter."),
+      from_email: z19.string().email().describe("Sender email address (must be authenticated domain)."),
+      from_name: z19.string().optional().describe("Sender display name."),
+      list_id: z19.number().int().optional().describe("Optional list ID to send to. If omitted, sends to all active subscribers.")
+    },
+    {
+      title: "Create Newsletter Draft",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: false
+    },
+    async ({ subject, html_content, from_email, from_name, list_id }) => {
+      const send = await client.sgCreateSend({
+        subject,
+        htmlContent: html_content,
+        fromEmail: from_email,
+        fromName: from_name,
+        listId: list_id
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Newsletter draft created.
+ID: ${send.id}
+Subject: ${send.subject}
+Status: ${send.status}
+
+Use sg_test_send to preview, or sg_send_newsletter to send.`
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "sg_update_send",
+    "Update a newsletter draft. Only drafts can be updated.",
+    {
+      send_id: z19.number().int().describe("ID of the send to update."),
+      subject: z19.string().min(1).max(500).optional().describe("New subject line."),
+      html_content: z19.string().min(1).optional().describe("New HTML content."),
+      from_email: z19.string().email().optional().describe("New sender email."),
+      from_name: z19.string().optional().describe("New sender name."),
+      list_id: z19.number().int().nullable().optional().describe("New list ID, or null to send to all.")
+    },
+    {
+      title: "Update Newsletter Draft",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    async ({ send_id, subject, html_content, from_email, from_name, list_id }) => {
+      const data = {};
+      if (subject !== void 0) data.subject = subject;
+      if (html_content !== void 0) data.htmlContent = html_content;
+      if (from_email !== void 0) data.fromEmail = from_email;
+      if (from_name !== void 0) data.fromName = from_name;
+      if (list_id !== void 0) data.listId = list_id;
+      const send = await client.sgUpdateSend(send_id, data);
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Newsletter draft updated.
+ID: ${send.id}
+Subject: ${send.subject}`
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "sg_delete_send",
+    "Delete a newsletter draft. Only drafts can be deleted. Requires confirmation.",
+    {
+      send_id: z19.number().int().describe("ID of the draft to delete."),
+      confirmed: z19.boolean().describe("Must be true to confirm deletion.")
+    },
+    {
+      title: "Delete Newsletter Draft",
+      readOnlyHint: false,
+      destructiveHint: true,
+      idempotentHint: false,
+      openWorldHint: false
+    },
+    async ({ send_id, confirmed }) => {
+      if (!confirmed) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "Deletion not confirmed. Set confirmed=true to proceed."
+            }
+          ]
+        };
+      }
+      await client.sgDeleteSend(send_id);
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Newsletter draft ${send_id} deleted.`
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "sg_send_newsletter",
+    allowDirectSend ? "Send a newsletter immediately to all active subscribers (or subscribers in the specified list). This action cannot be undone. Requires confirmation." : "DISABLED: Direct send is not enabled for this account. Contact support.",
+    {
+      send_id: z19.number().int().describe("ID of the draft to send."),
+      confirmed: z19.boolean().describe(
+        "Must be true. Show the user the subject, from address, and recipient count before confirming."
+      )
+    },
+    {
+      title: "Send Newsletter Now",
+      readOnlyHint: false,
+      destructiveHint: true,
+      idempotentHint: false,
+      openWorldHint: true
+    },
+    async ({ send_id, confirmed }) => {
+      if (!allowDirectSend) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "Direct send is not enabled for this account. Contact support to enable this feature."
+            }
+          ]
+        };
+      }
+      if (!confirmed) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "Send not confirmed. Review the newsletter details with sg_get_send first, then set confirmed=true."
+            }
+          ]
+        };
+      }
+      const result = await client.sgSendNewsletter(send_id);
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Newsletter sent successfully!
+Subject: ${result.subject}
+Recipients: ${result.recipientCount}
+Status: ${result.status}`
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "sg_test_send",
+    "Send a test email of a newsletter draft to a specific email address. Subject will be prefixed with [TEST].",
+    {
+      send_id: z19.number().int().describe("ID of the newsletter send."),
+      email: z19.string().email().describe("Email address to send the test to.")
+    },
+    {
+      title: "Send Test Email",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: true
+    },
+    async ({ send_id, email }) => {
+      await client.sgTestSend(send_id, { email });
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Test email sent to ${email}. Check your inbox.`
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "sg_schedule_send",
+    "Schedule a newsletter to be sent at a future date/time. Requires confirmation.",
+    {
+      send_id: z19.number().int().describe("ID of the draft to schedule."),
+      scheduled_at: z19.string().describe(
+        "ISO 8601 datetime for when to send (e.g., '2025-01-15T09:00:00Z'). Must be in the future."
+      ),
+      confirmed: z19.boolean().describe("Must be true to confirm scheduling.")
+    },
+    {
+      title: "Schedule Newsletter Send",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: true
+    },
+    async ({ send_id, scheduled_at, confirmed }) => {
+      if (!confirmed) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "Scheduling not confirmed. Set confirmed=true to proceed."
+            }
+          ]
+        };
+      }
+      const result = await client.sgScheduleSend(send_id, {
+        scheduledAt: scheduled_at
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Newsletter scheduled.
+Subject: ${result.subject}
+Scheduled for: ${result.scheduledAt}
+Recipients: ${result.recipientCount}`
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "sg_authenticate_domain",
+    "Start domain authentication with SendGrid. Returns DNS records that need to be added to your domain's DNS settings.",
+    {
+      domain: z19.string().min(1).describe("Domain to authenticate (e.g., 'example.com').")
+    },
+    {
+      title: "Authenticate Domain",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: true
+    },
+    async ({ domain }) => {
+      const result = await client.sgAuthenticateDomain(domain);
+      const lines = [
+        `Domain authentication started for **${result.domain}**.`,
+        `Domain ID: ${result.id}`,
+        "",
+        "Add these DNS records to your domain:",
+        "```",
+        JSON.stringify(result.dnsRecords, null, 2),
+        "```",
+        "",
+        "After adding the records, use sg_validate_domain to verify."
+      ];
+      return {
+        content: [{ type: "text", text: lines.join("\n") }]
+      };
+    }
+  );
+  server.tool(
+    "sg_validate_domain",
+    "Validate DNS records for a domain that was previously set up for authentication.",
+    {
+      domain_id: z19.number().int().describe("Domain ID from sg_authenticate_domain.")
+    },
+    {
+      title: "Validate Domain",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true
+    },
+    async ({ domain_id }) => {
+      const result = await client.sgValidateDomain(domain_id);
+      if (result.valid) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "Domain validation successful! Your domain is now authenticated for sending."
+            }
+          ]
+        };
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Domain validation failed. Check your DNS records.
+
+Results:
+${JSON.stringify(result.validationResults, null, 2)}`
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "sg_list_domains",
+    "List all authenticated sending domains.",
+    {},
+    {
+      title: "List Authenticated Domains",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true
+    },
+    async () => {
+      const domains = await client.sgListDomains();
+      if (!domains || domains.length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "No authenticated domains found. Use sg_authenticate_domain to set one up."
+            }
+          ]
+        };
+      }
+      const lines = [`## Authenticated Domains (${domains.length})`];
+      for (const d of domains) {
+        lines.push(
+          `- **${d.domain}** (ID: ${d.id}) \u2014 ${d.valid ? "Valid" : "Not verified"}`
+        );
+      }
+      return {
+        content: [{ type: "text", text: lines.join("\n") }]
+      };
+    }
+  );
+}
 export {
   BuzzPosterClient,
   registerAccountInfoTool,
@@ -4247,6 +5880,7 @@ export {
   registerAuditLogTools,
   registerBrandVoiceTools,
   registerCalendarTools,
+  registerCanvaTools,
   registerCarouselTools,
   registerInboxTools,
   registerKnowledgeTools,
@@ -4257,6 +5891,8 @@ export {
   registerNotificationTools,
   registerPostTools,
   registerPublishingRulesTools,
+  registerQueueTools,
   registerRssTools,
+  registerSendGridNewsletterTools,
   registerSourceTools
 };