@buzzposter/mcp 0.1.2 → 0.1.5

package/dist/index.js

@@ -101,12 +101,28 @@ var BuzzPosterClient = class {
     });
   }
   // Media
-  async uploadMedia(filename, base64Data, mimeType) {
-    return this.request("POST", "/api/v1/media/upload-base64", {
-      filename,
-      data: base64Data,
-      mimeType
+  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");
@@ -152,6 +168,64 @@ var BuzzPosterClient = class {
   async listForms() {
     return this.request("GET", "/api/v1/newsletters/forms");
   }
+  // 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");
+  }
+  // Audiences
+  async getAudience(id) {
+    return this.request("GET", `/api/v1/audiences/${id}`);
+  }
+  async getDefaultAudience() {
+    return this.request("GET", "/api/v1/audiences/default");
+  }
+  // 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 };
@@ -161,6 +235,16 @@ var BuzzPosterClient = class {
   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");
+  }
 };
 
 // src/tools/posts.ts
@@ -168,16 +252,36 @@ import { z } from "zod";
 function registerPostTools(server2, client2) {
   server2.tool(
     "post",
-    "Create and publish a post to one or more social media platforms. Supports Twitter, Instagram, LinkedIn, and Facebook with full platform-specific options.",
+    "Create and publish a post to one or more social media platforms. Supports Twitter, Instagram, LinkedIn, and Facebook with full platform-specific options. Requires confirmation before publishing.",
     {
       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().optional().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) {
+        const preview = `## Post Preview
+
+**Content:** "${args.content ?? "(no text)"}"
+**Platforms:** ${args.platforms.join(", ")}
+` + (args.media_urls?.length ? `**Media:** ${args.media_urls.length} file(s)
+` : "") + `
+This will be published **immediately**. 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]) {
@@ -204,10 +308,20 @@ function registerPostTools(server2, client2) {
   );
   server2.tool(
     "cross_post",
-    "Post the same content to all connected social media platforms at once.",
+    "Post the same content to all connected social media platforms at once. Requires confirmation before publishing.",
     {
       content: z.string().describe("The text content to post everywhere"),
-      media_urls: z.array(z.string()).optional().describe("Public URLs of media to attach")
+      media_urls: z.array(z.string()).optional().describe("Public URLs of media to attach"),
+      confirmed: z.boolean().optional().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 client2.listAccounts();
@@ -224,6 +338,16 @@ function registerPostTools(server2, client2) {
           ]
         };
       }
+      if (!args.confirmed) {
+        const preview = `## Cross-Post Preview
+
+**Content:** "${args.content}"
+**Platforms:** ${platforms.join(", ")}
+` + (args.media_urls?.length ? `**Media:** ${args.media_urls.length} file(s)
+` : "") + `
+This will be published **immediately** to all connected platforms. 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 })),
@@ -243,16 +367,37 @@ function registerPostTools(server2, client2) {
   );
   server2.tool(
     "schedule_post",
-    "Schedule a post for future publication.",
+    "Schedule a post for future publication. Requires confirmation before scheduling.",
     {
       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")
+      platform_specific: z.record(z.record(z.unknown())).optional().describe("Platform-specific data keyed by platform name"),
+      confirmed: z.boolean().optional().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) {
+        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)
+` : "") + `
+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]) {
@@ -286,6 +431,13 @@ function registerPostTools(server2, client2) {
       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,
@@ -311,6 +463,13 @@ function registerPostTools(server2, client2) {
       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;
@@ -327,6 +486,13 @@ function registerPostTools(server2, client2) {
     {
       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 client2.getPost(args.post_id);
       return {
@@ -336,11 +502,48 @@ function registerPostTools(server2, client2) {
   );
   server2.tool(
     "retry_post",
-    "Retry publishing a post that failed on one or more platforms.",
+    "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")
+      post_id: z.string().describe("The ID of the post to retry"),
+      confirmed: z.boolean().optional().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) {
+        const post = await client2.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 client2.retryPost(args.post_id);
       return {
         content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
@@ -353,23 +556,103 @@ function registerPostTools(server2, client2) {
 function registerAccountTools(server2, client2) {
   server2.tool(
     "list_accounts",
-    "List all connected social media accounts with their platform, username, and connection status.",
+    "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 client2.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: JSON.stringify(result, null, 2) }]
+        content: [{ type: "text", text }]
       };
     }
   );
   server2.tool(
     "check_accounts_health",
-    "Check the health and connection status of all connected social media accounts.",
+    "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 client2.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: JSON.stringify(result, null, 2) }]
+        content: [{ type: "text", text }]
       };
     }
   );
@@ -386,6 +669,13 @@ function registerAnalyticsTools(server2, client2) {
       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;
@@ -408,6 +698,13 @@ function registerInboxTools(server2, client2) {
     {
       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;
@@ -423,6 +720,13 @@ function registerInboxTools(server2, client2) {
     {
       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 client2.getConversation(args.conversation_id);
       return {
@@ -432,12 +736,29 @@ function registerInboxTools(server2, client2) {
   );
   server2.tool(
     "reply_to_conversation",
-    "Send a reply message in a DM conversation.",
+    "Send a reply message in a DM conversation. Sends a message to an external platform on your behalf.",
     {
       conversation_id: z3.string().describe("The conversation ID to reply to"),
-      message: z3.string().describe("The reply message text")
+      message: z3.string().describe("The reply message text"),
+      confirmed: z3.boolean().optional().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) {
+        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 client2.replyToConversation(
         args.conversation_id,
         args.message
@@ -453,6 +774,13 @@ function registerInboxTools(server2, client2) {
     {
       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;
@@ -464,12 +792,29 @@ function registerInboxTools(server2, client2) {
   );
   server2.tool(
     "reply_to_comment",
-    "Reply to a comment on one of your posts.",
+    "Reply to a comment on one of your posts. Sends a reply on the external platform.",
     {
       comment_id: z3.string().describe("The comment ID to reply to"),
-      message: z3.string().describe("The reply text")
+      message: z3.string().describe("The reply text"),
+      confirmed: z3.boolean().optional().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) {
+        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 client2.replyToComment(
         args.comment_id,
         args.message
@@ -483,6 +828,13 @@ function registerInboxTools(server2, client2) {
     "list_reviews",
     "List reviews on your Facebook page.",
     {},
+    {
+      title: "List Reviews",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true
+    },
     async () => {
       const result = await client2.listReviews();
       return {
@@ -492,12 +844,29 @@ function registerInboxTools(server2, client2) {
   );
   server2.tool(
     "reply_to_review",
-    "Reply to a review on your Facebook page.",
+    "Reply to a review on your Facebook page. Sends a public reply on the external platform.",
     {
       review_id: z3.string().describe("The review ID to reply to"),
-      message: z3.string().describe("The reply text")
+      message: z3.string().describe("The reply text"),
+      confirmed: z3.boolean().optional().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) {
+        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 client2.replyToReview(
         args.review_id,
         args.message
@@ -519,9 +888,15 @@ function registerMediaTools(server2, client2) {
     {
       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 = await readFile(args.file_path);
-      const base64 = buffer.toString("base64");
+      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 = {
@@ -537,26 +912,57 @@ function registerMediaTools(server2, client2) {
         pdf: "application/pdf"
       };
       const mimeType = mimeMap[ext] ?? "application/octet-stream";
-      const result = await client2.uploadMedia(filename, base64, mimeType);
+      const result = await client2.uploadMediaMultipart(filename, buffer, mimeType);
       return {
         content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
       };
     }
   );
   server2.tool(
-    "upload_media_base64",
-    "Upload media from base64-encoded data. Returns a CDN URL that can be used in posts.",
+    "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")
+    },
     {
-      filename: z4.string().describe("The filename including extension"),
-      data: z4.string().describe("Base64-encoded file data"),
-      mime_type: z4.string().describe("MIME type of the file, e.g. image/jpeg, video/mp4")
+      title: "Upload Media from URL",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: false
     },
     async (args) => {
-      const result = await client2.uploadMedia(
-        args.filename,
-        args.data,
-        args.mime_type
-      );
+      const result = await client2.uploadFromUrl({
+        url: args.url,
+        filename: args.filename,
+        folder: args.folder
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server2.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 client2.getUploadUrl({
+        filename: args.filename,
+        content_type: args.content_type
+      });
       return {
         content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
       };
@@ -566,6 +972,13 @@ function registerMediaTools(server2, client2) {
     "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 client2.listMedia();
       return {
@@ -575,11 +988,27 @@ function registerMediaTools(server2, client2) {
   );
   server2.tool(
     "delete_media",
-    "Delete a media file from your BuzzPoster media library.",
+    "Delete a media file from your BuzzPoster media library. This cannot be undone.",
+    {
+      key: z4.string().describe("The key/path of the media file to delete"),
+      confirmed: z4.boolean().optional().describe("Set to true to confirm deletion. If false or missing, returns a preview for user approval.")
+    },
     {
-      key: z4.string().describe("The key/path of the media file to delete")
+      title: "Delete Media File",
+      readOnlyHint: false,
+      destructiveHint: true,
+      idempotentHint: true,
+      openWorldHint: false
     },
     async (args) => {
+      if (!args.confirmed) {
+        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 client2.deleteMedia(args.key);
       return {
         content: [{ type: "text", text: "Media deleted successfully." }]
@@ -598,6 +1027,13 @@ function registerNewsletterTools(server2, client2) {
       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;
@@ -616,6 +1052,13 @@ function registerNewsletterTools(server2, client2) {
       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 client2.addSubscriber({
         email: args.email,
@@ -635,6 +1078,13 @@ function registerNewsletterTools(server2, client2) {
       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 client2.createBroadcast({
         subject: args.subject,
@@ -655,6 +1105,13 @@ function registerNewsletterTools(server2, client2) {
       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;
@@ -668,11 +1125,31 @@ function registerNewsletterTools(server2, client2) {
   );
   server2.tool(
     "send_newsletter",
-    "Send a newsletter/broadcast to subscribers. This action cannot be undone.",
+    "Send a newsletter/broadcast to subscribers. This action cannot be undone. Requires confirmation before sending.",
+    {
+      broadcast_id: z5.string().describe("The broadcast/newsletter ID to send"),
+      confirmed: z5.boolean().optional().describe(
+        "Set to true to confirm and send. If false or missing, returns a confirmation prompt."
+      )
+    },
     {
-      broadcast_id: z5.string().describe("The broadcast/newsletter ID to send")
+      title: "Send Newsletter",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: true
     },
     async (args) => {
+      if (!args.confirmed) {
+        const preview = `## Send Newsletter Confirmation
+
+**Broadcast ID:** ${args.broadcast_id}
+
+This will send the newsletter to your subscriber list. **This action cannot be undone.**
+
+Call this tool again with confirmed=true to send.`;
+        return { content: [{ type: "text", text: preview }] };
+      }
       await client2.sendBroadcast(args.broadcast_id);
       return {
         content: [{ type: "text", text: "Newsletter sent successfully." }]
@@ -685,6 +1162,13 @@ function registerNewsletterTools(server2, client2) {
     {
       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;
@@ -698,6 +1182,13 @@ function registerNewsletterTools(server2, client2) {
     "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 client2.listTags();
       return {
@@ -709,6 +1200,13 @@ function registerNewsletterTools(server2, client2) {
     "list_sequences",
     "List all email sequences/automations from your email service provider.",
     {},
+    {
+      title: "List Email Sequences",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true
+    },
     async () => {
       const result = await client2.listSequences();
       return {
@@ -720,6 +1218,13 @@ function registerNewsletterTools(server2, client2) {
     "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 client2.listForms();
       return {
@@ -739,6 +1244,13 @@ function registerRssTools(server2, client2) {
       url: z6.string().describe("The RSS/Atom feed URL to fetch"),
       limit: z6.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 client2.fetchFeed(args.url, args.limit);
       return {
@@ -752,6 +1264,13 @@ function registerRssTools(server2, client2) {
     {
       url: z6.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 client2.fetchArticle(args.url);
       return {
@@ -767,6 +1286,13 @@ function registerAccountInfoTool(server2, client2) {
     "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 client2.getAccount();
       return {
@@ -776,6 +1302,894 @@ function registerAccountInfoTool(server2, client2) {
   );
 }
 
+// src/tools/brand-voice.ts
+function registerBrandVoiceTools(server2, client2) {
+  server2.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.",
+    {},
+    {
+      title: "Get Brand Voice",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    async () => {
+      try {
+        const voice = await client2.getBrandVoice();
+        const lines = [];
+        lines.push(`## Brand Voice: ${voice.name || "My Brand"}`);
+        lines.push("");
+        if (voice.description) {
+          lines.push("### Voice Description");
+          lines.push(voice.description);
+          lines.push("");
+        }
+        if (voice.dos && voice.dos.length > 0) {
+          lines.push("### Do's");
+          for (const rule of voice.dos) {
+            lines.push(`- ${rule}`);
+          }
+          lines.push("");
+        }
+        if (voice.donts && voice.donts.length > 0) {
+          lines.push("### Don'ts");
+          for (const rule of voice.donts) {
+            lines.push(`- ${rule}`);
+          }
+          lines.push("");
+        }
+        if (voice.platformRules && Object.keys(voice.platformRules).length > 0) {
+          lines.push("### Platform-Specific Rules");
+          for (const [platform, rules] of Object.entries(voice.platformRules)) {
+            lines.push(`**${platform}:** ${rules}`);
+          }
+          lines.push("");
+        }
+        if (voice.examplePosts && voice.examplePosts.length > 0) {
+          lines.push("### Example Posts");
+          voice.examplePosts.forEach((post, i) => {
+            lines.push(`${i + 1}. ${post}`);
+          });
+          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;
+      }
+    }
+  );
+}
+
+// src/tools/knowledge.ts
+import { z as z7 } from "zod";
+function registerKnowledgeTools(server2, client2) {
+  server2.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 client2.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}`);
+      }
+    }
+  );
+  server2.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: z7.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 client2.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}`);
+      }
+    }
+  );
+  server2.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: z7.string().describe("Title for the knowledge item"),
+      content: z7.string().describe("The content/text to save"),
+      tags: z7.array(z7.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 client2.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 z8 } from "zod";
+function registerAudienceTools(server2, client2) {
+  server2.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: z8.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 client2.getAudience(audienceId) : await client2.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;
+      }
+    }
+  );
+}
+
+// src/tools/newsletter-template.ts
+import { z as z9 } from "zod";
+function registerNewsletterTemplateTools(server2, client2) {
+  server2.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.",
+    {
+      templateId: z9.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 client2.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("");
+        }
+        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 has been configured yet. The customer can set one up at their BuzzPoster dashboard under Templates."
+              }
+            ]
+          };
+        }
+        throw error;
+      }
+    }
+  );
+  server2.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: z9.number().optional().describe("Number of past newsletters to retrieve. Default 5, max 50."),
+      templateId: z9.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 client2.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}`);
+      }
+    }
+  );
+  server2.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: z9.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 client2.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;
+      }
+    }
+  );
+  server2.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: z9.string().describe("The newsletter subject line."),
+      contentHtml: z9.string().describe("The full HTML content of the newsletter."),
+      templateId: z9.string().optional().describe("The template ID used to generate this newsletter."),
+      notes: z9.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 client2.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 z10 } from "zod";
+function registerCalendarTools(server2, client2) {
+  server2.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: z10.string().optional().describe("ISO date to filter from, e.g. 2024-01-01"),
+      to: z10.string().optional().describe("ISO date to filter to, e.g. 2024-01-31"),
+      status: z10.string().optional().describe("Filter by status: scheduled, published, draft, failed"),
+      type: z10.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 client2.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 client2.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 }]
+      };
+    }
+  );
+  server2.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 client2.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 client2.getNextSlot();
+        if (nextSlot?.scheduledFor) {
+          const slotDate = new Date(nextSlot.scheduledFor);
+          text += `
+Next slot: ${slotDate.toLocaleString()} (${dayNames[slotDate.getDay()]})
+`;
+        }
+      } catch {
+      }
+      return {
+        content: [{ type: "text", text }]
+      };
+    }
+  );
+  server2.tool(
+    "schedule_to_queue",
+    "Add a post to the customer's content queue. The post will be automatically scheduled to the next available time slot. Requires confirmation before scheduling.",
+    {
+      content: z10.string().describe("The text content of the post"),
+      platforms: z10.array(z10.string()).describe('Platforms to post to, e.g. ["twitter", "linkedin"]'),
+      media_urls: z10.array(z10.string()).optional().describe("Public URLs of media to attach"),
+      confirmed: z10.boolean().optional().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 client2.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) {
+        const slotDate2 = new Date(nextSlot.scheduledFor);
+        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)
+` : "") + `
+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 client2.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 z11 } 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(server2, client2) {
+  server2.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: z11.boolean().optional().describe("If true, only show unread notifications. Default false."),
+      limit: z11.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 client2.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/index.ts
 var apiKey = process.env.BUZZPOSTER_API_KEY;
 var apiUrl = process.env.BUZZPOSTER_API_URL ?? "https://api.buzzposter.com";
@@ -801,5 +2215,11 @@ registerMediaTools(server, client);
 registerNewsletterTools(server, client);
 registerRssTools(server, client);
 registerAccountInfoTool(server, client);
+registerBrandVoiceTools(server, client);
+registerKnowledgeTools(server, client);
+registerAudienceTools(server, client);
+registerNewsletterTemplateTools(server, client);
+registerCalendarTools(server, client);
+registerNotificationTools(server, client);
 var transport = new StdioServerTransport();
 await server.connect(transport);