@buzzposter/mcp 0.1.5 → 0.1.7

package/dist/tools.js

@@ -0,0 +1,4251 @@
+// src/client.ts
+var BuzzPosterClient = class {
+  baseUrl;
+  apiKey;
+  constructor(config) {
+    this.baseUrl = config.baseUrl.replace(/\/$/, "");
+    this.apiKey = config.apiKey;
+  }
+  async request(method, path, body, query) {
+    const url = new URL(`${this.baseUrl}${path}`);
+    if (query) {
+      for (const [k, v] of Object.entries(query)) {
+        if (v !== void 0 && v !== "") url.searchParams.set(k, v);
+      }
+    }
+    const headers = {
+      Authorization: `Bearer ${this.apiKey}`
+    };
+    if (body) {
+      headers["Content-Type"] = "application/json";
+    }
+    const res = await fetch(url, {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : void 0
+    });
+    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;
+  }
+  // Account
+  async getAccount() {
+    return this.request("GET", "/api/v1/account");
+  }
+  // Social accounts
+  async listAccounts() {
+    return this.request("GET", "/api/v1/accounts");
+  }
+  async checkAccountsHealth() {
+    return this.request("GET", "/api/v1/accounts/health");
+  }
+  // Posts
+  async createPost(data) {
+    return this.request("POST", "/api/v1/posts", data);
+  }
+  async listPosts(params) {
+    return this.request("GET", "/api/v1/posts", void 0, params);
+  }
+  async getPost(id) {
+    return this.request("GET", `/api/v1/posts/${id}`);
+  }
+  async updatePost(id, data) {
+    return this.request("PUT", `/api/v1/posts/${id}`, data);
+  }
+  async deletePost(id) {
+    return this.request("DELETE", `/api/v1/posts/${id}`);
+  }
+  async retryPost(id) {
+    return this.request("POST", `/api/v1/posts/${id}/retry`);
+  }
+  // Analytics
+  async getAnalytics(params) {
+    return this.request("GET", "/api/v1/analytics", void 0, params);
+  }
+  // Inbox
+  async listConversations(params) {
+    return this.request("GET", "/api/v1/inbox/conversations", void 0, params);
+  }
+  async getConversation(id) {
+    return this.request("GET", `/api/v1/inbox/conversations/${id}`);
+  }
+  async replyToConversation(id, message) {
+    return this.request("POST", `/api/v1/inbox/conversations/${id}/reply`, {
+      message
+    });
+  }
+  async listComments(params) {
+    return this.request("GET", "/api/v1/inbox/comments", void 0, params);
+  }
+  async replyToComment(id, message) {
+    return this.request("POST", `/api/v1/inbox/comments/${id}/reply`, {
+      message
+    });
+  }
+  async listReviews(params) {
+    return this.request("GET", "/api/v1/inbox/reviews", void 0, params);
+  }
+  async replyToReview(id, message) {
+    return this.request("POST", `/api/v1/inbox/reviews/${id}/reply`, {
+      message
+    });
+  }
+  // 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);
+  }
+  async getUploadUrl(data) {
+    return this.request("POST", "/api/v1/media/presign", data);
+  }
+  async listMedia() {
+    return this.request("GET", "/api/v1/media");
+  }
+  async deleteMedia(key) {
+    return this.request("DELETE", `/api/v1/media/${encodeURIComponent(key)}`);
+  }
+  // Newsletter
+  async listSubscribers(params) {
+    return this.request(
+      "GET",
+      "/api/v1/newsletters/subscribers",
+      void 0,
+      params
+    );
+  }
+  async addSubscriber(data) {
+    return this.request("POST", "/api/v1/newsletters/subscribers", data);
+  }
+  async listBroadcasts(params) {
+    return this.request(
+      "GET",
+      "/api/v1/newsletters/broadcasts",
+      void 0,
+      params
+    );
+  }
+  async createBroadcast(data) {
+    return this.request("POST", "/api/v1/newsletters/broadcasts", data);
+  }
+  async updateBroadcast(id, data) {
+    return this.request("PUT", `/api/v1/newsletters/broadcasts/${id}`, data);
+  }
+  async sendBroadcast(id) {
+    return this.request("POST", `/api/v1/newsletters/broadcasts/${id}/send`);
+  }
+  async listTags() {
+    return this.request("GET", "/api/v1/newsletters/tags");
+  }
+  async listSequences() {
+    return this.request("GET", "/api/v1/newsletters/sequences");
+  }
+  async listForms() {
+    return this.request("GET", "/api/v1/newsletters/forms");
+  }
+  // Newsletter Advanced
+  async getSubscriberByEmail(email) {
+    return this.request("GET", `/api/v1/newsletters/subscribers/by-email/${encodeURIComponent(email)}`);
+  }
+  async listAutomations(params) {
+    return this.request("GET", "/api/v1/newsletters/automations", void 0, params);
+  }
+  async enrollInAutomation(automationId, data) {
+    return this.request("POST", `/api/v1/newsletters/automations/${automationId}/enroll`, data);
+  }
+  async listSegments(params) {
+    return this.request("GET", "/api/v1/newsletters/segments", void 0, params);
+  }
+  async getSegment(id, params) {
+    return this.request("GET", `/api/v1/newsletters/segments/${id}`, void 0, params);
+  }
+  async getSegmentMembers(segmentId, params) {
+    return this.request("GET", `/api/v1/newsletters/segments/${segmentId}/members`, void 0, params);
+  }
+  async deleteSegment(id) {
+    return this.request("DELETE", `/api/v1/newsletters/segments/${id}`);
+  }
+  async recalculateSegment(id) {
+    return this.request("POST", `/api/v1/newsletters/segments/${id}/recalculate`);
+  }
+  async listCustomFields() {
+    return this.request("GET", "/api/v1/newsletters/custom-fields");
+  }
+  async createCustomField(data) {
+    return this.request("POST", "/api/v1/newsletters/custom-fields", data);
+  }
+  async updateCustomField(id, data) {
+    return this.request("PUT", `/api/v1/newsletters/custom-fields/${id}`, data);
+  }
+  async deleteCustomField(id) {
+    return this.request("DELETE", `/api/v1/newsletters/custom-fields/${id}`);
+  }
+  async tagSubscriber(subscriberId, data) {
+    return this.request("POST", `/api/v1/newsletters/subscribers/${subscriberId}/tags`, data);
+  }
+  async updateSubscriber(id, data) {
+    return this.request("PUT", `/api/v1/newsletters/subscribers/${id}`, data);
+  }
+  async deleteSubscriber(id) {
+    return this.request("DELETE", `/api/v1/newsletters/subscribers/${id}`);
+  }
+  async bulkCreateSubscribers(data) {
+    return this.request("POST", "/api/v1/newsletters/subscribers/bulk", data);
+  }
+  async getReferralProgram() {
+    return this.request("GET", "/api/v1/newsletters/referral-program");
+  }
+  async listEspTiers() {
+    return this.request("GET", "/api/v1/newsletters/tiers");
+  }
+  async listPostTemplates() {
+    return this.request("GET", "/api/v1/newsletters/post-templates");
+  }
+  async getPostAggregateStats() {
+    return this.request("GET", "/api/v1/newsletters/broadcasts/aggregate-stats");
+  }
+  async deleteBroadcast(id) {
+    return this.request("DELETE", `/api/v1/newsletters/broadcasts/${id}`);
+  }
+  async listEspWebhooks() {
+    return this.request("GET", "/api/v1/newsletters/webhooks");
+  }
+  async createEspWebhook(data) {
+    return this.request("POST", "/api/v1/newsletters/webhooks", data);
+  }
+  async deleteEspWebhook(id) {
+    return this.request("DELETE", `/api/v1/newsletters/webhooks/${id}`);
+  }
+  // Knowledge
+  async listKnowledge(params) {
+    return this.request("GET", "/api/v1/knowledge", void 0, params);
+  }
+  async createKnowledge(data) {
+    return this.request("POST", "/api/v1/knowledge", data);
+  }
+  // Brand Voice
+  async getBrandVoice() {
+    return this.request("GET", "/api/v1/brand-voice");
+  }
+  async updateBrandVoice(data) {
+    return this.request("PUT", "/api/v1/brand-voice", data);
+  }
+  // Audiences
+  async getAudience(id) {
+    return this.request("GET", `/api/v1/audiences/${id}`);
+  }
+  async getDefaultAudience() {
+    return this.request("GET", "/api/v1/audiences/default");
+  }
+  async createAudience(data) {
+    return this.request("POST", "/api/v1/audiences", data);
+  }
+  async updateAudience(id, data) {
+    return this.request("PUT", `/api/v1/audiences/${id}`, data);
+  }
+  // Newsletter Templates
+  async getTemplate(id) {
+    if (id) return this.request("GET", `/api/v1/templates/${id}`);
+    return this.request("GET", "/api/v1/templates/default");
+  }
+  async listTemplates() {
+    return this.request("GET", "/api/v1/templates");
+  }
+  // Newsletter Archive
+  async listNewsletterArchive(params) {
+    return this.request("GET", "/api/v1/newsletter-archive", void 0, params);
+  }
+  async getArchivedNewsletter(id) {
+    return this.request("GET", `/api/v1/newsletter-archive/${id}`);
+  }
+  async saveNewsletterToArchive(data) {
+    return this.request("POST", "/api/v1/newsletter-archive", data);
+  }
+  // Calendar
+  async getCalendar(params) {
+    return this.request("GET", "/api/v1/calendar", void 0, params);
+  }
+  async rescheduleCalendarItem(id, scheduledFor) {
+    return this.request("PUT", `/api/v1/calendar/${id}`, {
+      scheduled_for: scheduledFor
+    });
+  }
+  async cancelCalendarItem(id) {
+    return this.request("DELETE", `/api/v1/calendar/${id}`);
+  }
+  // Queue
+  async getQueue() {
+    return this.request("GET", "/api/v1/queue");
+  }
+  async updateQueue(data) {
+    return this.request("PUT", "/api/v1/queue", data);
+  }
+  async getNextSlot() {
+    return this.request("GET", "/api/v1/queue/next");
+  }
+  // RSS
+  async fetchFeed(url, limit) {
+    const params = { url };
+    if (limit !== void 0) params.limit = String(limit);
+    return this.request("GET", "/api/v1/rss/fetch", void 0, params);
+  }
+  async fetchArticle(url) {
+    return this.request("GET", "/api/v1/rss/article", void 0, { url });
+  }
+  // Notifications
+  async getNotifications(params) {
+    return this.request("GET", "/api/v1/notifications", void 0, params);
+  }
+  async markNotificationRead(id) {
+    return this.request("PUT", `/api/v1/notifications/${id}/read`);
+  }
+  async markAllNotificationsRead() {
+    return this.request("PUT", "/api/v1/notifications/read-all");
+  }
+  // Content Sources
+  async listSources(params) {
+    return this.request("GET", "/api/v1/content-sources", void 0, params);
+  }
+  async createSource(data) {
+    return this.request("POST", "/api/v1/content-sources", data);
+  }
+  async updateSource(id, data) {
+    return this.request("PUT", `/api/v1/content-sources/${id}`, data);
+  }
+  async deleteSource(id) {
+    return this.request("DELETE", `/api/v1/content-sources/${id}`);
+  }
+  async checkSource(id) {
+    return this.request("POST", `/api/v1/content-sources/${id}/check`);
+  }
+  // Publishing Rules
+  async getPublishingRules() {
+    return this.request("GET", "/api/v1/publishing-rules");
+  }
+  // Audit Log
+  async getAuditLog(params) {
+    return this.request("GET", "/api/v1/audit-log", void 0, params);
+  }
+  // Newsletter Validation
+  async validateNewsletter(data) {
+    return this.request("POST", "/api/v1/newsletters/validate", data);
+  }
+  // Newsletter Schedule
+  async scheduleBroadcast(id, data) {
+    return this.request("POST", `/api/v1/newsletters/broadcasts/${id}/schedule`, data);
+  }
+  // Newsletter Test
+  async testBroadcast(id, data) {
+    return this.request("POST", `/api/v1/newsletters/broadcasts/${id}/test`, data);
+  }
+  // Carousel templates
+  async getCarouselTemplate() {
+    return this.request("GET", "/api/v1/carousel-templates");
+  }
+  async updateCarouselTemplate(data) {
+    return this.request("PUT", "/api/v1/carousel-templates", data);
+  }
+  async deleteCarouselTemplate() {
+    return this.request("DELETE", "/api/v1/carousel-templates");
+  }
+  async generateCarousel(data) {
+    return this.request("POST", "/api/v1/carousel-templates/generate", data);
+  }
+  async previewCarousel(data) {
+    return this.request("POST", "/api/v1/carousel-templates/preview", data);
+  }
+};
+
+// src/tools/posts.ts
+import { z } from "zod";
+function registerPostTools(server, client) {
+  server.tool(
+    "post",
+    `Create and publish a post to one or more social media platforms. Supports Twitter, Instagram, LinkedIn, and Facebook.
+
+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.
+
+REQUIRED WORKFLOW:
+1. BEFORE creating any content, call get_brand_voice and get_audience to match the customer's tone
+2. BEFORE publishing, call get_publishing_rules to check safety settings
+3. ALWAYS set confirmed=false first to get a preview -- never set confirmed=true on the first call
+4. Show the user a visual preview of the post before confirming
+5. Only set confirmed=true after the user explicitly says to publish/post/send
+6. If publishing_rules.social_default_action is 'draft', create as draft unless the user explicitly asks to publish
+7. If publishing_rules.require_double_confirm_social is true, ask for confirmation twice before publishing
+8. NEVER publish immediately without user confirmation, even if the user says "post this" -- always show the preview first
+
+When confirmed=false, this tool returns a structured preview with content, platform details, character counts, safety checks, and a confirmation message. You MUST render this as a visual preview for the user and wait for their explicit approval before calling again with confirmed=true.
+
+IMPORTANT: Always show the user a preview of the post content before publishing. Never publish without explicit user approval. If no preview has been shown yet, do NOT set confirmed=true -- render the preview first.`,
+    {
+      content: z.string().optional().describe("The text content of the post"),
+      platforms: z.array(z.string()).describe('Platforms to post to, e.g. ["twitter", "linkedin"]'),
+      media_urls: z.array(z.string()).optional().describe("Public URLs of media to attach"),
+      platform_specific: z.record(z.record(z.unknown())).optional().describe(
+        "Platform-specific data keyed by platform name. E.g. { twitter: { threadItems: [...] }, instagram: { firstComment: '...' } }"
+      ),
+      confirmed: z.boolean().default(false).describe(
+        "Set to true to confirm and publish. If false or missing, returns a preview for user approval."
+      )
+    },
+    {
+      title: "Publish Post Now",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: true
+    },
+    async (args) => {
+      if (args.confirmed !== true) {
+        let rulesText = "";
+        try {
+          const rules = await client.getPublishingRules();
+          const blockedWords = rules.blockedWords ?? [];
+          const foundBlocked = [];
+          if (args.content && blockedWords.length > 0) {
+            const lower = args.content.toLowerCase();
+            for (const word of blockedWords) {
+              if (lower.includes(word.toLowerCase())) foundBlocked.push(word);
+            }
+          }
+          rulesText = `
+### Safety Checks
+`;
+          rulesText += `- Blocked words: ${foundBlocked.length > 0 ? `**FAILED** (found: ${foundBlocked.join(", ")})` : "PASS"}
+`;
+          rulesText += `- Default action: ${rules.socialDefaultAction ?? "draft"}
+`;
+          rulesText += `- Immediate publish allowed: ${rules.allowImmediatePublish ? "yes" : "no"}
+`;
+          if (rules.maxPostsPerDay) rulesText += `- Daily post limit: ${rules.maxPostsPerDay}
+`;
+        } catch {
+        }
+        const charCounts = {};
+        const limits = { twitter: 280, linkedin: 3e3, instagram: 2200, facebook: 63206, threads: 500 };
+        const contentLen = (args.content ?? "").length;
+        for (const p of args.platforms) {
+          const limit = limits[p.toLowerCase()] ?? 5e3;
+          charCounts[p] = { used: contentLen, limit, ok: contentLen <= limit };
+        }
+        let charText = "\n### Character Counts\n";
+        for (const [platform, counts] of Object.entries(charCounts)) {
+          charText += `- ${platform}: ${counts.used}/${counts.limit} ${counts.ok ? "" : "**OVER LIMIT**"}
+`;
+        }
+        const preview = `## Post Preview
+
+**Content:** "${args.content ?? "(no text)"}"
+**Platforms:** ${args.platforms.join(", ")}
+` + (args.media_urls?.length ? `**Media:** ${args.media_urls.length} file(s)
+` : "") + charText + rulesText + `
+**Action:** This will be published **immediately** to ${args.platforms.length} platform(s).
+
+Call this tool again with confirmed=true to proceed.`;
+        return { content: [{ type: "text", text: preview }] };
+      }
+      const platforms = args.platforms.map((platform) => {
+        const entry = { platform };
+        if (args.platform_specific?.[platform]) {
+          entry.platformSpecificData = args.platform_specific[platform];
+        }
+        return entry;
+      });
+      const body = {
+        content: args.content,
+        platforms,
+        publishNow: true
+      };
+      if (args.media_urls?.length) {
+        body.mediaItems = args.media_urls.map((url) => ({
+          type: url.match(/\.(mp4|mov|avi|webm)$/i) ? "video" : "image",
+          url
+        }));
+      }
+      const result = await client.createPost(body);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "cross_post",
+    `Post the same content to all connected platforms at once.
+
+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.
+
+REQUIRED WORKFLOW:
+1. BEFORE creating content, call get_brand_voice and get_audience
+2. BEFORE publishing, call get_publishing_rules
+3. ALWAYS set confirmed=false first to preview
+4. Show the user a visual preview showing how the post will appear on each platform
+5. This is a high-impact action (goes to ALL platforms) -- always require explicit confirmation
+6. If publishing_rules.require_double_confirm_social is true, ask twice
+
+When confirmed=false, this tool returns a structured preview with content, platform details, character counts, safety checks, and a confirmation message. You MUST render this as a visual preview for the user and wait for their explicit approval before calling again with confirmed=true.`,
+    {
+      content: z.string().describe("The text content to post everywhere"),
+      media_urls: z.array(z.string()).optional().describe("Public URLs of media to attach"),
+      confirmed: z.boolean().default(false).describe(
+        "Set to true to confirm and publish. If false or missing, returns a preview for user approval."
+      )
+    },
+    {
+      title: "Cross-Post to All Platforms",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: true
+    },
+    async (args) => {
+      const accountsData = await client.listAccounts();
+      const platforms = (accountsData.accounts ?? []).map(
+        (a) => a.platform
+      );
+      if (platforms.length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "No connected social accounts found. Connect accounts first."
+            }
+          ]
+        };
+      }
+      if (args.confirmed !== true) {
+        let rulesText = "";
+        try {
+          const rules = await client.getPublishingRules();
+          const blockedWords = rules.blockedWords ?? [];
+          const foundBlocked = [];
+          if (args.content && blockedWords.length > 0) {
+            const lower = args.content.toLowerCase();
+            for (const word of blockedWords) {
+              if (lower.includes(word.toLowerCase())) foundBlocked.push(word);
+            }
+          }
+          rulesText = `
+### Safety Checks
+`;
+          rulesText += `- Blocked words: ${foundBlocked.length > 0 ? `**FAILED** (found: ${foundBlocked.join(", ")})` : "PASS"}
+`;
+          rulesText += `- Default action: ${rules.socialDefaultAction ?? "draft"}
+`;
+          rulesText += `- Double confirmation required: ${rules.requireDoubleConfirmSocial ? "yes" : "no"}
+`;
+        } catch {
+        }
+        const preview = `## Cross-Post Preview
+
+**Content:** "${args.content}"
+**Platforms:** ${platforms.join(", ")} (${platforms.length} platforms)
+` + (args.media_urls?.length ? `**Media:** ${args.media_urls.length} file(s)
+` : "") + rulesText + `
+**Action:** This will be published **immediately** to **all ${platforms.length} connected platforms**. This is a high-impact action.
+
+Call this tool again with confirmed=true to proceed.`;
+        return { content: [{ type: "text", text: preview }] };
+      }
+      const body = {
+        content: args.content,
+        platforms: platforms.map((p) => ({ platform: p })),
+        publishNow: true
+      };
+      if (args.media_urls?.length) {
+        body.mediaItems = args.media_urls.map((url) => ({
+          type: url.match(/\.(mp4|mov|avi|webm)$/i) ? "video" : "image",
+          url
+        }));
+      }
+      const result = await client.createPost(body);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "schedule_post",
+    `Schedule a post for future publication.
+
+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.
+
+REQUIRED WORKFLOW:
+1. BEFORE creating content, call get_brand_voice and get_audience
+2. BEFORE scheduling, call get_publishing_rules
+3. ALWAYS set confirmed=false first to preview
+4. Show the user a visual preview with the scheduled date/time before confirming
+5. Only confirm after explicit user approval
+6. If the user hasn't specified a time, suggest one based on get_queue time slots
+
+When confirmed=false, this tool returns a structured preview with content, platform details, character counts, safety checks, and a confirmation message. You MUST render this as a visual preview for the user and wait for their explicit approval before calling again with confirmed=true.
+
+IMPORTANT: Always show the user a preview of the post content before scheduling. Never schedule without explicit user approval. If no preview has been shown yet, do NOT set confirmed=true -- render the preview first.`,
+    {
+      content: z.string().optional().describe("The text content of the post"),
+      platforms: z.array(z.string()).describe('Platforms to post to, e.g. ["twitter", "linkedin"]'),
+      scheduled_for: z.string().describe("ISO 8601 datetime for when to publish, e.g. 2024-01-16T12:00:00"),
+      timezone: z.string().default("UTC").describe("Timezone for the scheduled time, e.g. America/New_York"),
+      media_urls: z.array(z.string()).optional().describe("Media URLs to attach"),
+      platform_specific: z.record(z.record(z.unknown())).optional().describe("Platform-specific data keyed by platform name"),
+      confirmed: z.boolean().default(false).describe(
+        "Set to true to confirm scheduling. If false or missing, returns a preview for user approval."
+      )
+    },
+    {
+      title: "Schedule Social Post",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: true
+    },
+    async (args) => {
+      if (args.confirmed !== true) {
+        let rulesText = "";
+        try {
+          const rules = await client.getPublishingRules();
+          const blockedWords = rules.blockedWords ?? [];
+          const foundBlocked = [];
+          if (args.content && blockedWords.length > 0) {
+            const lower = args.content.toLowerCase();
+            for (const word of blockedWords) {
+              if (lower.includes(word.toLowerCase())) foundBlocked.push(word);
+            }
+          }
+          rulesText = `
+### Safety Checks
+`;
+          rulesText += `- Blocked words: ${foundBlocked.length > 0 ? `**FAILED** (found: ${foundBlocked.join(", ")})` : "PASS"}
+`;
+        } catch {
+        }
+        const preview = `## Schedule Preview
+
+**Content:** "${args.content ?? "(no text)"}"
+**Platforms:** ${args.platforms.join(", ")}
+**Scheduled for:** ${args.scheduled_for} (${args.timezone})
+` + (args.media_urls?.length ? `**Media:** ${args.media_urls.length} file(s)
+` : "") + rulesText + `
+Call this tool again with confirmed=true to schedule.`;
+        return { content: [{ type: "text", text: preview }] };
+      }
+      const platforms = args.platforms.map((platform) => {
+        const entry = { platform };
+        if (args.platform_specific?.[platform]) {
+          entry.platformSpecificData = args.platform_specific[platform];
+        }
+        return entry;
+      });
+      const body = {
+        content: args.content,
+        platforms,
+        scheduledFor: args.scheduled_for,
+        timezone: args.timezone
+      };
+      if (args.media_urls?.length) {
+        body.mediaItems = args.media_urls.map((url) => ({
+          type: url.match(/\.(mp4|mov|avi|webm)$/i) ? "video" : "image",
+          url
+        }));
+      }
+      const result = await client.createPost(body);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "create_draft",
+    "Save a post as a draft without publishing. This NEVER publishes \u2014 it only saves. No confirmation needed since nothing goes live.",
+    {
+      content: z.string().optional().describe("The text content of the draft"),
+      platforms: z.array(z.string()).describe("Platforms this draft is intended for"),
+      media_urls: z.array(z.string()).optional().describe("Media URLs to attach")
+    },
+    {
+      title: "Create Draft Post",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: false
+    },
+    async (args) => {
+      const body = {
+        content: args.content,
+        platforms: args.platforms.map((p) => ({ platform: p }))
+      };
+      if (args.media_urls?.length) {
+        body.mediaItems = args.media_urls.map((url) => ({
+          type: url.match(/\.(mp4|mov|avi|webm)$/i) ? "video" : "image",
+          url
+        }));
+      }
+      const result = await client.createPost(body);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "list_posts",
+    "List recent posts with their status and platform details.",
+    {
+      status: z.string().optional().describe("Filter by status: published, scheduled, draft, failed"),
+      limit: z.string().optional().describe("Number of posts to return")
+    },
+    {
+      title: "List Posts",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true
+    },
+    async (args) => {
+      const params = {};
+      if (args.status) params.status = args.status;
+      if (args.limit) params.limit = args.limit;
+      const result = await client.listPosts(params);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "get_post",
+    "Get detailed information about a specific post.",
+    {
+      post_id: z.string().describe("The ID of the post to retrieve")
+    },
+    {
+      title: "Get Post Details",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true
+    },
+    async (args) => {
+      const result = await client.getPost(args.post_id);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "retry_post",
+    "Retry a post that failed to publish on one or more platforms. Only retries the failed platforms -- already-published platforms are not affected. Use this when a post shows 'failed' or 'partial' status.",
+    {
+      post_id: z.string().describe("The ID of the post to retry"),
+      confirmed: z.boolean().default(false).describe(
+        "Set to true to confirm retry. If false/missing, shows post details first."
+      )
+    },
+    {
+      title: "Retry Failed Post",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true
+    },
+    async (args) => {
+      if (args.confirmed !== true) {
+        const post = await client.getPost(args.post_id);
+        const platforms = post.platforms ?? [];
+        const failed = platforms.filter((p) => p.status === "failed");
+        const published = platforms.filter((p) => p.status === "published");
+        let text = `## Retry Post Preview
+
+`;
+        text += `**Post ID:** ${args.post_id}
+`;
+        text += `**Content:** "${(post.content ?? "").substring(0, 100)}"
+`;
+        text += `**Status:** ${post.status}
+
+`;
+        if (published.length > 0) {
+          text += `**Already published on:** ${published.map((p) => p.platform).join(", ")}
+`;
+        }
+        if (failed.length > 0) {
+          text += `**Failed on:** ${failed.map((p) => `${p.platform} (${p.error ?? "unknown error"})`).join(", ")}
+`;
+        }
+        text += `
+Retrying will only attempt the failed platforms. Call this tool again with confirmed=true to proceed.`;
+        return { content: [{ type: "text", text }] };
+      }
+      const result = await client.retryPost(args.post_id);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/accounts.ts
+function registerAccountTools(server, client) {
+  server.tool(
+    "list_accounts",
+    "List all connected accounts \u2014 both social media platforms (Twitter, Instagram, etc.) and email service provider / ESP (Kit, Beehiiv, Mailchimp). Use this whenever the user asks about their accounts, connections, or integrations.",
+    {},
+    {
+      title: "List Connected Accounts",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    async () => {
+      const result = await client.listAccounts();
+      const accounts = result.accounts ?? [];
+      const esp = result.esp;
+      if (accounts.length === 0 && !esp) {
+        return {
+          content: [{
+            type: "text",
+            text: "## Connected Accounts\n\nNo accounts connected. Connect social media accounts and/or an email service provider via the dashboard."
+          }]
+        };
+      }
+      let text = "## Connected Accounts\n\n";
+      text += "### Social Media\n";
+      if (accounts.length > 0) {
+        for (const a of accounts) {
+          const icon = a.isActive ? "\u2705" : "\u274C";
+          const platform = a.platform.charAt(0).toUpperCase() + a.platform.slice(1);
+          const name = a.username || a.displayName || a.platform;
+          text += `${icon} **${platform}** \u2014 @${name}
+`;
+        }
+      } else {
+        text += "No social accounts connected.\n";
+      }
+      text += "\n### Email Service Provider (ESP)\n";
+      if (esp && esp.connected) {
+        const provider = esp.provider.charAt(0).toUpperCase() + esp.provider.slice(1);
+        text += `\u2705 **${provider}** \u2014 Connected`;
+        if (esp.publicationId) text += ` (Publication: ${esp.publicationId})`;
+        text += "\n";
+      } else if (esp) {
+        const provider = esp.provider.charAt(0).toUpperCase() + esp.provider.slice(1);
+        text += `\u26A0\uFE0F **${provider}** \u2014 Provider set but API key missing
+`;
+      } else {
+        text += "No ESP configured.\n";
+      }
+      return {
+        content: [{ type: "text", text }]
+      };
+    }
+  );
+  server.tool(
+    "check_accounts_health",
+    "Check the health status of all connected social media accounts. Shows which accounts are working, which have warnings, and which need reconnection. Call this before scheduling posts to make sure target platforms are healthy.",
+    {},
+    {
+      title: "Check Account Health",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true
+    },
+    async () => {
+      const result = await client.checkAccountsHealth();
+      const accounts = result.accounts ?? [];
+      const summary = result.summary;
+      if (accounts.length === 0) {
+        return {
+          content: [{
+            type: "text",
+            text: "## Account Health\n\nNo connected accounts found. Connect accounts first via the dashboard."
+          }]
+        };
+      }
+      const statusIcon = {
+        healthy: "\u2705",
+        warning: "\u26A0\uFE0F",
+        error: "\u274C"
+      };
+      const lines = accounts.map((a) => {
+        const icon = statusIcon[a.status] ?? "\u2753";
+        const name = a.username ? `@${a.username}` : a.platform;
+        const platform = a.platform.charAt(0).toUpperCase() + a.platform.slice(1);
+        const msg = a.message || (a.status === "healthy" ? "Healthy" : a.status);
+        return `${icon} **${platform}** (${name}) \u2014 ${msg}`;
+      });
+      let text = `## Account Health
+
+${lines.join("\n")}`;
+      if (summary) {
+        text += `
+
+**Summary:** ${summary.total} total, ${summary.healthy} healthy, ${summary.warning} warning, ${summary.error} error`;
+      }
+      return {
+        content: [{ type: "text", text }]
+      };
+    }
+  );
+}
+
+// src/tools/analytics.ts
+import { z as z2 } from "zod";
+function registerAnalyticsTools(server, client) {
+  server.tool(
+    "get_analytics",
+    "Get performance analytics for your social media posts. Supports filtering by platform and date range.",
+    {
+      platform: z2.string().optional().describe("Filter by platform: twitter, instagram, linkedin, facebook"),
+      from_date: z2.string().optional().describe("Start date for analytics range (ISO 8601)"),
+      to_date: z2.string().optional().describe("End date for analytics range (ISO 8601)")
+    },
+    {
+      title: "Get Analytics",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true
+    },
+    async (args) => {
+      const params = {};
+      if (args.platform) params.platform = args.platform;
+      if (args.from_date) params.fromDate = args.from_date;
+      if (args.to_date) params.toDate = args.to_date;
+      const result = await client.getAnalytics(params);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/inbox.ts
+import { z as z3 } from "zod";
+function registerInboxTools(server, client) {
+  server.tool(
+    "list_conversations",
+    "List DM conversations across all connected social media platforms.",
+    {
+      platform: z3.string().optional().describe("Filter by platform: twitter, instagram, linkedin, facebook")
+    },
+    {
+      title: "List Conversations",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true
+    },
+    async (args) => {
+      const params = {};
+      if (args.platform) params.platform = args.platform;
+      const result = await client.listConversations(params);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "get_conversation",
+    "Get all messages in a specific DM conversation.",
+    {
+      conversation_id: z3.string().describe("The conversation ID")
+    },
+    {
+      title: "Get Conversation Messages",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true
+    },
+    async (args) => {
+      const result = await client.getConversation(args.conversation_id);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "reply_to_conversation",
+    `Send a reply message in a DM conversation. This sends a message on an external platform on the customer's behalf. Always show draft reply to the user before calling with confirmed=true.
+
+REQUIRED WORKFLOW:
+1. ALWAYS set confirmed=false first to preview the reply
+2. Show the user the reply text and which platform/conversation it will be sent to
+3. Only confirm after explicit user approval`,
+    {
+      conversation_id: z3.string().describe("The conversation ID to reply to"),
+      message: z3.string().describe("The reply message text"),
+      confirmed: z3.boolean().default(false).describe("Set to true to confirm and send. If false or missing, returns a preview for user approval.")
+    },
+    {
+      title: "Reply to Conversation",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: true
+    },
+    async (args) => {
+      if (args.confirmed !== true) {
+        const preview = `## Reply Preview
+
+**Conversation:** ${args.conversation_id}
+**Message:** "${args.message}"
+
+This will send a DM reply on the external platform. Call this tool again with confirmed=true to send.`;
+        return { content: [{ type: "text", text: preview }] };
+      }
+      const result = await client.replyToConversation(
+        args.conversation_id,
+        args.message
+      );
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "list_comments",
+    "List comments on your social media posts.",
+    {
+      post_id: z3.string().optional().describe("Filter comments by post ID")
+    },
+    {
+      title: "List Comments",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true
+    },
+    async (args) => {
+      const params = {};
+      if (args.post_id) params.postId = args.post_id;
+      const result = await client.listComments(params);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "reply_to_comment",
+    `Reply to a comment on one of the customer's posts. This sends a public reply on the external platform. Sends a message on the user's behalf on an external platform. Always show draft reply to the user before calling with confirmed=true.
+
+REQUIRED WORKFLOW:
+1. ALWAYS set confirmed=false first to preview
+2. Show the user the reply and the original comment for context
+3. Only confirm after explicit user approval -- public replies are visible to everyone`,
+    {
+      comment_id: z3.string().describe("The comment ID to reply to"),
+      message: z3.string().describe("The reply text"),
+      confirmed: z3.boolean().default(false).describe("Set to true to confirm and send. If false or missing, returns a preview for user approval.")
+    },
+    {
+      title: "Reply to Comment",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: true
+    },
+    async (args) => {
+      if (args.confirmed !== true) {
+        const preview = `## Comment Reply Preview
+
+**Comment ID:** ${args.comment_id}
+**Reply:** "${args.message}"
+
+This will post a public reply. Call this tool again with confirmed=true to send.`;
+        return { content: [{ type: "text", text: preview }] };
+      }
+      const result = await client.replyToComment(
+        args.comment_id,
+        args.message
+      );
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "list_reviews",
+    "List reviews on your Facebook page.",
+    {},
+    {
+      title: "List Reviews",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true
+    },
+    async () => {
+      const result = await client.listReviews();
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "reply_to_review",
+    `Reply to a review on the customer's Facebook page. This sends a public reply on the external platform. Sends a message on the user's behalf on an external platform. Always show draft reply to the user before calling with confirmed=true.
+
+REQUIRED WORKFLOW:
+1. ALWAYS set confirmed=false first to preview
+2. Show the user the reply, the original review, and the star rating for context
+3. Only confirm after explicit user approval -- public replies represent the brand`,
+    {
+      review_id: z3.string().describe("The review ID to reply to"),
+      message: z3.string().describe("The reply text"),
+      confirmed: z3.boolean().default(false).describe("Set to true to confirm and send. If false or missing, returns a preview for user approval.")
+    },
+    {
+      title: "Reply to Review",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: true
+    },
+    async (args) => {
+      if (args.confirmed !== true) {
+        const preview = `## Review Reply Preview
+
+**Review ID:** ${args.review_id}
+**Reply:** "${args.message}"
+
+This will post a public reply to the review. Call this tool again with confirmed=true to send.`;
+        return { content: [{ type: "text", text: preview }] };
+      }
+      const result = await client.replyToReview(
+        args.review_id,
+        args.message
+      );
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+}
+
+// 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.",
+    {
+      url: z4.string().url().describe("Public URL of the image or video to upload"),
+      filename: z4.string().optional().describe("Optional filename override (including extension)"),
+      folder: z4.string().optional().describe("Optional folder path within the customer's storage")
+    },
+    {
+      title: "Upload Media from URL",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: false
+    },
+    async (args) => {
+      const result = await client.uploadFromUrl({
+        url: args.url,
+        filename: args.filename,
+        folder: args.folder
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "get_upload_url",
+    "Get a pre-signed URL for direct client upload to storage. The URL is valid for 5 minutes. After uploading to the URL, the file will be available at the returned CDN URL.",
+    {
+      filename: z4.string().describe("The filename including extension (e.g. photo.jpg)"),
+      content_type: z4.string().describe("MIME type of the file (e.g. image/jpeg, video/mp4)")
+    },
+    {
+      title: "Get Upload URL",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: false
+    },
+    async (args) => {
+      const result = await client.getUploadUrl({
+        filename: args.filename,
+        content_type: args.content_type
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "list_media",
+    "List all uploaded media files in your BuzzPoster media library.",
+    {},
+    {
+      title: "List Media Library",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    async () => {
+      const result = await client.listMedia();
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "delete_media",
+    `Delete a media file from the customer's BuzzPoster media library. This cannot be undone.
+
+REQUIRED WORKFLOW:
+1. ALWAYS set confirmed=false first
+2. Show the user which file will be deleted (filename, URL, size)
+3. Only confirm after explicit approval`,
+    {
+      key: z4.string().describe("The key/path of the media file to delete"),
+      confirmed: z4.boolean().default(false).describe("Set to true to confirm deletion. If false or missing, returns a preview for user approval.")
+    },
+    {
+      title: "Delete Media File",
+      readOnlyHint: false,
+      destructiveHint: true,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    async (args) => {
+      if (args.confirmed !== true) {
+        const preview = `## Delete Media Confirmation
+
+**File:** ${args.key}
+
+This will permanently delete this media file. Call this tool again with confirmed=true to proceed.`;
+        return { content: [{ type: "text", text: preview }] };
+      }
+      await client.deleteMedia(args.key);
+      return {
+        content: [{ type: "text", text: "Media deleted successfully." }]
+      };
+    }
+  );
+}
+
+// src/tools/newsletter.ts
+import { z as z5 } from "zod";
+function registerNewsletterTools(server, client, options = {}) {
+  server.tool(
+    "list_subscribers",
+    "List email subscribers from your configured email service provider (Kit, Beehiiv, or Mailchimp).",
+    {
+      page: z5.string().optional().describe("Page number for pagination"),
+      per_page: z5.string().optional().describe("Number of subscribers per page")
+    },
+    {
+      title: "List Subscribers",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true
+    },
+    async (args) => {
+      const params = {};
+      if (args.page) params.page = args.page;
+      if (args.per_page) params.perPage = args.per_page;
+      const result = await client.listSubscribers(params);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "add_subscriber",
+    "Add a new email subscriber to your mailing list.",
+    {
+      email: z5.string().describe("Email address of the subscriber"),
+      first_name: z5.string().optional().describe("Subscriber's first name"),
+      last_name: z5.string().optional().describe("Subscriber's last name")
+    },
+    {
+      title: "Add Subscriber",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: true
+    },
+    async (args) => {
+      const result = await client.addSubscriber({
+        email: args.email,
+        firstName: args.first_name,
+        lastName: args.last_name
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "create_newsletter",
+    `Push an approved newsletter draft to the user's ESP (Kit, Beehiiv, or Mailchimp) as a DRAFT. This creates a DRAFT only -- it does not send. IMPORTANT: Only call this AFTER the user has reviewed and explicitly approved an HTML artifact preview of the newsletter. If no artifact has been shown yet, do NOT call this tool -- go back and render the preview first. No third-party branding in the output unless the customer explicitly configured it.`,
+    {
+      subject: z5.string().describe("Email subject line"),
+      content: z5.string().describe("HTML content of the newsletter"),
+      preview_text: z5.string().optional().describe("Preview text shown in email clients")
+    },
+    {
+      title: "Create Newsletter Draft",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: true
+    },
+    async (args) => {
+      const result = await client.createBroadcast({
+        subject: args.subject,
+        content: args.content,
+        previewText: args.preview_text
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "update_newsletter",
+    `Update an existing newsletter/broadcast draft. After updating, show the user a visual preview of the changes.`,
+    {
+      broadcast_id: z5.string().describe("The broadcast/newsletter ID to update"),
+      subject: z5.string().optional().describe("Updated subject line"),
+      content: z5.string().optional().describe("Updated HTML content"),
+      preview_text: z5.string().optional().describe("Updated preview text")
+    },
+    {
+      title: "Update Newsletter Draft",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true
+    },
+    async (args) => {
+      const data = {};
+      if (args.subject) data.subject = args.subject;
+      if (args.content) data.content = args.content;
+      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) }]
+      };
+    }
+  );
+  if (options.allowDirectSend) {
+    server.tool(
+      "send_newsletter",
+      `Send a newsletter/broadcast to subscribers. THIS ACTION CANNOT BE UNDONE. Once sent, the email goes to every subscriber on the list.
+
+REQUIRED WORKFLOW:
+1. ALWAYS call get_publishing_rules first
+2. NEVER send without showing a full visual preview of the newsletter first
+3. ALWAYS set confirmed=false first -- this returns a confirmation prompt, not a send
+4. Tell the user exactly how many subscribers will receive this email
+5. If publishing_rules.require_double_confirm_newsletter is true (default), require TWO explicit confirmations:
+   - First: "Are you sure you want to send this to [X] subscribers?"
+   - Second: "This is irreversible. Type 'send' to confirm."
+6. If publishing_rules.allow_immediate_send is false and the user asks to send immediately, suggest scheduling instead
+7. NEVER set confirmed=true without the user explicitly confirming after seeing the preview and subscriber count
+
+When confirmed=false, this tool returns a structured preview with broadcast details, subscriber count, safety checks, and a confirmation message. You MUST render this as a visual preview for the user and wait for their explicit approval before calling again with confirmed=true.`,
+      {
+        broadcast_id: z5.string().describe("The broadcast/newsletter ID to send"),
+        confirmed: z5.boolean().default(false).describe(
+          "Set to true to confirm and send. If false or missing, returns a confirmation prompt."
+        )
+      },
+      {
+        title: "Send Newsletter",
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true
+      },
+      async (args) => {
+        if (args.confirmed !== true) {
+          let subscriberCount = "unknown";
+          let rulesText = "";
+          try {
+            const subData = await client.listSubscribers({ perPage: "1" });
+            subscriberCount = String(subData?.totalCount ?? subData?.total ?? subData?.subscribers?.length ?? "unknown");
+          } catch {
+          }
+          try {
+            const rules = await client.getPublishingRules();
+            rulesText = `
+### Safety Checks
+`;
+            rulesText += `- Double confirmation required: ${rules.requireDoubleConfirmNewsletter ? "**yes**" : "no"}
+`;
+            rulesText += `- Immediate send allowed: ${rules.allowImmediateSend ? "yes" : "**no**"}
+`;
+            if (rules.requiredDisclaimer) {
+              rulesText += `- Required disclaimer: "${rules.requiredDisclaimer}"
+`;
+            }
+          } catch {
+          }
+          let espText = "";
+          try {
+            const account = await client.getAccount();
+            espText = account?.espProvider ? `**ESP:** ${account.espProvider}
+` : "";
+          } catch {
+          }
+          const preview = `## Send Newsletter Confirmation
+
+**Broadcast ID:** ${args.broadcast_id}
+**Subscribers:** ~${subscriberCount} recipients
+` + espText + rulesText + `
+**This action cannot be undone.** Once sent, the email goes to every subscriber.
+
+Call this tool again with confirmed=true to send.`;
+          return { content: [{ type: "text", text: preview }] };
+        }
+        await client.sendBroadcast(args.broadcast_id);
+        return {
+          content: [{ type: "text", text: "Newsletter sent successfully." }]
+        };
+      }
+    );
+  }
+  server.tool(
+    "schedule_newsletter",
+    `Schedule a newsletter/broadcast to be sent at a future time.
+
+REQUIRED WORKFLOW:
+1. ALWAYS call get_publishing_rules first
+2. NEVER schedule without showing a full visual preview of the newsletter first
+3. ALWAYS set confirmed=false first -- this returns a confirmation prompt with details, not an actual schedule
+4. Tell the user exactly how many subscribers will receive this email and the scheduled send time
+5. If publishing_rules.require_double_confirm_newsletter is true (default), require TWO explicit confirmations:
+   - First: "Are you sure you want to schedule this for [time] to [X] subscribers?"
+   - Second: "Confirm schedule for [time]."
+6. If publishing_rules.allow_immediate_send is false and the scheduled time is very soon, warn the user
+7. NEVER set confirmed=true without the user explicitly confirming after seeing the preview, subscriber count, and scheduled time
+
+Scheduling can typically be cancelled or rescheduled later, but the user should still verify the time is correct before confirming.
+
+When confirmed=false, this tool returns a structured preview with broadcast details, scheduled time, subscriber count, safety checks, and a confirmation message. You MUST render this as a visual preview for the user and wait for their explicit approval before calling again with confirmed=true.`,
+    {
+      broadcast_id: z5.string().describe("The broadcast/newsletter ID to schedule"),
+      scheduled_for: z5.string().describe(
+        "ISO 8601 datetime for when to send (e.g. '2026-02-25T14:00:00Z')"
+      ),
+      confirmed: z5.boolean().default(false).describe(
+        "Set to true to confirm and schedule. If false or missing, returns a confirmation prompt."
+      )
+    },
+    {
+      title: "Schedule Newsletter",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: true
+    },
+    async (args) => {
+      if (args.confirmed !== true) {
+        let subscriberCount = "unknown";
+        let rulesText = "";
+        try {
+          const subData = await client.listSubscribers({ perPage: "1" });
+          subscriberCount = String(
+            subData?.totalCount ?? subData?.total ?? subData?.subscribers?.length ?? "unknown"
+          );
+        } catch {
+        }
+        try {
+          const rules = await client.getPublishingRules();
+          rulesText = `
+### Safety Checks
+`;
+          rulesText += `- Double confirmation required: ${rules.requireDoubleConfirmNewsletter ? "**yes**" : "no"}
+`;
+          rulesText += `- Immediate send allowed: ${rules.allowImmediateSend ? "yes" : "**no**"}
+`;
+          if (rules.requiredDisclaimer) {
+            rulesText += `- Required disclaimer: "${rules.requiredDisclaimer}"
+`;
+          }
+        } catch {
+        }
+        let espText = "";
+        try {
+          const account = await client.getAccount();
+          espText = account?.espProvider ? `**ESP:** ${account.espProvider}
+` : "";
+        } catch {
+        }
+        const preview = `## Schedule Newsletter Confirmation
+
+**Broadcast ID:** ${args.broadcast_id}
+**Scheduled for:** ${args.scheduled_for}
+**Subscribers:** ~${subscriberCount} recipients
+` + espText + rulesText + `
+Scheduling can typically be cancelled or rescheduled later, but please verify the time is correct.
+
+Call this tool again with confirmed=true to schedule.`;
+        return { content: [{ type: "text", text: preview }] };
+      }
+      await client.scheduleBroadcast(args.broadcast_id, {
+        scheduledFor: args.scheduled_for
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Newsletter scheduled successfully for ${args.scheduled_for}.`
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "list_newsletters",
+    "List all newsletters/broadcasts with their status.",
+    {
+      page: z5.string().optional().describe("Page number for pagination")
+    },
+    {
+      title: "List Newsletters",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true
+    },
+    async (args) => {
+      const params = {};
+      if (args.page) params.page = args.page;
+      const result = await client.listBroadcasts(params);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "list_tags",
+    "List all subscriber tags from your email service provider.",
+    {},
+    {
+      title: "List Subscriber Tags",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true
+    },
+    async () => {
+      const result = await client.listTags();
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "list_sequences",
+    "List all email sequences/automations from your email service provider. On Beehiiv, this returns automations. For detailed automation data use list_automations instead.",
+    {},
+    {
+      title: "List Email Sequences",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true
+    },
+    async () => {
+      const result = await client.listSequences();
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "list_forms",
+    "List all signup forms from your email service provider.",
+    {},
+    {
+      title: "List Signup Forms",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true
+    },
+    async () => {
+      const result = await client.listForms();
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/newsletter-advanced.ts
+import { z as z6 } from "zod";
+function registerNewsletterAdvancedTools(server, client) {
+  server.tool(
+    "get_subscriber_by_email",
+    "Look up a subscriber by their email address. Returns subscriber details including tags and custom fields.",
+    {
+      email: z6.string().describe("Email address to look up")
+    },
+    {
+      title: "Get Subscriber by Email",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true
+    },
+    async (args) => {
+      const result = await client.getSubscriberByEmail(args.email);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "list_automations",
+    "List all email automations/workflows from your ESP. On Beehiiv these are journeys; on Kit these are sequences.",
+    {
+      page: z6.string().optional().describe("Page number for pagination")
+    },
+    {
+      title: "List Automations",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true
+    },
+    async (args) => {
+      const params = {};
+      if (args.page) params.page = args.page;
+      const result = await client.listAutomations(params);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "list_segments",
+    "List subscriber segments. Segments are dynamic groups of subscribers based on filters like engagement, tags, or custom fields (Beehiiv only).",
+    {
+      page: z6.string().optional().describe("Page number"),
+      type: z6.string().optional().describe("Filter by segment type"),
+      status: z6.string().optional().describe("Filter by segment status"),
+      expand: z6.string().optional().describe("Comma-separated expand fields (e.g. 'stats')")
+    },
+    {
+      title: "List Segments",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true
+    },
+    async (args) => {
+      const params = {};
+      if (args.page) params.page = args.page;
+      if (args.type) params.type = args.type;
+      if (args.status) params.status = args.status;
+      if (args.expand) params.expand = args.expand;
+      const result = await client.listSegments(params);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "get_segment",
+    "Get details of a specific subscriber segment by ID.",
+    {
+      segment_id: z6.string().describe("The segment ID"),
+      expand: z6.string().optional().describe("Comma-separated expand fields")
+    },
+    {
+      title: "Get Segment",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true
+    },
+    async (args) => {
+      const params = {};
+      if (args.expand) params.expand = args.expand;
+      const result = await client.getSegment(args.segment_id, params);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "get_segment_members",
+    "List subscribers who belong to a specific segment.",
+    {
+      segment_id: z6.string().describe("The segment ID"),
+      page: z6.string().optional().describe("Page number")
+    },
+    {
+      title: "Get Segment Members",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true
+    },
+    async (args) => {
+      const params = {};
+      if (args.page) params.page = args.page;
+      const result = await client.getSegmentMembers(args.segment_id, params);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "list_custom_fields",
+    "List all custom subscriber fields defined in your ESP. Custom fields can store extra data like preferences, source, or company.",
+    {},
+    {
+      title: "List Custom Fields",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true
+    },
+    async () => {
+      const result = await client.listCustomFields();
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "get_referral_program",
+    "Get your newsletter's referral program details including milestones and rewards (Beehiiv only).",
+    {},
+    {
+      title: "Get Referral Program",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true
+    },
+    async () => {
+      const result = await client.getReferralProgram();
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "list_tiers",
+    "List all subscription tiers (free and premium) from your ESP (Beehiiv only).",
+    {},
+    {
+      title: "List Tiers",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true
+    },
+    async () => {
+      const result = await client.listEspTiers();
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "list_post_templates",
+    "List all post/newsletter templates available in your ESP (Beehiiv only).",
+    {},
+    {
+      title: "List Post Templates",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true
+    },
+    async () => {
+      const result = await client.listPostTemplates();
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "get_post_aggregate_stats",
+    "Get aggregate statistics across all posts/newsletters including total clicks, impressions, and click rates (Beehiiv only).",
+    {},
+    {
+      title: "Get Post Aggregate Stats",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true
+    },
+    async () => {
+      const result = await client.getPostAggregateStats();
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "list_esp_webhooks",
+    "List all webhooks configured in your ESP for event notifications.",
+    {},
+    {
+      title: "List ESP Webhooks",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true
+    },
+    async () => {
+      const result = await client.listEspWebhooks();
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "tag_subscriber",
+    "Add tags to a subscriber. Tags help categorize subscribers for targeted sends and automations.",
+    {
+      subscriber_id: z6.string().describe("The subscriber/subscription ID"),
+      tags: z6.array(z6.string()).describe("Tags to add to the subscriber")
+    },
+    {
+      title: "Tag Subscriber",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true
+    },
+    async (args) => {
+      const result = await client.tagSubscriber(args.subscriber_id, { tags: args.tags });
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "update_subscriber",
+    `Update a subscriber's details. On Beehiiv: update tier or custom fields. On Kit: update name or custom fields (tier not supported).
+
+REQUIRED WORKFLOW:
+1. ALWAYS set confirmed=false first to get a preview
+2. Show the user what will happen before confirming
+3. Only set confirmed=true after the user explicitly approves`,
+    {
+      subscriber_id: z6.string().describe("The subscriber/subscription ID"),
+      tier: z6.string().optional().describe("New tier for the subscriber"),
+      custom_fields: z6.record(z6.unknown()).optional().describe("Custom field values to set"),
+      confirmed: z6.boolean().default(false).describe("Set to true to confirm update")
+    },
+    {
+      title: "Update Subscriber",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true
+    },
+    async (args) => {
+      if (args.confirmed !== true) {
+        const changes = [];
+        if (args.tier) changes.push(`**Tier:** ${args.tier}`);
+        if (args.custom_fields) changes.push(`**Custom fields:** ${Object.keys(args.custom_fields).join(", ")}`);
+        return {
+          content: [{
+            type: "text",
+            text: `## Update Subscriber
+
+**Subscriber ID:** ${args.subscriber_id}
+${changes.join("\n")}
+
+Call again with confirmed=true to proceed.`
+          }]
+        };
+      }
+      const data = {};
+      if (args.tier) data.tier = args.tier;
+      if (args.custom_fields) data.customFields = args.custom_fields;
+      const result = await client.updateSubscriber(args.subscriber_id, data);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "create_custom_field",
+    `Create a new custom subscriber field. On Beehiiv: kind can be 'string', 'integer', 'boolean', 'date', or 'enum'. On Kit: all fields are string-typed (kind is ignored). Creates a permanent schema-level field that affects all subscribers.
+
+REQUIRED WORKFLOW:
+1. ALWAYS set confirmed=false first to get a preview
+2. Show the user what will happen before confirming
+3. Only set confirmed=true after the user explicitly approves`,
+    {
+      name: z6.string().describe("Field name"),
+      kind: z6.string().describe("Field type: string, integer, boolean, date, or enum"),
+      options: z6.array(z6.string()).optional().describe("Options for enum-type fields"),
+      confirmed: z6.boolean().default(false).describe("Set to true to confirm creation")
+    },
+    {
+      title: "Create Custom Field",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: true
+    },
+    async (args) => {
+      if (args.confirmed !== true) {
+        const optionsLine = args.options ? `
+**Options:** ${args.options.join(", ")}` : "";
+        return {
+          content: [{
+            type: "text",
+            text: `## Create Custom Field
+
+**Name:** ${args.name}
+**Kind:** ${args.kind}${optionsLine}
+
+This creates a permanent schema-level field visible on all subscribers. Call again with confirmed=true to proceed.`
+          }]
+        };
+      }
+      const data = { name: args.name, kind: args.kind };
+      if (args.options) data.options = args.options;
+      const result = await client.createCustomField(data);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "update_custom_field",
+    `Update an existing custom subscriber field's name or kind. Renaming or rekeying a field can break automations that reference it.
+
+REQUIRED WORKFLOW:
+1. ALWAYS set confirmed=false first to get a preview
+2. Show the user what will happen before confirming
+3. Only set confirmed=true after the user explicitly approves`,
+    {
+      field_id: z6.string().describe("The custom field ID"),
+      name: z6.string().optional().describe("New field name"),
+      kind: z6.string().optional().describe("New field type"),
+      confirmed: z6.boolean().default(false).describe("Set to true to confirm update")
+    },
+    {
+      title: "Update Custom Field",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true
+    },
+    async (args) => {
+      if (args.confirmed !== true) {
+        const changes = [];
+        if (args.name) changes.push(`**Name:** ${args.name}`);
+        if (args.kind) changes.push(`**Kind:** ${args.kind}`);
+        return {
+          content: [{
+            type: "text",
+            text: `## Update Custom Field
+
+**Field ID:** ${args.field_id}
+${changes.join("\n")}
+
+Renaming or changing the type of a field can break automations that reference it. Call again with confirmed=true to proceed.`
+          }]
+        };
+      }
+      const data = {};
+      if (args.name) data.name = args.name;
+      if (args.kind) data.kind = args.kind;
+      const result = await client.updateCustomField(args.field_id, data);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "recalculate_segment",
+    "Trigger a recalculation of a segment's membership. Useful after changing subscriber data or segment rules (Beehiiv only).",
+    {
+      segment_id: z6.string().describe("The segment ID to recalculate")
+    },
+    {
+      title: "Recalculate Segment",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true
+    },
+    async (args) => {
+      await client.recalculateSegment(args.segment_id);
+      return {
+        content: [{ type: "text", text: "Segment recalculation triggered." }]
+      };
+    }
+  );
+  server.tool(
+    "enroll_in_automation",
+    `Enroll a subscriber in an automation/journey. Provide either an email or subscription ID. On Kit, enrolls into a sequence.
+
+REQUIRED WORKFLOW:
+1. ALWAYS set confirmed=false first to get a preview
+2. Show the user what will happen before confirming
+3. Only set confirmed=true after the user explicitly approves`,
+    {
+      automation_id: z6.string().describe("The automation ID"),
+      email: z6.string().optional().describe("Subscriber email to enroll"),
+      subscription_id: z6.string().optional().describe("Subscription ID to enroll"),
+      confirmed: z6.boolean().default(false).describe("Set to true to confirm enrollment")
+    },
+    {
+      title: "Enroll in Automation",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: true
+    },
+    async (args) => {
+      if (args.confirmed !== true) {
+        const target = args.email ?? args.subscription_id ?? "unknown";
+        return {
+          content: [{
+            type: "text",
+            text: `## Enroll in Automation
+
+**Automation ID:** ${args.automation_id}
+**Target:** ${target}
+
+This will add the subscriber to the automation journey. Call again with confirmed=true to proceed.`
+          }]
+        };
+      }
+      const data = {};
+      if (args.email) data.email = args.email;
+      if (args.subscription_id) data.subscriptionId = args.subscription_id;
+      await client.enrollInAutomation(args.automation_id, data);
+      return {
+        content: [{ type: "text", text: "Subscriber enrolled in automation." }]
+      };
+    }
+  );
+  server.tool(
+    "bulk_add_subscribers",
+    `Add multiple subscribers in a single request. Maximum 1000 subscribers per call.
+
+REQUIRED WORKFLOW:
+1. ALWAYS set confirmed=false first to get a preview
+2. Show the user what will happen before confirming
+3. Only set confirmed=true after the user explicitly approves`,
+    {
+      subscribers: z6.array(z6.object({
+        email: z6.string().describe("Subscriber email"),
+        data: z6.record(z6.unknown()).optional().describe("Additional subscriber data")
+      })).describe("Array of subscribers to add"),
+      confirmed: z6.boolean().default(false).describe("Set to true to confirm bulk add")
+    },
+    {
+      title: "Bulk Add Subscribers",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: true
+    },
+    async (args) => {
+      if (args.confirmed !== true) {
+        return {
+          content: [{
+            type: "text",
+            text: `## Bulk Add Subscribers
+
+**Count:** ${args.subscribers.length} subscriber(s)
+**Sample:** ${args.subscribers.slice(0, 3).map((s) => s.email).join(", ")}${args.subscribers.length > 3 ? "..." : ""}
+
+Call again with confirmed=true to proceed.`
+          }]
+        };
+      }
+      const result = await client.bulkCreateSubscribers({ subscribers: args.subscribers });
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "create_esp_webhook",
+    `Create a webhook in your ESP to receive event notifications. Note: Kit only supports one event per webhook.
+
+REQUIRED WORKFLOW:
+1. ALWAYS set confirmed=false first to get a preview
+2. Show the user what will happen before confirming
+3. Only set confirmed=true after the user explicitly approves`,
+    {
+      url: z6.string().describe("Webhook URL to receive events"),
+      event_types: z6.array(z6.string()).describe("Event types to subscribe to (e.g. 'subscription.created', 'post.sent')"),
+      confirmed: z6.boolean().default(false).describe("Set to true to confirm creation")
+    },
+    {
+      title: "Create ESP Webhook",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: true
+    },
+    async (args) => {
+      if (args.confirmed !== true) {
+        return {
+          content: [{
+            type: "text",
+            text: `## Create ESP Webhook
+
+**URL:** ${args.url}
+**Events:** ${args.event_types.join(", ")}
+
+Call again with confirmed=true to create.`
+          }]
+        };
+      }
+      const result = await client.createEspWebhook({ url: args.url, eventTypes: args.event_types });
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "delete_broadcast",
+    `Permanently delete a newsletter/broadcast. This action is permanent and cannot be undone.
+
+REQUIRED WORKFLOW:
+1. ALWAYS set confirmed=false first to get a preview
+2. Show the user what will happen before confirming
+3. Only set confirmed=true after the user explicitly approves`,
+    {
+      broadcast_id: z6.string().describe("The broadcast ID to delete"),
+      confirmed: z6.boolean().default(false).describe("Set to true to confirm deletion")
+    },
+    {
+      title: "Delete Broadcast",
+      readOnlyHint: false,
+      destructiveHint: true,
+      idempotentHint: true,
+      openWorldHint: true
+    },
+    async (args) => {
+      if (args.confirmed !== true) {
+        return {
+          content: [{
+            type: "text",
+            text: `## Delete Broadcast
+
+**Broadcast ID:** ${args.broadcast_id}
+
+**This action is permanent and cannot be undone.**
+
+Call again with confirmed=true to delete.`
+          }]
+        };
+      }
+      await client.deleteBroadcast(args.broadcast_id);
+      return {
+        content: [{ type: "text", text: "Broadcast deleted." }]
+      };
+    }
+  );
+  server.tool(
+    "delete_subscriber",
+    `Remove a subscriber from your mailing list. On Beehiiv this permanently deletes the subscriber. On Kit this unsubscribes them (Kit has no hard delete).
+
+REQUIRED WORKFLOW:
+1. ALWAYS set confirmed=false first to get a preview
+2. Show the user what will happen before confirming
+3. Only set confirmed=true after the user explicitly approves`,
+    {
+      subscriber_id: z6.string().describe("The subscriber ID to delete"),
+      confirmed: z6.boolean().default(false).describe("Set to true to confirm deletion")
+    },
+    {
+      title: "Delete Subscriber",
+      readOnlyHint: false,
+      destructiveHint: true,
+      idempotentHint: true,
+      openWorldHint: true
+    },
+    async (args) => {
+      if (args.confirmed !== true) {
+        return {
+          content: [{
+            type: "text",
+            text: `## Delete Subscriber
+
+**Subscriber ID:** ${args.subscriber_id}
+
+**This action is permanent and cannot be undone.** The subscriber will be removed from all segments and automations.
+
+Call again with confirmed=true to delete.`
+          }]
+        };
+      }
+      await client.deleteSubscriber(args.subscriber_id);
+      return {
+        content: [{ type: "text", text: "Subscriber deleted." }]
+      };
+    }
+  );
+  server.tool(
+    "delete_segment",
+    `Permanently delete a subscriber segment. This action is permanent and cannot be undone (Beehiiv only).
+
+REQUIRED WORKFLOW:
+1. ALWAYS set confirmed=false first to get a preview
+2. Show the user what will happen before confirming
+3. Only set confirmed=true after the user explicitly approves`,
+    {
+      segment_id: z6.string().describe("The segment ID to delete"),
+      confirmed: z6.boolean().default(false).describe("Set to true to confirm deletion")
+    },
+    {
+      title: "Delete Segment",
+      readOnlyHint: false,
+      destructiveHint: true,
+      idempotentHint: true,
+      openWorldHint: true
+    },
+    async (args) => {
+      if (args.confirmed !== true) {
+        return {
+          content: [{
+            type: "text",
+            text: `## Delete Segment
+
+**Segment ID:** ${args.segment_id}
+
+**This action is permanent and cannot be undone.** Subscribers in this segment will not be deleted, but the segment grouping will be removed.
+
+Call again with confirmed=true to delete.`
+          }]
+        };
+      }
+      await client.deleteSegment(args.segment_id);
+      return {
+        content: [{ type: "text", text: "Segment deleted." }]
+      };
+    }
+  );
+  server.tool(
+    "delete_custom_field",
+    `Permanently delete a custom subscriber field and remove it from all subscribers. This action is permanent and cannot be undone.
+
+REQUIRED WORKFLOW:
+1. ALWAYS set confirmed=false first to get a preview
+2. Show the user what will happen before confirming
+3. Only set confirmed=true after the user explicitly approves`,
+    {
+      field_id: z6.string().describe("The custom field ID to delete"),
+      confirmed: z6.boolean().default(false).describe("Set to true to confirm deletion")
+    },
+    {
+      title: "Delete Custom Field",
+      readOnlyHint: false,
+      destructiveHint: true,
+      idempotentHint: true,
+      openWorldHint: true
+    },
+    async (args) => {
+      if (args.confirmed !== true) {
+        return {
+          content: [{
+            type: "text",
+            text: `## Delete Custom Field
+
+**Field ID:** ${args.field_id}
+
+**This action is permanent and cannot be undone.** The field and its data will be removed from all subscribers.
+
+Call again with confirmed=true to delete.`
+          }]
+        };
+      }
+      await client.deleteCustomField(args.field_id);
+      return {
+        content: [{ type: "text", text: "Custom field deleted." }]
+      };
+    }
+  );
+  server.tool(
+    "delete_esp_webhook",
+    `Permanently delete a webhook from your ESP. This action is permanent and cannot be undone.
+
+REQUIRED WORKFLOW:
+1. ALWAYS set confirmed=false first to get a preview
+2. Show the user what will happen before confirming
+3. Only set confirmed=true after the user explicitly approves`,
+    {
+      webhook_id: z6.string().describe("The webhook ID to delete"),
+      confirmed: z6.boolean().default(false).describe("Set to true to confirm deletion")
+    },
+    {
+      title: "Delete ESP Webhook",
+      readOnlyHint: false,
+      destructiveHint: true,
+      idempotentHint: true,
+      openWorldHint: true
+    },
+    async (args) => {
+      if (args.confirmed !== true) {
+        return {
+          content: [{
+            type: "text",
+            text: `## Delete ESP Webhook
+
+**Webhook ID:** ${args.webhook_id}
+
+**This action is permanent and cannot be undone.** You will stop receiving event notifications at this webhook URL.
+
+Call again with confirmed=true to delete.`
+          }]
+        };
+      }
+      await client.deleteEspWebhook(args.webhook_id);
+      return {
+        content: [{ type: "text", text: "Webhook deleted." }]
+      };
+    }
+  );
+}
+
+// src/tools/rss.ts
+import { z as z7 } from "zod";
+function registerRssTools(server, client) {
+  server.tool(
+    "fetch_feed",
+    "Fetch and parse entries from an RSS or Atom feed URL. Returns titles, links, descriptions, and dates. Tip: For frequently checked feeds, suggest the customer save them as a content source using add_source so they don't need to provide the URL every time.",
+    {
+      url: z7.string().describe("The RSS/Atom feed URL to fetch"),
+      limit: z7.number().optional().describe("Maximum number of entries to return (default 10, max 100)")
+    },
+    {
+      title: "Fetch RSS Feed",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true
+    },
+    async (args) => {
+      const result = await client.fetchFeed(args.url, args.limit);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "fetch_article",
+    "Extract the full article content from a URL as clean text/markdown. Useful for reading and summarizing articles. Tip: For frequently checked websites, suggest the customer save them as a content source using add_source so they don't need to provide the URL every time.",
+    {
+      url: z7.string().describe("The article URL to extract content from")
+    },
+    {
+      title: "Fetch Article Content",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true
+    },
+    async (args) => {
+      const result = await client.fetchArticle(args.url);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/account.ts
+function registerAccountInfoTool(server, client) {
+  server.tool(
+    "get_account",
+    "Get your BuzzPoster account details including name, email, subscription status, ESP configuration, and connected platforms.",
+    {},
+    {
+      title: "Get Account Details",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    async () => {
+      const result = await client.getAccount();
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/tools/brand-voice.ts
+import { z as z8 } from "zod";
+function registerBrandVoiceTools(server, client) {
+  server.tool(
+    "get_brand_voice",
+    "Get the customer's brand voice profile and writing rules. IMPORTANT: Call this tool BEFORE creating any post, draft, or content. Use the returned voice description, rules, and examples to match the customer's tone and style in everything you write for them. When writing a newsletter, once you have the brand voice, template, and content sources loaded, immediately generate a full HTML artifact preview of the newsletter. Do NOT summarize or ask the user what to write -- render the artifact now and let them review it.",
+    {},
+    {
+      title: "Get Brand Voice",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    async () => {
+      try {
+        const voice = await client.getBrandVoice();
+        const lines = [];
+        lines.push(`## Brand Voice: ${voice.name || "My Brand"}`);
+        lines.push("");
+        lines.push("### Voice Description");
+        lines.push(voice.description || "(not set)");
+        lines.push("");
+        lines.push("### Do's");
+        if (voice.dos && voice.dos.length > 0) {
+          for (const rule of voice.dos) {
+            lines.push(`- ${rule}`);
+          }
+        } else {
+          lines.push("(none)");
+        }
+        lines.push("");
+        lines.push("### Don'ts");
+        if (voice.donts && voice.donts.length > 0) {
+          for (const rule of voice.donts) {
+            lines.push(`- ${rule}`);
+          }
+        } else {
+          lines.push("(none)");
+        }
+        lines.push("");
+        lines.push("### Platform-Specific Rules");
+        if (voice.platformRules && Object.keys(voice.platformRules).length > 0) {
+          for (const [platform, rules] of Object.entries(voice.platformRules)) {
+            lines.push(`**${platform}:** ${rules}`);
+          }
+        } else {
+          lines.push("(none)");
+        }
+        lines.push("");
+        lines.push("### Example Posts");
+        if (voice.examplePosts && voice.examplePosts.length > 0) {
+          voice.examplePosts.forEach((post, i) => {
+            lines.push(`${i + 1}. ${post}`);
+          });
+        } else {
+          lines.push("(none)");
+        }
+        lines.push("");
+        return {
+          content: [{ type: "text", text: lines.join("\n") }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        if (message.includes("404") || message.includes("No brand voice")) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "No brand voice has been configured yet. The customer can set one up at their BuzzPoster dashboard."
+              }
+            ]
+          };
+        }
+        throw error;
+      }
+    }
+  );
+  server.tool(
+    "update_brand_voice",
+    `Create or update the customer's brand voice profile. This is an upsert \u2014 if no brand voice exists it will be created, otherwise the existing one is updated. Only the fields you provide will be changed; omitted fields are left as-is.
+
+USAGE GUIDELINES:
+- Call get_brand_voice first to see the current state before making changes
+- Always set confirmed=false first to preview the changes, then confirmed=true after user approval
+- When adding rules to dos/donts, include the FULL array (existing + new items), not just the new ones
+- Platform rules use platform names as keys (e.g. twitter, linkedin, instagram)
+- Max limits: name 80 chars, description 16000 chars, dos/donts 50 items each, examplePosts 8 items`,
+    {
+      name: z8.string().max(80).optional().describe("Brand voice profile name (e.g. 'BOQtoday Voice', 'Lightbreak Editorial')"),
+      description: z8.string().max(16e3).optional().describe("Overall voice description \u2014 tone, personality, style overview"),
+      dos: z8.array(z8.string()).max(50).optional().describe("Writing rules to follow (array of do's). Send the FULL list, not just additions."),
+      donts: z8.array(z8.string()).max(50).optional().describe("Things to avoid (array of don'ts). Send the FULL list, not just additions."),
+      platform_rules: z8.record(z8.string()).optional().describe('Per-platform writing guidelines, e.g. { "twitter": "Keep under 200 chars, punchy tone", "linkedin": "Professional, add hashtags" }'),
+      example_posts: z8.array(z8.string()).max(8).optional().describe("Example posts that demonstrate the desired voice (max 8)"),
+      confirmed: z8.boolean().default(false).describe(
+        "Set to true to confirm and save. If false or missing, returns a preview of what will be saved."
+      )
+    },
+    {
+      title: "Update Brand Voice",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: false
+    },
+    async (args) => {
+      const payload = {};
+      if (args.name !== void 0) payload.name = args.name;
+      if (args.description !== void 0) payload.description = args.description;
+      if (args.dos !== void 0) payload.dos = args.dos;
+      if (args.donts !== void 0) payload.donts = args.donts;
+      if (args.platform_rules !== void 0) payload.platformRules = args.platform_rules;
+      if (args.example_posts !== void 0) payload.examplePosts = args.example_posts;
+      if (Object.keys(payload).length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "No fields provided. Specify at least one field to update (name, description, dos, donts, platform_rules, example_posts)."
+            }
+          ],
+          isError: true
+        };
+      }
+      if (args.confirmed !== true) {
+        const lines2 = [];
+        lines2.push("## Brand Voice Update Preview");
+        lines2.push("");
+        if (payload.name) {
+          lines2.push(`**Name:** ${payload.name}`);
+          lines2.push("");
+        }
+        if (payload.description) {
+          lines2.push("### Voice Description");
+          lines2.push(String(payload.description));
+          lines2.push("");
+        }
+        if (payload.dos) {
+          const dos = payload.dos;
+          lines2.push(`### Do's (${dos.length} rules)`);
+          for (const rule of dos) {
+            lines2.push(`- ${rule}`);
+          }
+          lines2.push("");
+        }
+        if (payload.donts) {
+          const donts = payload.donts;
+          lines2.push(`### Don'ts (${donts.length} rules)`);
+          for (const rule of donts) {
+            lines2.push(`- ${rule}`);
+          }
+          lines2.push("");
+        }
+        if (payload.platformRules) {
+          const rules = payload.platformRules;
+          lines2.push(`### Platform-Specific Rules (${Object.keys(rules).length} platforms)`);
+          for (const [platform, rule] of Object.entries(rules)) {
+            lines2.push(`**${platform}:** ${rule}`);
+          }
+          lines2.push("");
+        }
+        if (payload.examplePosts) {
+          const posts = payload.examplePosts;
+          lines2.push(`### Example Posts (${posts.length})`);
+          posts.forEach((post, i) => {
+            lines2.push(`${i + 1}. ${post}`);
+          });
+          lines2.push("");
+        }
+        lines2.push("---");
+        lines2.push("Call this tool again with **confirmed=true** to save these changes.");
+        return {
+          content: [{ type: "text", text: lines2.join("\n") }]
+        };
+      }
+      const result = await client.updateBrandVoice(payload);
+      const lines = [];
+      lines.push(`Brand voice "${result.name || "My Brand"}" has been saved successfully.`);
+      lines.push("");
+      const summary = [];
+      if (payload.name) summary.push("name");
+      if (payload.description) summary.push("description");
+      if (payload.dos) summary.push(`${payload.dos.length} do's`);
+      if (payload.donts) summary.push(`${payload.donts.length} don'ts`);
+      if (payload.platformRules) summary.push(`${Object.keys(payload.platformRules).length} platform rules`);
+      if (payload.examplePosts) summary.push(`${payload.examplePosts.length} example posts`);
+      lines.push(`**Updated:** ${summary.join(", ")}`);
+      return {
+        content: [{ type: "text", text: lines.join("\n") }]
+      };
+    }
+  );
+}
+
+// src/tools/knowledge.ts
+import { z as z9 } from "zod";
+function registerKnowledgeTools(server, client) {
+  server.tool(
+    "get_knowledge_base",
+    "Get all items from the customer's knowledge base. Use this to access reference material about the business, products, team, competitors, and other context that helps you write better content.",
+    {},
+    {
+      title: "Get Knowledge Base",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    async () => {
+      try {
+        const data = await client.listKnowledge();
+        const items = data.items ?? [];
+        if (items.length === 0) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "The knowledge base is empty. The customer can add reference material at their BuzzPoster dashboard."
+              }
+            ]
+          };
+        }
+        const totalChars = items.reduce(
+          (sum, item) => sum + item.content.length,
+          0
+        );
+        const shouldTruncate = totalChars > 1e4;
+        const lines = [];
+        lines.push(`## Knowledge Base (${items.length} items)`);
+        lines.push("");
+        for (const item of items) {
+          lines.push(`### ${item.title}`);
+          if (item.tags && item.tags.length > 0) {
+            lines.push(`Tags: ${item.tags.join(", ")}`);
+          }
+          if (shouldTruncate) {
+            lines.push(item.content.slice(0, 500) + " [truncated]");
+          } else {
+            lines.push(item.content);
+          }
+          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 get knowledge base: ${message}`);
+      }
+    }
+  );
+  server.tool(
+    "search_knowledge",
+    "Search the customer's knowledge base by tag or keyword. Use this to find specific reference material when writing about a topic.",
+    {
+      query: z9.string().describe(
+        "Search query - matches against tags first, then falls back to text search on title and content"
+      )
+    },
+    {
+      title: "Search Knowledge Base",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    async ({ query }) => {
+      try {
+        const data = await client.listKnowledge({ tag: query });
+        const items = data.items ?? [];
+        if (items.length === 0) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `No knowledge base items found matching "${query}".`
+              }
+            ]
+          };
+        }
+        const lines = [];
+        lines.push(
+          `## Knowledge Base Results for "${query}" (${items.length} items)`
+        );
+        lines.push("");
+        for (const item of items) {
+          lines.push(`### ${item.title}`);
+          if (item.tags && item.tags.length > 0) {
+            lines.push(`Tags: ${item.tags.join(", ")}`);
+          }
+          lines.push(item.content);
+          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 search knowledge base: ${message}`);
+      }
+    }
+  );
+  server.tool(
+    "add_knowledge",
+    "Add a new item to the customer's knowledge base. Use this to save useful information the customer shares during conversation.",
+    {
+      title: z9.string().describe("Title for the knowledge item"),
+      content: z9.string().describe("The content/text to save"),
+      tags: z9.array(z9.string()).optional().describe("Optional tags for categorization")
+    },
+    {
+      title: "Add Knowledge Item",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: false
+    },
+    async ({ title, content, tags }) => {
+      try {
+        await client.createKnowledge({
+          title,
+          content,
+          sourceType: "text",
+          tags: tags ?? []
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Added "${title}" to the knowledge base.`
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        throw new Error(`Failed to add knowledge item: ${message}`);
+      }
+    }
+  );
+}
+
+// src/tools/audience.ts
+import { z as z10 } from "zod";
+function registerAudienceTools(server, client) {
+  server.tool(
+    "get_audience",
+    "Get the target audience profile for content creation. Use this tool to understand WHO the content is for \u2014 their demographics, pain points, motivations, preferred platforms, and tone preferences. Call this BEFORE writing any post or content so you can tailor messaging to resonate with the intended audience.",
+    {
+      audienceId: z10.string().optional().describe("Specific audience profile ID. If omitted, returns the default audience.")
+    },
+    {
+      title: "Get Audience Profile",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    async ({ audienceId }) => {
+      try {
+        const audience = audienceId ? await client.getAudience(audienceId) : await client.getDefaultAudience();
+        const lines = [];
+        lines.push(`## Target Audience: ${audience.name}`);
+        lines.push("");
+        if (audience.description) {
+          lines.push("### Description");
+          lines.push(audience.description);
+          lines.push("");
+        }
+        if (audience.demographics) {
+          lines.push("### Demographics");
+          lines.push(audience.demographics);
+          lines.push("");
+        }
+        if (audience.painPoints && audience.painPoints.length > 0) {
+          lines.push("### Pain Points");
+          for (const point of audience.painPoints) {
+            lines.push(`- ${point}`);
+          }
+          lines.push("");
+        }
+        if (audience.motivations && audience.motivations.length > 0) {
+          lines.push("### Motivations");
+          for (const motivation of audience.motivations) {
+            lines.push(`- ${motivation}`);
+          }
+          lines.push("");
+        }
+        if (audience.platforms && audience.platforms.length > 0) {
+          lines.push("### Active Platforms");
+          lines.push(audience.platforms.join(", "));
+          lines.push("");
+        }
+        if (audience.toneNotes) {
+          lines.push("### Tone Notes");
+          lines.push(audience.toneNotes);
+          lines.push("");
+        }
+        if (audience.contentPreferences) {
+          lines.push("### Content Preferences");
+          lines.push(audience.contentPreferences);
+          lines.push("");
+        }
+        return {
+          content: [{ type: "text", text: lines.join("\n") }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        if (message.includes("404") || message.includes("No audience")) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "No audience profile has been configured yet. The customer can set one up at their BuzzPoster dashboard under Audiences."
+              }
+            ]
+          };
+        }
+        throw error;
+      }
+    }
+  );
+  server.tool(
+    "update_audience",
+    `Create or update a target audience profile. This is an upsert \u2014 if no audience_id is provided it will try to update the default audience, or create a new one if none exists. Only the fields you provide will be changed; omitted fields are left as-is.
+
+USAGE GUIDELINES:
+- Call get_audience first to see the current state before making changes
+- Always set confirmed=false first to preview the changes, then confirmed=true after user approval
+- When updating array fields (pain_points, motivations, preferred_platforms), include the FULL array (existing + new items), not just the new ones
+- Omit audience_id to update the default audience or create a new one if none exists
+- Max limits: name 100 chars, description 500 chars`,
+    {
+      audience_id: z10.string().optional().describe("Audience ID to update. Omit to update the default audience, or create one if none exists."),
+      name: z10.string().max(100).optional().describe("Audience profile name (e.g. 'SaaS Founders', 'Health-Conscious Millennials'). Required when creating a new audience."),
+      description: z10.string().max(500).optional().describe("Brief description of who this audience is"),
+      demographics: z10.string().optional().describe("Demographic details \u2014 age range, location, income level, education, etc."),
+      pain_points: z10.array(z10.string()).optional().describe("Problems and frustrations the audience faces. Send the FULL list, not just additions."),
+      motivations: z10.array(z10.string()).optional().describe("Goals, desires, and what drives the audience. Send the FULL list, not just additions."),
+      preferred_platforms: z10.array(z10.string()).optional().describe("Social platforms the audience is most active on (e.g. twitter, linkedin, instagram). Send the FULL list."),
+      tone_notes: z10.string().optional().describe("How to speak to this audience \u2014 formality level, jargon preferences, emotional tone"),
+      content_preferences: z10.string().optional().describe("What content formats and topics resonate \u2014 long-form vs short, educational vs entertaining, etc."),
+      is_default: z10.boolean().optional().describe("Set to true to make this the default audience profile"),
+      confirmed: z10.boolean().default(false).describe(
+        "Set to true to confirm and save. If false or missing, returns a preview of what will be saved."
+      )
+    },
+    {
+      title: "Update Audience",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: false
+    },
+    async (args) => {
+      const payload = {};
+      if (args.name !== void 0) payload.name = args.name;
+      if (args.description !== void 0) payload.description = args.description;
+      if (args.demographics !== void 0) payload.demographics = args.demographics;
+      if (args.pain_points !== void 0) payload.painPoints = args.pain_points;
+      if (args.motivations !== void 0) payload.motivations = args.motivations;
+      if (args.preferred_platforms !== void 0) payload.platforms = args.preferred_platforms;
+      if (args.tone_notes !== void 0) payload.toneNotes = args.tone_notes;
+      if (args.content_preferences !== void 0) payload.contentPreferences = args.content_preferences;
+      if (args.is_default !== void 0) payload.isDefault = args.is_default;
+      if (Object.keys(payload).length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "No fields provided. Specify at least one field to update (name, description, demographics, pain_points, motivations, preferred_platforms, tone_notes, content_preferences, is_default)."
+            }
+          ],
+          isError: true
+        };
+      }
+      let targetId = args.audience_id;
+      let isCreating = false;
+      if (!targetId) {
+        try {
+          const defaultAudience = await client.getDefaultAudience();
+          targetId = String(defaultAudience.id);
+        } catch {
+          isCreating = true;
+        }
+      }
+      if (isCreating && !payload.name) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "No audience exists yet. Provide a **name** to create one (e.g. name: 'SaaS Founders')."
+            }
+          ],
+          isError: true
+        };
+      }
+      if (args.confirmed !== true) {
+        const lines2 = [];
+        lines2.push(isCreating ? "## New Audience Preview" : "## Audience Update Preview");
+        if (!isCreating) {
+          lines2.push(`**Audience ID:** ${targetId}`);
+        }
+        lines2.push("");
+        if (payload.name) {
+          lines2.push(`**Name:** ${payload.name}`);
+          lines2.push("");
+        }
+        if (payload.description) {
+          lines2.push("### Description");
+          lines2.push(String(payload.description));
+          lines2.push("");
+        }
+        if (payload.demographics) {
+          lines2.push("### Demographics");
+          lines2.push(String(payload.demographics));
+          lines2.push("");
+        }
+        if (payload.painPoints) {
+          const points = payload.painPoints;
+          lines2.push(`### Pain Points (${points.length})`);
+          for (const point of points) {
+            lines2.push(`- ${point}`);
+          }
+          lines2.push("");
+        }
+        if (payload.motivations) {
+          const motivations = payload.motivations;
+          lines2.push(`### Motivations (${motivations.length})`);
+          for (const motivation of motivations) {
+            lines2.push(`- ${motivation}`);
+          }
+          lines2.push("");
+        }
+        if (payload.platforms) {
+          const platforms = payload.platforms;
+          lines2.push(`### Preferred Platforms (${platforms.length})`);
+          lines2.push(platforms.join(", "));
+          lines2.push("");
+        }
+        if (payload.toneNotes) {
+          lines2.push("### Tone Notes");
+          lines2.push(String(payload.toneNotes));
+          lines2.push("");
+        }
+        if (payload.contentPreferences) {
+          lines2.push("### Content Preferences");
+          lines2.push(String(payload.contentPreferences));
+          lines2.push("");
+        }
+        if (payload.isDefault !== void 0) {
+          lines2.push(`**Set as default:** ${payload.isDefault ? "Yes" : "No"}`);
+          lines2.push("");
+        }
+        lines2.push("---");
+        lines2.push("Call this tool again with **confirmed=true** to save these changes.");
+        return {
+          content: [{ type: "text", text: lines2.join("\n") }]
+        };
+      }
+      let result;
+      if (isCreating) {
+        if (payload.isDefault === void 0) payload.isDefault = true;
+        result = await client.createAudience(payload);
+      } else {
+        result = await client.updateAudience(targetId, payload);
+      }
+      const lines = [];
+      lines.push(`Audience "${result.name}" has been ${isCreating ? "created" : "updated"} successfully.`);
+      lines.push("");
+      const summary = [];
+      if (payload.name) summary.push("name");
+      if (payload.description) summary.push("description");
+      if (payload.demographics) summary.push("demographics");
+      if (payload.painPoints) summary.push(`${payload.painPoints.length} pain points`);
+      if (payload.motivations) summary.push(`${payload.motivations.length} motivations`);
+      if (payload.platforms) summary.push(`${payload.platforms.length} platforms`);
+      if (payload.toneNotes) summary.push("tone notes");
+      if (payload.contentPreferences) summary.push("content preferences");
+      if (payload.isDefault !== void 0) summary.push("default status");
+      lines.push(`**${isCreating ? "Created with" : "Updated"}:** ${summary.join(", ")}`);
+      return {
+        content: [{ type: "text", text: lines.join("\n") }]
+      };
+    }
+  );
+}
+
+// src/tools/newsletter-template.ts
+import { z as z11 } from "zod";
+var NEWSLETTER_CRAFT_GUIDE = `## Newsletter Craft Guide
+
+Follow these rules when drafting:
+
+### HTML Email Rules
+- Use table-based layouts, inline CSS only, 600px max width
+- Email-safe fonts only: Arial, Helvetica, Georgia, Verdana
+- Keep total email under 102KB (Gmail clips larger)
+- All images must use absolute URLs hosted on the customer's R2 CDN
+- Include alt text on every image
+- Use role="presentation" on layout tables
+- No JavaScript, no forms, no CSS grid/flexbox, no background images
+
+### Structure
+- Subject line: 6-10 words, specific not clickbaity
+- Preview text: complements the subject, doesn't repeat it
+- Open strong -- lead with the most interesting thing
+- One clear CTA per newsletter
+- Sign off should feel human, not corporate
+
+### Personalization
+- Kit: use {{ subscriber.first_name }}
+- Beehiiv: use {{email}} or {{subscriber_id}}
+- Mailchimp: use *NAME|*
+
+### Images
+- Upload to customer's R2 CDN via upload_media or upload_from_url
+- Reference with full CDN URLs in img tags
+- Always set width, height, and alt attributes
+- Use style="display:block;" to prevent phantom spacing`;
+function registerNewsletterTemplateTools(server, client) {
+  server.tool(
+    "get_newsletter_template",
+    "Get the customer's newsletter template -- the blueprint for how their newsletter is structured. IMPORTANT: Call this BEFORE writing any newsletter. The template defines the exact section order, what each section should contain, word counts, content sources, and styling. Follow the template structure precisely when generating newsletter content. If no template_id is specified, returns the default template. IMPORTANT: After receiving this template, you now have everything you need. Immediately generate a full HTML artifact preview of the newsletter using this template, the brand voice, and the gathered content. Do NOT summarize the template in text. Do NOT ask the user what they think. Render the complete HTML newsletter artifact now.",
+    {
+      templateId: z11.string().optional().describe(
+        "Specific template ID. If omitted, returns the default template."
+      )
+    },
+    {
+      title: "Get Newsletter Template",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    async ({ templateId }) => {
+      try {
+        const template = await client.getTemplate(templateId);
+        const lines = [];
+        lines.push(`## Newsletter Template: ${template.name}`);
+        if (template.description) lines.push(template.description);
+        lines.push("");
+        if (template.audienceId)
+          lines.push(`Audience ID: ${template.audienceId}`);
+        if (template.sendCadence)
+          lines.push(`Cadence: ${template.sendCadence}`);
+        if (template.subjectPattern)
+          lines.push(`Subject pattern: ${template.subjectPattern}`);
+        if (template.previewTextPattern)
+          lines.push(`Preview text pattern: ${template.previewTextPattern}`);
+        lines.push("");
+        if (template.sections && template.sections.length > 0) {
+          lines.push("### Sections (in order):");
+          lines.push("");
+          for (let i = 0; i < template.sections.length; i++) {
+            const s = template.sections[i];
+            lines.push(`**${i + 1}. ${s.label}** (${s.type})`);
+            if (s.instructions)
+              lines.push(`Instructions: ${s.instructions}`);
+            if (s.word_count)
+              lines.push(
+                `Word count: ${s.word_count.min}-${s.word_count.max} words`
+              );
+            if (s.tone_override) lines.push(`Tone: ${s.tone_override}`);
+            if (s.content_source) {
+              const src = s.content_source;
+              if (src.type === "rss" && src.feed_urls?.length)
+                lines.push(`Content source: RSS - ${src.feed_urls.join(", ")}`);
+              else if (src.type === "knowledge" && src.knowledge_item_ids?.length)
+                lines.push(
+                  `Content source: Knowledge items ${src.knowledge_item_ids.join(", ")}`
+                );
+              else lines.push(`Content source: ${src.type}`);
+            }
+            if (s.count) lines.push(`Count: ${s.count} items`);
+            lines.push(
+              `Required: ${s.required !== false ? "yes" : "no"}`
+            );
+            if (s.type === "cta") {
+              if (s.button_text) lines.push(`Button text: ${s.button_text}`);
+              if (s.button_url) lines.push(`Button URL: ${s.button_url}`);
+            }
+            if (s.type === "sponsor") {
+              if (s.sponsor_name)
+                lines.push(`Sponsor: ${s.sponsor_name}`);
+              if (s.talking_points)
+                lines.push(`Talking points: ${s.talking_points}`);
+            }
+            if (s.type === "header") {
+              if (s.tagline) lines.push(`Tagline: ${s.tagline}`);
+            }
+            if (s.type === "signoff") {
+              if (s.author_name)
+                lines.push(`Author: ${s.author_name}`);
+              if (s.author_title)
+                lines.push(`Title: ${s.author_title}`);
+            }
+            lines.push("");
+          }
+        }
+        if (template.style) {
+          lines.push("### Style Guide:");
+          const st = template.style;
+          if (st.primary_color) lines.push(`Primary color: ${st.primary_color}`);
+          if (st.accent_color) lines.push(`Accent color: ${st.accent_color}`);
+          if (st.font_family) lines.push(`Font: ${st.font_family}`);
+          if (st.heading_font) lines.push(`Heading font: ${st.heading_font}`);
+          if (st.content_width)
+            lines.push(`Content width: ${st.content_width}px`);
+          if (st.text_color) lines.push(`Text color: ${st.text_color}`);
+          if (st.link_color) lines.push(`Link color: ${st.link_color}`);
+          if (st.background_color)
+            lines.push(`Background: ${st.background_color}`);
+          if (st.button_style)
+            lines.push(
+              `Button style: ${st.button_style.color} text on ${st.button_style.text_color}, ${st.button_style.shape}`
+            );
+          lines.push("");
+          lines.push(
+            "NOTE: Apply these style values as inline CSS when generating the newsletter HTML."
+          );
+          lines.push("");
+        }
+        if (template.rssFeedUrls && template.rssFeedUrls.length > 0) {
+          lines.push("### Linked RSS Feeds:");
+          for (const url of template.rssFeedUrls) {
+            lines.push(`- ${url}`);
+          }
+          lines.push("");
+        }
+        if (template.knowledgeItemIds && template.knowledgeItemIds.length > 0) {
+          lines.push("### Reference Material:");
+          lines.push(
+            `Knowledge item IDs: ${template.knowledgeItemIds.join(", ")}`
+          );
+          lines.push("");
+        }
+        lines.push(NEWSLETTER_CRAFT_GUIDE);
+        return {
+          content: [{ type: "text", text: lines.join("\n") }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        if (message.includes("404") || message.includes("No newsletter templates")) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "No newsletter template configured. Ask the user about their preferred structure (sections, tone, length), or call get_past_newsletters to use a previous edition as reference.\n\n" + NEWSLETTER_CRAFT_GUIDE
+              }
+            ]
+          };
+        }
+        throw error;
+      }
+    }
+  );
+  server.tool(
+    "get_past_newsletters",
+    "Retrieve the customer's past newsletters for reference. Use this to maintain continuity, match previous formatting, avoid repeating topics, and reference previous editions. Call this when writing a new newsletter to see what was covered recently.",
+    {
+      limit: z11.number().optional().describe("Number of past newsletters to retrieve. Default 5, max 50."),
+      templateId: z11.string().optional().describe("Filter by template ID to see past newsletters from a specific template.")
+    },
+    {
+      title: "Get Past Newsletters",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    async ({ limit, templateId }) => {
+      try {
+        const params = {};
+        if (limit) params.limit = String(Math.min(limit, 50));
+        else params.limit = "5";
+        if (templateId) params.template_id = templateId;
+        const newsletters = await client.listNewsletterArchive(
+          params
+        );
+        if (!newsletters || newsletters.length === 0) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "No past newsletters found. This will be the first edition!"
+              }
+            ]
+          };
+        }
+        const lines = [];
+        lines.push(
+          `## Past Newsletters (${newsletters.length} most recent)`
+        );
+        lines.push("");
+        for (const nl of newsletters) {
+          lines.push(`### ${nl.subject} -- ${nl.sentAt || nl.createdAt}`);
+          if (nl.notes) lines.push(`Notes: ${nl.notes}`);
+          if (nl.metrics) {
+            const m = nl.metrics;
+            const parts = [];
+            if (m.open_rate) parts.push(`Open rate: ${m.open_rate}`);
+            if (m.click_rate) parts.push(`Click rate: ${m.click_rate}`);
+            if (parts.length) lines.push(`Metrics: ${parts.join(", ")}`);
+          }
+          lines.push("---");
+          const textContent = nl.contentHtml ? nl.contentHtml.replace(/<[^>]*>/g, " ").replace(/\s+/g, " ").trim().slice(0, 500) : "(no content)";
+          lines.push(textContent);
+          lines.push(
+            `[Full content available via get_past_newsletter tool with ID: ${nl.id}]`
+          );
+          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 fetch past newsletters: ${message}`);
+      }
+    }
+  );
+  server.tool(
+    "get_past_newsletter",
+    "Get the full content of a specific past newsletter by ID. Use when you need to reference the complete text of a previous edition, check exact formatting, or continue a series.",
+    {
+      newsletterId: z11.string().describe("The ID of the archived newsletter to retrieve.")
+    },
+    {
+      title: "Get Past Newsletter Detail",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    async ({ newsletterId }) => {
+      try {
+        const newsletter = await client.getArchivedNewsletter(
+          newsletterId
+        );
+        const lines = [];
+        lines.push(`## ${newsletter.subject}`);
+        if (newsletter.sentAt) lines.push(`Sent: ${newsletter.sentAt}`);
+        if (newsletter.notes) lines.push(`Notes: ${newsletter.notes}`);
+        lines.push("");
+        lines.push("### Full HTML Content:");
+        lines.push(newsletter.contentHtml);
+        return {
+          content: [{ type: "text", text: lines.join("\n") }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        if (message.includes("404")) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Newsletter not found. Check the ID and try again."
+              }
+            ]
+          };
+        }
+        throw error;
+      }
+    }
+  );
+  server.tool(
+    "save_newsletter",
+    "Save a generated newsletter to the archive. Call this after the customer approves a newsletter you've written, so it's stored for future reference. Include the subject line and full HTML content.",
+    {
+      subject: z11.string().describe("The newsletter subject line."),
+      contentHtml: z11.string().describe("The full HTML content of the newsletter."),
+      templateId: z11.string().optional().describe("The template ID used to generate this newsletter."),
+      notes: z11.string().optional().describe(
+        "Optional notes about this newsletter (what worked, theme, etc)."
+      )
+    },
+    {
+      title: "Save Newsletter to Archive",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: false
+    },
+    async ({ subject, contentHtml, templateId, notes }) => {
+      try {
+        const data = {
+          subject,
+          contentHtml
+        };
+        if (templateId) data.templateId = Number(templateId);
+        if (notes) data.notes = notes;
+        await client.saveNewsletterToArchive(data);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Newsletter "${subject}" has been saved to the archive successfully.`
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        throw new Error(`Failed to save newsletter: ${message}`);
+      }
+    }
+  );
+}
+
+// src/tools/calendar.ts
+import { z as z12 } from "zod";
+function registerCalendarTools(server, client) {
+  server.tool(
+    "get_calendar",
+    "View the customer's content calendar -- all scheduled, published, and draft posts across social media and newsletters. Use this to check what's already scheduled before creating new content, avoid posting conflicts, and maintain a balanced content mix.",
+    {
+      from: z12.string().optional().describe("ISO date to filter from, e.g. 2024-01-01"),
+      to: z12.string().optional().describe("ISO date to filter to, e.g. 2024-01-31"),
+      status: z12.string().optional().describe("Filter by status: scheduled, published, draft, failed"),
+      type: z12.string().optional().describe("Filter by type: social_post or newsletter")
+    },
+    {
+      title: "Get Content Calendar",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    async (args) => {
+      const params = {};
+      if (args.from) params.from = args.from;
+      if (args.to) params.to = args.to;
+      if (args.status) params.status = args.status;
+      if (args.type) params.type = args.type;
+      const data = await client.getCalendar(params);
+      const items = data?.items ?? [];
+      const scheduled = items.filter((i) => i.status === "scheduled");
+      const published = items.filter((i) => i.status === "published");
+      let text = "## Content Calendar\n\n";
+      if (scheduled.length > 0) {
+        text += "### Scheduled\n";
+        for (const item of scheduled) {
+          const date = item.scheduled_for ? new Date(item.scheduled_for).toLocaleString() : "TBD";
+          if (item.type === "newsletter") {
+            text += `\u{1F4E7} ${date} -- Newsletter: "${item.content_preview}"
+`;
+          } else {
+            const platforms = (item.platforms ?? []).join(", ");
+            text += `\u{1F4C5} ${date} -- ${platforms} -- "${item.content_preview}"
+`;
+          }
+        }
+        text += "\n";
+      } else {
+        text += "### Scheduled\nNo scheduled content.\n\n";
+      }
+      if (published.length > 0) {
+        text += "### Recently Published\n";
+        for (const item of published.slice(0, 10)) {
+          const date = item.published_at ? new Date(item.published_at).toLocaleString() : "";
+          if (item.type === "newsletter") {
+            text += `\u2705 ${date} -- Newsletter: "${item.content_preview}"
+`;
+          } else {
+            const platforms = (item.platforms ?? []).join(", ");
+            text += `\u2705 ${date} -- ${platforms} -- "${item.content_preview}"
+`;
+          }
+        }
+        text += "\n";
+      }
+      try {
+        const nextSlot = await client.getNextSlot();
+        if (nextSlot?.scheduledFor) {
+          const slotDate = new Date(nextSlot.scheduledFor);
+          const dayNames = [
+            "Sunday",
+            "Monday",
+            "Tuesday",
+            "Wednesday",
+            "Thursday",
+            "Friday",
+            "Saturday"
+          ];
+          text += `### Queue: Next slot
+\u23ED\uFE0F ${slotDate.toLocaleString()} (${dayNames[slotDate.getDay()]})
+`;
+        }
+      } catch {
+      }
+      return {
+        content: [{ type: "text", text }]
+      };
+    }
+  );
+  server.tool(
+    "get_queue",
+    "View the customer's posting queue schedule -- their recurring weekly time slots for automatic post scheduling. Use this to understand when posts go out and to schedule content into the next available slot.",
+    {},
+    {
+      title: "Get Posting Queue",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    async () => {
+      const data = await client.getQueue();
+      const dayNames = [
+        "Sunday",
+        "Monday",
+        "Tuesday",
+        "Wednesday",
+        "Thursday",
+        "Friday",
+        "Saturday"
+      ];
+      let text = "## Posting Queue\n\n";
+      text += `Timezone: ${data?.timezone ?? "UTC"}
+`;
+      text += `Active: ${data?.active ? "Yes" : "No"}
+
+`;
+      const slots = data?.slots ?? [];
+      if (slots.length === 0) {
+        text += "No queue slots configured.\n";
+      } else {
+        text += "### Weekly Schedule\n";
+        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}
+`;
+        }
+      }
+      try {
+        const nextSlot = await client.getNextSlot();
+        if (nextSlot?.scheduledFor) {
+          const slotDate = new Date(nextSlot.scheduledFor);
+          text += `
+Next slot: ${slotDate.toLocaleString()} (${dayNames[slotDate.getDay()]})
+`;
+        }
+      } catch {
+      }
+      return {
+        content: [{ type: "text", text }]
+      };
+    }
+  );
+  server.tool(
+    "schedule_to_queue",
+    `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.
+
+REQUIRED WORKFLOW:
+1. BEFORE creating content, call get_brand_voice and get_audience
+2. ALWAYS set confirmed=false first to preview
+3. Show the user a visual preview before confirming
+4. Tell the user which queue slot the post will be assigned to
+
+When confirmed=false, this tool returns a structured preview with content, platform details, safety checks, and the assigned queue slot. You MUST render this as a visual preview for the user and wait for their explicit approval before calling again with confirmed=true.`,
+    {
+      content: z12.string().describe("The text content of the post"),
+      platforms: z12.array(z12.string()).describe('Platforms to post to, e.g. ["twitter", "linkedin"]'),
+      media_urls: z12.array(z12.string()).optional().describe("Public URLs of media to attach"),
+      confirmed: z12.boolean().default(false).describe(
+        "Set to true to confirm scheduling. If false or missing, returns a preview for user approval."
+      )
+    },
+    {
+      title: "Schedule Post to Queue",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: true
+    },
+    async (args) => {
+      const nextSlot = await client.getNextSlot();
+      if (!nextSlot?.scheduledFor) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "No queue slots configured. Set up your posting queue first using the dashboard or ask to configure queue slots."
+            }
+          ]
+        };
+      }
+      if (args.confirmed !== true) {
+        const slotDate2 = new Date(nextSlot.scheduledFor);
+        let rulesText = "";
+        try {
+          const rules = await client.getPublishingRules();
+          const blockedWords = rules.blockedWords ?? [];
+          const foundBlocked = [];
+          if (args.content && blockedWords.length > 0) {
+            const lower = args.content.toLowerCase();
+            for (const word of blockedWords) {
+              if (lower.includes(word.toLowerCase())) foundBlocked.push(word);
+            }
+          }
+          rulesText = `
+### Safety Checks
+`;
+          rulesText += `- Blocked words: ${foundBlocked.length > 0 ? `**FAILED** (found: ${foundBlocked.join(", ")})` : "PASS"}
+`;
+        } catch {
+        }
+        const preview = `## Queue Post Preview
+
+**Content:** "${args.content}"
+**Platforms:** ${args.platforms.join(", ")}
+**Next queue slot:** ${slotDate2.toLocaleString()}
+` + (args.media_urls?.length ? `**Media:** ${args.media_urls.length} file(s)
+` : "") + rulesText + `
+Call this tool again with confirmed=true to schedule.`;
+        return { content: [{ type: "text", text: preview }] };
+      }
+      const body = {
+        content: args.content,
+        platforms: args.platforms.map((p) => ({ platform: p })),
+        scheduledFor: nextSlot.scheduledFor,
+        timezone: nextSlot.timezone ?? "UTC"
+      };
+      if (args.media_urls?.length) {
+        body.mediaItems = args.media_urls.map((url) => ({
+          type: url.match(/\.(mp4|mov|avi|webm)$/i) ? "video" : "image",
+          url
+        }));
+      }
+      const result = await client.createPost(body);
+      const slotDate = new Date(nextSlot.scheduledFor);
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Post scheduled to queue slot: ${slotDate.toLocaleString()}
+
+${JSON.stringify(result, null, 2)}`
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/tools/notifications.ts
+import { z as z13 } from "zod";
+function timeAgo(dateStr) {
+  const diff = Date.now() - new Date(dateStr).getTime();
+  const minutes = Math.floor(diff / 6e4);
+  if (minutes < 1) return "just now";
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ago`;
+}
+function registerNotificationTools(server, client) {
+  server.tool(
+    "get_notifications",
+    "Get recent notifications including post publishing results, account health warnings, and errors. Use this to check if any posts failed or if any accounts need attention.",
+    {
+      unread_only: z13.boolean().optional().describe("If true, only show unread notifications. Default false."),
+      limit: z13.number().optional().describe("Max notifications to return. Default 10.")
+    },
+    {
+      title: "Get Notifications",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    async (args) => {
+      const params = {};
+      if (args.unread_only) params.unread = "true";
+      if (args.limit) params.limit = String(args.limit);
+      else params.limit = "10";
+      const result = await client.getNotifications(params);
+      const notifications = result.notifications ?? [];
+      const unreadCount = result.unread_count ?? 0;
+      if (notifications.length === 0) {
+        return {
+          content: [{
+            type: "text",
+            text: `## Notifications${args.unread_only ? " (unread)" : ""}
+
+No notifications found. All clear!`
+          }]
+        };
+      }
+      const severityIcon = {
+        success: "\u{1F7E2}",
+        warning: "\u{1F7E1}",
+        error: "\u{1F534}",
+        info: "\u{1F535}"
+      };
+      const lines = notifications.map((n) => {
+        const icon = severityIcon[n.severity] ?? "\u2B1C";
+        const time = n.createdAt ? timeAgo(n.createdAt) : "";
+        let line = `${icon} **${time}** \u2014 ${n.title}
+   "${n.message}"`;
+        if (n.actionUrl || n.actionLabel) {
+          const action = n.actionLabel || "View";
+          if (n.resourceType === "post" && n.resourceId) {
+            line += `
+   Action: ${action} \u2192 retry_post with post_id "${n.resourceId}"`;
+          } else {
+            line += `
+   Action: ${action} \u2192 ${n.actionUrl}`;
+          }
+        }
+        return line;
+      });
+      const header = `## Notifications (${unreadCount} unread)
+
+`;
+      const footer = `
+
+Showing ${notifications.length} of ${result.unread_count !== void 0 ? "total" : ""} notifications.`;
+      return {
+        content: [{
+          type: "text",
+          text: header + lines.join("\n\n") + footer
+        }]
+      };
+    }
+  );
+}
+
+// src/tools/publishing-rules.ts
+function registerPublishingRulesTools(server, client) {
+  server.tool(
+    "get_publishing_rules",
+    `Get the customer's publishing safety rules and default behaviors. IMPORTANT: Call this tool BEFORE publishing, scheduling, or sending any content. These rules define whether content should default to draft, whether previews are required, and what confirmations are needed before going live. Always respect these rules -- they exist to prevent accidental publishing.`,
+    {},
+    {
+      title: "Get Publishing Rules",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    async () => {
+      const rules = await client.getPublishingRules();
+      let text = "## Publishing Rules\n\n";
+      text += `Social media default: **${rules.socialDefaultAction ?? "draft"}**`;
+      if (rules.socialDefaultAction === "draft") text += " (content is saved as draft, not published)";
+      text += "\n";
+      text += `Newsletter default: **${rules.newsletterDefaultAction ?? "draft"}**`;
+      if (rules.newsletterDefaultAction === "draft") text += " (content is saved as draft, not sent)";
+      text += "\n";
+      text += `Preview required before publish: **${rules.requirePreviewBeforePublish ? "yes" : "no"}**
+`;
+      text += `Double confirmation for newsletters: **${rules.requireDoubleConfirmNewsletter ? "yes" : "no"}**
+`;
+      text += `Double confirmation for social: **${rules.requireDoubleConfirmSocial ? "yes" : "no"}**
+`;
+      text += `Immediate publish allowed: **${rules.allowImmediatePublish ? "yes" : "no"}**
+`;
+      text += `Immediate send allowed: **${rules.allowImmediateSend ? "yes" : "no"}**
+`;
+      text += `Max posts per day: **${rules.maxPostsPerDay ?? "unlimited"}**
+`;
+      if (rules.blockedWords && rules.blockedWords.length > 0) {
+        text += `Blocked words: **${rules.blockedWords.join(", ")}**
+`;
+      } else {
+        text += "Blocked words: none\n";
+      }
+      if (rules.requiredDisclaimer) {
+        text += `Required disclaimer: "${rules.requiredDisclaimer}"
+`;
+      } else {
+        text += "Required disclaimer: none\n";
+      }
+      return { content: [{ type: "text", text }] };
+    }
+  );
+}
+
+// src/tools/audit-log.ts
+import { z as z14 } from "zod";
+function registerAuditLogTools(server, client) {
+  server.tool(
+    "get_audit_log",
+    "View the history of all publish, send, schedule, and delete actions taken on the customer's account. Use this to review what was published recently, check activity, and troubleshoot issues.",
+    {
+      limit: z14.number().optional().describe("Maximum number of entries to return (default 20, max 200)"),
+      action: z14.string().optional().describe("Filter by action type prefix, e.g. 'post.published', 'newsletter.sent', 'post.' for all post actions"),
+      resource_type: z14.string().optional().describe("Filter by resource type: post, newsletter, account, media, publishing_rules, brand_voice")
+    },
+    {
+      title: "Get Audit Log",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    async (args) => {
+      const params = {};
+      if (args.limit) params.limit = String(args.limit);
+      if (args.action) params.action = args.action;
+      if (args.resource_type) params.resource_type = args.resource_type;
+      const data = await client.getAuditLog(params);
+      const entries = data?.entries ?? [];
+      if (entries.length === 0) {
+        return {
+          content: [{ type: "text", text: "## Audit Log\n\nNo entries found." }]
+        };
+      }
+      let text = `## Audit Log (${entries.length} of ${data?.total ?? entries.length} entries)
+
+`;
+      for (const entry of entries) {
+        const date = entry.createdAt ? new Date(entry.createdAt).toLocaleString() : "unknown";
+        const details = entry.details && Object.keys(entry.details).length > 0 ? ` \u2014 ${JSON.stringify(entry.details)}` : "";
+        text += `- **${date}** | ${entry.action} | ${entry.resourceType}`;
+        if (entry.resourceId) text += ` #${entry.resourceId}`;
+        text += `${details}
+`;
+      }
+      return { content: [{ type: "text", text }] };
+    }
+  );
+}
+
+// src/tools/sources.ts
+import { z as z15 } from "zod";
+var TYPE_LABELS = {
+  feed: "RSS Feed",
+  website: "Website",
+  youtube: "YouTube Channel",
+  search: "Search Topic",
+  podcast: "Podcast",
+  reddit: "Reddit",
+  social: "Social Profile"
+};
+var TYPE_HINTS = {
+  feed: "Use fetch_feed to get latest entries",
+  website: "Use fetch_article to extract content",
+  youtube: "Use fetch_feed to get latest videos (YouTube RSS)",
+  search: "Use web_search with the searchQuery",
+  podcast: "Use fetch_feed to get latest episodes",
+  reddit: "Use fetch_feed to get latest posts (Reddit RSS)",
+  social: "Use web_search to check recent activity"
+};
+function registerSourceTools(server, client) {
+  server.tool(
+    "get_sources",
+    "Get the customer's saved content sources \u2014 their curated list of RSS feeds, websites, YouTube channels, social accounts, and search topics that they monitor for content ideas and inspiration. Call this when the user asks 'what should I post about?', 'check my sources', 'what's new?', 'find me content ideas', or references their content sources. After getting sources, use fetch_feed (for feed/podcast/reddit/youtube types), fetch_article (for website types), or web_search (for search/social types) to actually retrieve the latest content from each source.",
+    {
+      type: z15.string().optional().describe(
+        "Optional: filter by type (feed, website, youtube, search, podcast, reddit, social)"
+      ),
+      category: z15.string().optional().describe("Optional: filter by category")
+    },
+    {
+      title: "Get Content Sources",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    async (args) => {
+      const params = {};
+      if (args.type) params.type = args.type;
+      if (args.category) params.category = args.category;
+      const result = await client.listSources(params);
+      const sources = result.sources;
+      if (sources.length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "No content sources saved yet. Use add_source to save RSS feeds, websites, YouTube channels, or search topics the customer wants to monitor for content ideas."
+            }
+          ]
+        };
+      }
+      const lines = [`## Content Sources (${sources.length})
+`];
+      const byCategory = /* @__PURE__ */ new Map();
+      for (const s of sources) {
+        const cat = s.category || "Uncategorized";
+        if (!byCategory.has(cat)) byCategory.set(cat, []);
+        byCategory.get(cat).push(s);
+      }
+      for (const [cat, items] of byCategory) {
+        lines.push(`### ${cat}
+`);
+        for (const s of items) {
+          const typeLabel = TYPE_LABELS[s.type] || s.type;
+          const hint = TYPE_HINTS[s.type] || "";
+          lines.push(`**${s.name}** (ID: ${s.id})`);
+          lines.push(`- Type: ${typeLabel}`);
+          if (s.url) lines.push(`- URL: ${s.url}`);
+          if (s.searchQuery) lines.push(`- Search: "${s.searchQuery}"`);
+          if (s.tags && s.tags.length > 0)
+            lines.push(`- Tags: ${s.tags.join(", ")}`);
+          if (s.notes) lines.push(`- Notes: ${s.notes}`);
+          if (s.lastCheckedAt)
+            lines.push(`- Last checked: ${s.lastCheckedAt}`);
+          if (s.lastCheckedSummary)
+            lines.push(`- Last result: ${s.lastCheckedSummary}`);
+          if (hint) lines.push(`- How to check: ${hint}`);
+          lines.push("");
+        }
+      }
+      return {
+        content: [{ type: "text", text: lines.join("\n") }]
+      };
+    }
+  );
+  server.tool(
+    "add_source",
+    "Save a new content source to the customer's profile. Use this when the customer says 'add this to my sources', 'save this feed', 'monitor this blog', 'track this competitor', etc. For RSS feeds, set type to 'feed'. For regular websites/blogs without RSS, set type to 'website'. For YouTube channels, set type to 'youtube'. For search topics, set type to 'search' and provide searchQuery instead of url.",
+    {
+      name: z15.string().describe("Display name for the source"),
+      url: z15.string().optional().describe(
+        "URL of the source (RSS feed, website, YouTube channel, subreddit, or social profile URL). Not needed for 'search' type."
+      ),
+      type: z15.enum([
+        "feed",
+        "website",
+        "youtube",
+        "search",
+        "podcast",
+        "reddit",
+        "social"
+      ]).describe("Type of source. Determines how to fetch content from it."),
+      category: z15.string().optional().describe(
+        "Optional category for organization (e.g. 'competitors', 'industry', 'inspiration', 'my-content')"
+      ),
+      tags: z15.array(z15.string()).optional().describe("Optional tags for filtering"),
+      notes: z15.string().optional().describe("Optional notes about why this source matters"),
+      searchQuery: z15.string().optional().describe(
+        "For 'search' type only: the keyword or topic to search for"
+      )
+    },
+    {
+      title: "Add Content Source",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: false
+    },
+    async (args) => {
+      const data = {
+        name: args.name,
+        type: args.type
+      };
+      if (args.url) data.url = args.url;
+      if (args.category) data.category = args.category;
+      if (args.tags) data.tags = args.tags;
+      if (args.notes) data.notes = args.notes;
+      if (args.searchQuery) data.searchQuery = args.searchQuery;
+      const result = await client.createSource(data);
+      const typeLabel = TYPE_LABELS[result.type] || result.type;
+      const lines = [
+        `## Source Added
+`,
+        `**${result.name}** (ID: ${result.id})`,
+        `- Type: ${typeLabel}`
+      ];
+      if (result.url) lines.push(`- URL: ${result.url}`);
+      if (result.searchQuery)
+        lines.push(`- Search: "${result.searchQuery}"`);
+      if (result.category) lines.push(`- Category: ${result.category}`);
+      return {
+        content: [{ type: "text", text: lines.join("\n") }]
+      };
+    }
+  );
+  server.tool(
+    "update_source",
+    "Update a saved content source. Use when the customer wants to rename, recategorize, change the URL, add notes, or deactivate a source.",
+    {
+      source_id: z15.number().describe("The ID of the source to update"),
+      name: z15.string().optional().describe("New display name"),
+      url: z15.string().optional().describe("New URL"),
+      type: z15.enum([
+        "feed",
+        "website",
+        "youtube",
+        "search",
+        "podcast",
+        "reddit",
+        "social"
+      ]).optional().describe("New source type"),
+      category: z15.string().optional().describe("New category"),
+      tags: z15.array(z15.string()).optional().describe("New tags"),
+      notes: z15.string().optional().describe("New notes"),
+      searchQuery: z15.string().optional().describe("New search query"),
+      isActive: z15.boolean().optional().describe("Set to false to deactivate")
+    },
+    {
+      title: "Update Content Source",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    async (args) => {
+      const { source_id, ...updates } = args;
+      const data = {};
+      for (const [k, v] of Object.entries(updates)) {
+        if (v !== void 0) data[k] = v;
+      }
+      const result = await client.updateSource(source_id, data);
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Source **${result.name}** (ID: ${result.id}) updated successfully.`
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "remove_source",
+    `Remove a content source from the customer's saved sources. Use when the customer says 'remove that source', 'stop tracking X', 'delete that feed', etc.
+
+REQUIRED WORKFLOW:
+1. ALWAYS set confirmed=false first to preview which source will be deleted
+2. Show the user the source details before confirming
+3. Only confirm after explicit user approval`,
+    {
+      source_id: z15.number().describe("The ID of the source to remove"),
+      confirmed: z15.boolean().default(false).describe("Set to true to confirm deletion. If false or missing, returns a preview for user approval.")
+    },
+    {
+      title: "Remove Content Source",
+      readOnlyHint: false,
+      destructiveHint: true,
+      idempotentHint: false,
+      openWorldHint: false
+    },
+    async (args) => {
+      if (args.confirmed !== true) {
+        const preview = `## Remove Source Confirmation
+
+**Source ID:** ${args.source_id}
+
+This will permanently remove this content source. Call this tool again with confirmed=true to proceed.`;
+        return { content: [{ type: "text", text: preview }] };
+      }
+      await client.deleteSource(args.source_id);
+      return {
+        content: [
+          {
+            type: "text",
+            text: "Content source removed successfully."
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/tools/carousel.ts
+import { z as z16 } from "zod";
+function registerCarouselTools(server, client) {
+  server.tool(
+    "get_carousel_template",
+    "Get the customer's carousel template configuration. Returns brand colors, logo, CTA text, and other visual settings used to generate carousels from article URLs.",
+    {},
+    {
+      title: "Get Carousel Template",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    async () => {
+      try {
+        const template = await client.getCarouselTemplate();
+        const lines = [];
+        lines.push(`## Carousel Template: ${template.name || "Not configured"}`);
+        lines.push("");
+        if (!template.id) {
+          lines.push("No carousel template has been configured yet.");
+          lines.push("");
+          lines.push("Use `save_carousel_template` to set one up with your brand name, colors, and CTA text.");
+          return {
+            content: [{ type: "text", text: lines.join("\n") }]
+          };
+        }
+        lines.push(`**Brand Name:** ${template.brandName || "\u2014"}`);
+        if (template.logoUrl) lines.push(`**Logo:** ${template.logoUrl}`);
+        lines.push(`**Primary Color:** ${template.colorPrimary || "#1a1a2e"}`);
+        lines.push(`**Secondary Color:** ${template.colorSecondary || "#e94560"}`);
+        lines.push(`**Accent Color:** ${template.colorAccent || "#ffffff"}`);
+        lines.push(`**CTA Text:** ${template.ctaText || "Read the full story \u2192"}`);
+        lines.push(`**Logo Placement:** ${template.logoPlacement || "top-left"}`);
+        lines.push("");
+        return {
+          content: [{ type: "text", text: lines.join("\n") }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        if (message.includes("404")) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "No carousel template has been configured yet. Use `save_carousel_template` to set one up."
+              }
+            ]
+          };
+        }
+        throw error;
+      }
+    }
+  );
+  server.tool(
+    "save_carousel_template",
+    `Create or update the customer's carousel template. This configures the visual style for auto-generated carousels (brand colors, logo, CTA text).
+
+USAGE:
+- Set confirmed=false first to preview, then confirmed=true after user approval
+- brand_name is required
+- All color values should be hex codes (e.g. "#1a1a2e")
+- logo_placement: "top-left", "top-right", or "top-center"`,
+    {
+      brand_name: z16.string().max(255).describe("Brand name displayed on CTA slide"),
+      color_primary: z16.string().max(20).optional().describe('Primary background color (hex, e.g. "#1a1a2e")'),
+      color_secondary: z16.string().max(20).optional().describe('Secondary/accent color for buttons and highlights (hex, e.g. "#e94560")'),
+      color_accent: z16.string().max(20).optional().describe('Text color (hex, e.g. "#ffffff")'),
+      cta_text: z16.string().max(255).optional().describe('Call-to-action text on the final slide (e.g. "Read the full story \u2192")'),
+      logo_placement: z16.enum(["top-left", "top-right", "top-center"]).optional().describe("Where to place the logo on slides"),
+      confirmed: z16.boolean().default(false).describe("Set to true to confirm and save. If false, returns a preview.")
+    },
+    {
+      title: "Save Carousel Template",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: false
+    },
+    async (args) => {
+      const payload = {
+        brandName: args.brand_name
+      };
+      if (args.color_primary !== void 0) payload.colorPrimary = args.color_primary;
+      if (args.color_secondary !== void 0) payload.colorSecondary = args.color_secondary;
+      if (args.color_accent !== void 0) payload.colorAccent = args.color_accent;
+      if (args.cta_text !== void 0) payload.ctaText = args.cta_text;
+      if (args.logo_placement !== void 0) payload.logoPlacement = args.logo_placement;
+      if (args.confirmed !== true) {
+        const lines2 = [];
+        lines2.push("## Carousel Template Preview");
+        lines2.push("");
+        lines2.push(`**Brand Name:** ${args.brand_name}`);
+        if (args.color_primary) lines2.push(`**Primary Color:** ${args.color_primary}`);
+        if (args.color_secondary) lines2.push(`**Secondary Color:** ${args.color_secondary}`);
+        if (args.color_accent) lines2.push(`**Accent Color:** ${args.color_accent}`);
+        if (args.cta_text) lines2.push(`**CTA Text:** ${args.cta_text}`);
+        if (args.logo_placement) lines2.push(`**Logo Placement:** ${args.logo_placement}`);
+        lines2.push("");
+        lines2.push("---");
+        lines2.push("Call this tool again with **confirmed=true** to save these settings.");
+        return {
+          content: [{ type: "text", text: lines2.join("\n") }]
+        };
+      }
+      const result = await client.updateCarouselTemplate(payload);
+      const lines = [];
+      lines.push(`Carousel template "${result.brandName || args.brand_name}" has been saved successfully.`);
+      lines.push("");
+      const updated = ["brand name"];
+      if (args.color_primary) updated.push("primary color");
+      if (args.color_secondary) updated.push("secondary color");
+      if (args.color_accent) updated.push("accent color");
+      if (args.cta_text) updated.push("CTA text");
+      if (args.logo_placement) updated.push("logo placement");
+      lines.push(`**Updated:** ${updated.join(", ")}`);
+      return {
+        content: [{ type: "text", text: lines.join("\n") }]
+      };
+    }
+  );
+  server.tool(
+    "generate_carousel",
+    "Generate a full multi-slide carousel from an article URL. Extracts headline and key points using AI, renders branded slides (hero + key points + CTA), and uploads them to CDN. Returns an array of CDN URLs for the rendered slides. Requires a carousel template to be configured first via save_carousel_template.",
+    {
+      url: z16.string().url().describe("The article URL to generate a carousel from")
+    },
+    {
+      title: "Generate Carousel",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: true
+    },
+    async (args) => {
+      try {
+        const result = await client.generateCarousel({
+          url: args.url
+        });
+        const lines = [];
+        lines.push("## Carousel Generated");
+        lines.push("");
+        lines.push(`**Headline:** ${result.article.headline}`);
+        lines.push(`**Source:** ${result.article.sourceDomain}`);
+        lines.push(`**Slides:** ${result.slides.length}`);
+        lines.push("");
+        lines.push("### Key Points");
+        for (const point of result.article.keyPoints) {
+          lines.push(`- ${point}`);
+        }
+        lines.push("");
+        lines.push("### Slide URLs");
+        for (const slide of result.slides) {
+          lines.push(`${slide.slideNumber}. [${slide.type}](${slide.cdnUrl})`);
+        }
+        lines.push("");
+        lines.push("These URLs can be used as `media_urls` when creating a post.");
+        return {
+          content: [{ type: "text", text: lines.join("\n") }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Failed to generate carousel: ${message}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "preview_carousel",
+    "Generate a quick preview of the carousel hero slide from an article URL. Useful for checking how the template looks before generating the full carousel. Requires a carousel template to be configured first.",
+    {
+      url: z16.string().url().describe("The article URL to preview")
+    },
+    {
+      title: "Preview Carousel",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: true
+    },
+    async (args) => {
+      try {
+        const result = await client.previewCarousel({
+          url: args.url
+        });
+        const lines = [];
+        lines.push("## Carousel Preview");
+        lines.push("");
+        lines.push(`**Headline:** ${result.article.headline}`);
+        lines.push(`**Source:** ${result.article.sourceDomain}`);
+        lines.push("");
+        lines.push(`**Hero Slide:** ${result.cdnUrl}`);
+        lines.push("");
+        lines.push("Use `generate_carousel` to create the full carousel with all slides.");
+        return {
+          content: [{ type: "text", text: lines.join("\n") }]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Failed to preview carousel: ${message}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
+export {
+  BuzzPosterClient,
+  registerAccountInfoTool,
+  registerAccountTools,
+  registerAnalyticsTools,
+  registerAudienceTools,
+  registerAuditLogTools,
+  registerBrandVoiceTools,
+  registerCalendarTools,
+  registerCarouselTools,
+  registerInboxTools,
+  registerKnowledgeTools,
+  registerMediaTools,
+  registerNewsletterAdvancedTools,
+  registerNewsletterTemplateTools,
+  registerNewsletterTools,
+  registerNotificationTools,
+  registerPostTools,
+  registerPublishingRulesTools,
+  registerRssTools,
+  registerSourceTools
+};