@xreplyai/mcp 0.3.11 → 0.3.17

package/dist/tools/posts.js

@@ -2,20 +2,14 @@ import { z } from "zod";
 import * as fs from "fs";
 import * as path from "path";
 import { validateScheduledAt } from "../validation.js";
-function ok(data) {
-    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
-}
-function err(error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return { content: [{ type: "text", text: `Error: ${message}` }], isError: true };
-}
+import { ok, err } from "./helpers.js";
 const PostContentSchema = z.object({
-    platform: z.enum(["twitter", "linkedin", "youtube"]).describe("Target platform"),
-    body: z.string().min(1).max(3000).optional().describe("Post body text (max 280 for X, max 3000 for LinkedIn). Optional for YouTube video posts (used as video description)."),
+    platform: z.enum(["twitter", "linkedin", "youtube", "threads", "instagram", "bluesky", "facebook", "google_business"]).describe("Target platform"),
+    body: z.string().min(1).max(3000).optional().describe("Post body text (max 280 for X, max 3000 for LinkedIn, max 500 for Threads, max 300 for Bluesky, max 1500 for Google Business). Optional for YouTube video posts (used as video description)."),
     content_type: z
-        .enum(["text", "single_image", "multi_image", "video"])
+        .enum(["text", "single_image", "multi_image", "video", "document"])
         .optional()
-        .describe("Content type (default: text). Use video for LinkedIn and YouTube video posts."),
+        .describe("Content type (default: text). Use video for LinkedIn and YouTube video posts. Use document for LinkedIn carousel posts (PDF)."),
     metadata: z
         .object({
         asset_urn: z.string().optional().describe("LinkedIn only — asset_urn from xreply_media_upload or xreply_video_upload"),
@@ -29,17 +23,23 @@ const PostContentSchema = z.object({
         category_id: z.string().optional().describe("YouTube only — numeric category ID (default: 22 = People & Blogs)"),
         tags: z.array(z.string()).optional().describe("YouTube only — array of tags"),
         thumbnail_url: z.string().optional().describe("YouTube only — URL of thumbnail image to set after upload"),
+        image_url: z.string().optional().describe("Threads only — public HTTPS URL of image to attach (required for single_image content_type on Threads). Instagram only — public JPEG URL for single_image posts"),
+        image_urls: z.array(z.string()).optional().describe("Instagram only — 2-10 public JPEG URLs for carousel (multi_image) posts"),
+        video_url: z.string().optional().describe("Instagram only — public MOV/MP4 URL for Reels (video) posts"),
+        cover_url: z.string().optional().describe("Instagram only — custom thumbnail URL for Reels"),
+        share_to_feed: z.boolean().optional().describe("Instagram only — true to share Reel to Feed tab as well as Reels tab"),
+        document_urn: z.string().optional().describe("LinkedIn only — document_urn from xreply_linkedin_document_upload, for carousel (document) posts"),
     })
         .optional()
-        .describe("Metadata for the post content. For X images: media_id or media_ids. For LinkedIn images: asset_urn or asset_urns. For LinkedIn/YouTube video: asset_urn. For YouTube: title (required), privacy_status, category_id, tags, thumbnail_url. For X auto-retweet: auto_rt_hours. For X communities: community_id."),
+        .describe("Metadata for the post content. For X images: media_id or media_ids. For LinkedIn images: asset_urn or asset_urns. For LinkedIn/YouTube video: asset_urn. For LinkedIn carousel: document_urn. For YouTube: title (required), privacy_status, category_id, tags, thumbnail_url. For Threads image: image_url (public HTTPS URL). For X auto-retweet: auto_rt_hours. For X communities: community_id. For Instagram single_image: image_url. For Instagram multi_image carousel: image_urls (2-10 URLs). For Instagram video/reel: video_url, cover_url, share_to_feed."),
 });
 const CreatePostSchema = z.object({
-    body: z.string().min(1).max(280).optional().describe("Post body text for X only (max 280 chars). Use post_contents for LinkedIn or cross-posting."),
+    body: z.string().min(1).max(280).optional().describe("Post body text for X only (max 280 chars). Use post_contents for LinkedIn, Threads, Instagram, or cross-posting."),
     post_contents: z
         .array(PostContentSchema)
         .min(1)
         .optional()
-        .describe("Per-platform content. Use this for LinkedIn posts or when posting different text to multiple platforms."),
+        .describe("Per-platform content. Use this for LinkedIn, Threads, or Instagram posts, or when posting different text to multiple platforms."),
     account_id: z
         .number()
         .int()
@@ -51,6 +51,7 @@ const CreatePostSchema = z.object({
         .optional()
         .describe("Array of social account IDs to post from. Takes precedence over account_id."),
 });
+const PLATFORM_ENUM = ["twitter", "linkedin", "threads", "instagram", "youtube", "bluesky", "facebook", "google_business"];
 const GeneratePostSchema = z.object({
     topic: z
         .string()
@@ -62,13 +63,19 @@ const GeneratePostSchema = z.object({
         .optional()
         .describe("Writing angle for the post"),
     platform: z
-        .enum(["twitter", "linkedin"])
+        .enum(["twitter", "linkedin", "threads", "instagram", "youtube", "bluesky"])
         .optional()
-        .describe("Target platform — twitter (default, max 280 chars) or linkedin (max 3000 chars). Controls output length and style."),
+        .describe("Target platform for a single-platform post — controls output length and style. Use platforms (array) instead to generate for multiple platforms at once."),
+    platforms: z
+        .array(z.enum(PLATFORM_ENUM))
+        .min(2)
+        .max(5)
+        .optional()
+        .describe("Generate platform-native variants for multiple platforms at once (2-5 platforms). Each variant counts as 1 quota. Returns variants array instead of body."),
 });
 const GenerateBatchSchema = z.object({
     category: z
-        .enum(["personalized", "trending", "viral"])
+        .enum(["personalized", "trending"])
         .describe("Category of posts to generate"),
     count: z
         .number()
@@ -76,10 +83,14 @@ const GenerateBatchSchema = z.object({
         .min(1)
         .max(9)
         .describe("Number of posts to generate (1-9). Cannot exceed your remaining daily quota."),
+    platform: z
+        .enum(PLATFORM_ENUM)
+        .optional()
+        .describe("Target platform — controls output length and style (default: twitter)."),
 });
 const EditPostSchema = z.object({
     id: z.number().int().positive().describe("Post ID"),
-    body: z.string().min(1).max(280).optional().describe("New X post body text (max 280 chars). Use post_contents to update LinkedIn or multiple platforms."),
+    body: z.string().min(1).max(280).optional().describe("New X post body text (max 280 chars). Use post_contents to update LinkedIn, Threads, Instagram, or multiple platforms."),
     post_contents: z
         .array(PostContentSchema)
         .min(1)
@@ -94,6 +105,22 @@ const EditPostSchema = z.object({
 const DeletePostSchema = z.object({
     id: z.number().int().positive().describe("Post ID to delete"),
 });
+const CarouselGenerateSchema = z.object({
+    topic: z.string().max(280).optional(),
+    slide_count: z.number().int().min(3).max(12).optional(),
+    theme: z.enum(["dark", "light", "blue", "green"]).optional(),
+    cta_text: z.string().max(100).optional(),
+});
+const ThreadGenerateSchema = z.object({
+    topic: z.string().max(280).optional().describe("Optional topic for the thread (max 280 chars)"),
+    tweet_count: z
+        .number()
+        .int()
+        .min(2)
+        .max(10)
+        .optional()
+        .describe("Number of tweets in the thread (2-10, default 5). Each tweet counts as 1 quota."),
+});
 export const postTools = [
     {
         name: "xreply_posts_list",
@@ -119,7 +146,10 @@ export const postTools = [
             "For X images: call xreply_media_upload first, include media_id in metadata. " +
             "For LinkedIn images: call xreply_media_upload first, include asset_urn in metadata. " +
             "For LinkedIn video: call xreply_video_upload first, include asset_urn in metadata, set content_type to 'video'. " +
-            "For YouTube video: set platform to 'youtube', content_type to 'video', include title in metadata (required), privacy_status (default: private), and optionally tags/category_id/thumbnail_url. Body is used as the video description. After publishing, the post will be in upload_pending status — call xreply_youtube_upload with the post_account_id and video file path to complete the upload.",
+            "For YouTube video: set platform to 'youtube', content_type to 'video', include title in metadata (required), privacy_status (default: private), and optionally tags/category_id/thumbnail_url. Body is used as the video description. After creating the draft, call xreply_youtube_upload with the post_id and video file path BEFORE publishing — then call xreply_posts_publish. " +
+            "For Threads: set platform to 'threads', body (max 500 chars). Image posts are supported via image_url in metadata. " +
+            "For Bluesky: set platform to 'bluesky', body (max 300 chars). Text-only posts supported. " +
+            "For Facebook Page: set platform to 'facebook', body (max 63206 chars). Supports text and single_image (image_url in metadata).",
         inputSchema: {
             type: "object",
             properties: {
@@ -127,21 +157,21 @@ export const postTools = [
                     type: "string",
                     minLength: 1,
                     maxLength: 280,
-                    description: "Post body text for X only (max 280 chars). Use post_contents for LinkedIn or cross-posting.",
+                    description: "Post body text for X only (max 280 chars). Use post_contents for LinkedIn, Threads, or cross-posting.",
                 },
                 post_contents: {
                     type: "array",
                     minItems: 1,
-                    description: "Per-platform content. Use this for LinkedIn posts or when posting different text to multiple platforms.",
+                    description: "Per-platform content. Use this for LinkedIn or Threads posts, or when posting different text to multiple platforms.",
                     items: {
                         type: "object",
                         properties: {
-                            platform: { type: "string", enum: ["twitter", "linkedin", "youtube"], description: "Target platform" },
-                            body: { type: "string", minLength: 1, maxLength: 3000, description: "Post body (max 280 for X, max 3000 for LinkedIn). For YouTube, used as video description (optional)." },
-                            content_type: { type: "string", enum: ["text", "single_image", "multi_image", "video"], description: "Content type (default: text). Use video for LinkedIn and YouTube video posts." },
+                            platform: { type: "string", enum: ["twitter", "linkedin", "youtube", "threads", "instagram", "bluesky", "facebook"], description: "Target platform" },
+                            body: { type: "string", minLength: 1, maxLength: 63206, description: "Post body (max 280 for X, max 3000 for LinkedIn, max 500 for Threads, max 300 for Bluesky, max 63206 for Facebook). For YouTube, used as video description (optional)." },
+                            content_type: { type: "string", enum: ["text", "single_image", "multi_image", "video", "document", "poll"], description: "Content type (default: text). Use video for LinkedIn and YouTube video posts. Use document for LinkedIn carousel posts (PDF). Use poll for LinkedIn polls." },
                             metadata: {
                                 type: "object",
-                                description: "Metadata for the post content. For X images: media_id or media_ids. For LinkedIn images: asset_urn or asset_urns. For LinkedIn/YouTube video: set content_type to video. For YouTube: title (required), privacy_status, category_id, tags, thumbnail_url. For X auto-retweet: auto_rt_hours. For X communities: community_id.",
+                                description: "Metadata for the post content. For X images: media_id or media_ids. For LinkedIn images: asset_urn or asset_urns. For LinkedIn/YouTube video: set content_type to video. For YouTube: title (required), privacy_status, category_id, tags, thumbnail_url. For Threads image: image_url (public HTTPS URL — no upload step needed). For X auto-retweet: auto_rt_hours. For X communities: community_id. For LinkedIn polls: question (max 140 chars), options (2-4 strings, max 30 chars each), duration (ONE_DAY, THREE_DAYS, SEVEN_DAYS, or FOURTEEN_DAYS).",
                                 properties: {
                                     media_id: { type: "string", description: "X only — media_id from xreply_media_upload (single image)" },
                                     media_ids: { type: "array", items: { type: "string" }, description: "X only — multiple media_ids from xreply_media_upload" },
@@ -154,6 +184,11 @@ export const postTools = [
                                     category_id: { type: "string", description: "YouTube only — numeric category ID (default: 22 = People & Blogs)" },
                                     tags: { type: "array", items: { type: "string" }, description: "YouTube only — video tags" },
                                     thumbnail_url: { type: "string", description: "YouTube only — URL of thumbnail image to set after upload completes" },
+                                    image_url: { type: "string", description: "Threads only — public HTTPS URL of image to attach (required for single_image content_type on Threads)" },
+                                    question: { type: "string", maxLength: 140, description: "LinkedIn poll only — the poll question (max 140 chars)" },
+                                    options: { type: "array", items: { type: "string", maxLength: 30 }, minItems: 2, maxItems: 4, description: "LinkedIn poll only — poll answer options (2-4 items, each max 30 chars)" },
+                                    duration: { type: "string", enum: ["ONE_DAY", "THREE_DAYS", "SEVEN_DAYS", "FOURTEEN_DAYS"], description: "LinkedIn poll only — how long the poll stays open" },
+                                    linkedin_org_id: { type: "string", description: "LinkedIn only — numeric org ID to post as an organization page instead of personal profile" },
                                 },
                             },
                         },
@@ -198,7 +233,7 @@ export const postTools = [
     },
     {
         name: "xreply_posts_generate",
-        description: "Generate a single AI post in the user's voice and auto-save it as a draft. Specify platform to control output length and style (x = max 280 chars, linkedin = max 3000 chars). Returns the generated body and the saved post ID. Counts as 1 generation against the daily quota (5/day free, 100/day pro).",
+        description: "Generate AI post(s) in the user's voice and auto-save as draft(s). Use platform (single) for one platform or platforms (array) for platform-native variants across multiple platforms at once. Each platform variant counts as 1 quota. Returns body + post for single-platform, variants + post for multi-platform.",
         inputSchema: {
             type: "object",
             properties: {
@@ -214,8 +249,15 @@ export const postTools = [
                 },
                 platform: {
                     type: "string",
-                    enum: ["twitter", "linkedin"],
-                    description: "Target platform — x (default, max 280 chars) or linkedin (max 3000 chars). Controls output length and style.",
+                    enum: ["twitter", "linkedin", "threads", "instagram", "youtube", "bluesky"],
+                    description: "Single target platform. Use platforms (array) instead for multi-platform generation.",
+                },
+                platforms: {
+                    type: "array",
+                    items: { type: "string", enum: ["twitter", "linkedin", "threads", "instagram", "youtube", "bluesky"] },
+                    minItems: 2,
+                    maxItems: 5,
+                    description: "Generate for multiple platforms at once — each gets platform-native content. 2-5 platforms. Each counts as 1 quota.",
                 },
             },
             required: [],
@@ -225,16 +267,21 @@ export const postTools = [
                 const params = GeneratePostSchema.parse(args);
                 const billing = await client.get("/api/v1/billing/subscriptions/current");
                 const remaining = billing.quota.replies_remaining_today;
-                if (remaining !== undefined && remaining !== null && remaining <= 0) {
-                    return err(`Daily generation quota exhausted (${billing.quota.daily_limit}/day on ${billing.tier} plan). Resets at midnight.`);
+                const platformCount = params.platforms ? params.platforms.length : 1;
+                if (remaining !== undefined && remaining !== null && remaining < platformCount) {
+                    return err(`Insufficient quota: need ${platformCount} but only ${remaining} remaining today (${billing.quota.daily_limit}/day on ${billing.tier} plan). Resets at midnight.`);
+                }
+                if (params.platforms && params.platforms.length >= 2) {
+                    const generated = await client.post("/api/v1/posts/generate", params);
+                    const variants = generated.variants ?? [];
+                    const postContents = variants.map((v) => ({ platform: v.platform, body: v.body, content_type: "text" }));
+                    const saved = await client.post("/api/v1/posts", { post: {}, post_contents: postContents });
+                    return ok({ variants, post: saved.post, quota_used: variants.length });
                 }
                 const generated = await client.post("/api/v1/posts/generate", params);
                 const platform = params.platform ?? "twitter";
                 const postContents = [{ platform, body: generated.body, content_type: "text" }];
-                const saved = await client.post("/api/v1/posts", {
-                    post: {},
-                    post_contents: postContents,
-                });
+                const saved = await client.post("/api/v1/posts", { post: {}, post_contents: postContents });
                 return ok({ body: generated.body, post: saved.post });
             }
             catch (e) {
@@ -244,13 +291,13 @@ export const postTools = [
     },
     {
         name: "xreply_posts_generate_batch",
-        description: "Generate multiple AI posts at once in the user's voice. Use 'personalized' for posts tailored to your voice profile, 'trending' for timely content, or 'viral' for posts inspired by viral formats. Returns an array of post body strings. Each post counts as 1 generation against the daily quota (5/day free, 100/day pro) — a single batch of 9 will exhaust a free account. Check xreply_billing_status first if quota is a concern.",
+        description: "Generate multiple AI posts at once in the user's voice. Use 'personalized' for posts tailored to your voice profile or 'trending' for timely content. Returns an array of post body strings. Each post counts as 1 generation against the daily quota (5/day free, 100/day pro) — a single batch of 9 will exhaust a free account. Check xreply_billing_status first if quota is a concern.",
         inputSchema: {
             type: "object",
             properties: {
                 category: {
                     type: "string",
-                    enum: ["personalized", "trending", "viral"],
+                    enum: ["personalized", "trending"],
                     description: "Category of posts to generate",
                 },
                 count: {
@@ -259,12 +306,17 @@ export const postTools = [
                     maximum: 9,
                     description: "Number of posts to generate (1-9). Cannot exceed your remaining daily quota.",
                 },
+                platform: {
+                    type: "string",
+                    enum: ["twitter", "linkedin", "threads", "instagram", "youtube", "bluesky"],
+                    description: "Target platform — controls output length and style (default: twitter).",
+                },
             },
             required: ["category", "count"],
         },
         async handler(args, client) {
             try {
-                const { category, count } = GenerateBatchSchema.parse(args);
+                const { category, count, platform } = GenerateBatchSchema.parse(args);
                 const billing = await client.get("/api/v1/billing/subscriptions/current");
                 const remaining = billing.quota.replies_remaining_today;
                 if (remaining !== undefined && remaining !== null && remaining <= 0) {
@@ -281,7 +333,7 @@ export const postTools = [
                 const safeCount = remaining !== undefined && remaining !== null
                     ? Math.min(count, remaining)
                     : count;
-                const result = await client.post("/api/v1/posts/generate_batch", { category, count: safeCount });
+                const result = await client.post("/api/v1/posts/generate_batch", { category, count: safeCount, ...(platform ? { platform } : {}) });
                 return ok(result);
             }
             catch (e) {
@@ -289,9 +341,120 @@ export const postTools = [
             }
         },
     },
+    {
+        name: "xreply_posts_generate_thread",
+        description: "Generate an X (Twitter) thread as a sequence of connected tweets in the user's voice. Returns an array of tweet strings — each under 240 chars, standalone but connected to the thread. Does NOT auto-save as a draft (unlike single-post generation); the caller is expected to review the tweets and create/publish posts separately. Each tweet counts as 1 generation against the daily quota.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                topic: {
+                    type: "string",
+                    maxLength: 280,
+                    description: "Optional topic for the thread. If omitted, AI picks from the user's voice profile.",
+                },
+                tweet_count: {
+                    type: "integer",
+                    minimum: 2,
+                    maximum: 10,
+                    description: "Number of tweets in the thread (2-10, default 5). Each tweet counts as 1 quota.",
+                },
+            },
+            required: [],
+        },
+        async handler(args, client) {
+            try {
+                const params = ThreadGenerateSchema.parse(args);
+                const tweetCount = params.tweet_count ?? 5;
+                const billing = await client.get("/api/v1/billing/subscriptions/current");
+                const remaining = billing.quota.replies_remaining_today;
+                if (remaining !== undefined && remaining !== null && remaining < tweetCount) {
+                    return err(`Insufficient quota: need ${tweetCount} but only ${remaining} remaining today (${billing.quota.daily_limit}/day on ${billing.tier} plan). Resets at midnight.`);
+                }
+                const result = await client.post("/api/v1/posts/generate_thread", { topic: params.topic, tweet_count: tweetCount });
+                return ok({ tweets: result.tweets, count: result.tweets.length });
+            }
+            catch (e) {
+                return err(e);
+            }
+        },
+    },
+    {
+        name: "xreply_carousel_generate",
+        description: "Generate an AI-written LinkedIn carousel post from a topic/prompt. The AI creates structured slides in the user's voice, renders them as a PDF, and auto-saves as a draft LinkedIn post. Returns the slides, post, and document_urn. Counts as 1 generation against the daily quota.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                topic: {
+                    type: "string",
+                    maxLength: 280,
+                    description: "Optional topic or prompt for the carousel. If omitted, AI picks from the user's voice profile.",
+                },
+                slide_count: {
+                    type: "integer",
+                    minimum: 3,
+                    maximum: 12,
+                    description: "Number of slides (3-12, default 3). Includes cover and CTA slides.",
+                },
+                theme: {
+                    type: "string",
+                    enum: ["dark", "light", "blue", "green"],
+                    description: "Visual theme for the PDF (default: dark).",
+                },
+                cta_text: {
+                    type: "string",
+                    maxLength: 100,
+                    description: "Custom text for the last slide (e.g. 'Follow me for more async tips'). If omitted, AI generates one.",
+                },
+            },
+            required: [],
+        },
+        async handler(args, client) {
+            try {
+                const billing = await client.get("/api/v1/billing/subscriptions/current");
+                const remaining = billing.quota.replies_remaining_today;
+                if (remaining !== undefined && remaining !== null && remaining < 1) {
+                    return err(`Insufficient quota: 0 remaining today (${billing.quota.daily_limit}/day on ${billing.tier} plan). Resets at midnight.`);
+                }
+                const accounts = await client.get("/api/v1/social_accounts");
+                const linkedinAccount = accounts.social_accounts.find((a) => a.platform === "linkedin");
+                if (!linkedinAccount) {
+                    return err("No LinkedIn account connected. Please connect LinkedIn in settings first.");
+                }
+                const parsed = CarouselGenerateSchema.parse(args);
+                const body = { social_account_id: linkedinAccount.id };
+                if (parsed.topic !== undefined)
+                    body.topic = parsed.topic;
+                if (parsed.slide_count !== undefined)
+                    body.slide_count = parsed.slide_count;
+                if (parsed.theme !== undefined)
+                    body.theme = parsed.theme;
+                if (parsed.cta_text !== undefined)
+                    body.cta_text = parsed.cta_text;
+                const generated = await client.post("/api/v1/posts/generate_carousel", body);
+                const saved = await client.post("/api/v1/posts", {
+                    post: {},
+                    post_contents: [{
+                            platform: "linkedin",
+                            body: generated.caption,
+                            content_type: "document",
+                            metadata: { document_urn: generated.document_urn, title: generated.title },
+                        }],
+                });
+                return ok({
+                    slides: generated.slides,
+                    caption: generated.caption,
+                    document_urn: generated.document_urn,
+                    post: saved.post,
+                });
+            }
+            catch (e) {
+                return err(e);
+            }
+        },
+    },
     {
         name: "xreply_posts_edit",
-        description: "Edit a post's content, scheduled time, or auto-retweet setting. Use `body` to update X-only text, or `post_contents` to update per-platform content (LinkedIn, YouTube, or cross-platform). Set scheduled_at to an ISO 8601 datetime to schedule, or null to move back to draft. Cannot edit posts that are processing or already posted. " +
+        description: "Edit a post's content, scheduled time, or auto-retweet setting. Use `body` to update X-only text, or `post_contents` to update per-platform content (LinkedIn, YouTube, Threads, or cross-platform). Set scheduled_at to an ISO 8601 datetime to schedule, or null to move back to draft. Cannot edit posts that are processing or already posted. " +
             "For X images: call xreply_media_upload first, include media_id in metadata. " +
             "For LinkedIn images: call xreply_media_upload first, include asset_urn in metadata. " +
             "For LinkedIn video: call xreply_video_upload first, include asset_urn in metadata, set content_type to 'video'. " +
@@ -308,12 +471,12 @@ export const postTools = [
                     items: {
                         type: "object",
                         properties: {
-                            platform: { type: "string", enum: ["twitter", "linkedin", "youtube"], description: "Target platform" },
-                            body: { type: "string", minLength: 1, maxLength: 3000, description: "Post body (max 280 for X, max 3000 for LinkedIn). For YouTube, used as video description (optional)." },
-                            content_type: { type: "string", enum: ["text", "single_image", "multi_image", "video"], description: "Content type (default: text). Use video for LinkedIn and YouTube video posts." },
+                            platform: { type: "string", enum: ["twitter", "linkedin", "youtube", "threads", "instagram", "bluesky", "facebook"], description: "Target platform" },
+                            body: { type: "string", minLength: 1, maxLength: 63206, description: "Post body (max 280 for X, max 3000 for LinkedIn, max 500 for Threads, max 300 for Bluesky, max 63206 for Facebook). For YouTube, used as video description (optional)." },
+                            content_type: { type: "string", enum: ["text", "single_image", "multi_image", "video", "document", "poll"], description: "Content type (default: text). Use video for LinkedIn and YouTube video posts. Use document for LinkedIn carousel posts (PDF). Use poll for LinkedIn polls." },
                             metadata: {
                                 type: "object",
-                                description: "Metadata for the post content. For X images: media_id or media_ids. For LinkedIn images: asset_urn or asset_urns. For LinkedIn/YouTube video: set content_type to video. For YouTube: title (required), privacy_status, category_id, tags, thumbnail_url. For X auto-retweet: auto_rt_hours. For X communities: community_id.",
+                                description: "Metadata for the post content. For X images: media_id or media_ids. For LinkedIn images: asset_urn or asset_urns. For LinkedIn/YouTube video: set content_type to video. For YouTube: title (required), privacy_status, category_id, tags, thumbnail_url. For Threads image: image_url (public HTTPS URL — no upload step needed). For X auto-retweet: auto_rt_hours. For X communities: community_id. For LinkedIn polls: question (max 140 chars), options (2-4 strings, max 30 chars each), duration (ONE_DAY, THREE_DAYS, SEVEN_DAYS, or FOURTEEN_DAYS).",
                                 properties: {
                                     media_id: { type: "string", description: "X only — media_id from xreply_media_upload (single image)" },
                                     media_ids: { type: "array", items: { type: "string" }, description: "X only — multiple media_ids from xreply_media_upload" },
@@ -326,6 +489,11 @@ export const postTools = [
                                     category_id: { type: "string", description: "YouTube only — numeric category ID (default: 22 = People & Blogs)" },
                                     tags: { type: "array", items: { type: "string" }, description: "YouTube only — video tags" },
                                     thumbnail_url: { type: "string", description: "YouTube only — URL of thumbnail image to set after upload completes" },
+                                    image_url: { type: "string", description: "Threads only — public HTTPS URL of image to attach (required for single_image content_type on Threads)" },
+                                    question: { type: "string", maxLength: 140, description: "LinkedIn poll only — the poll question (max 140 chars)" },
+                                    options: { type: "array", items: { type: "string", maxLength: 30 }, minItems: 2, maxItems: 4, description: "LinkedIn poll only — poll answer options (2-4 items, each max 30 chars)" },
+                                    duration: { type: "string", enum: ["ONE_DAY", "THREE_DAYS", "SEVEN_DAYS", "FOURTEEN_DAYS"], description: "LinkedIn poll only — how long the poll stays open" },
+                                    linkedin_org_id: { type: "string", description: "LinkedIn only — numeric org ID to post as an organization page instead of personal profile" },
                                 },
                             },
                         },
@@ -512,43 +680,48 @@ export const postTools = [
     },
     {
         name: "xreply_youtube_upload",
-        description: "Upload a local video file to YouTube for a post that is in upload_pending status. " +
-            "YouTube uses a resumable upload flow: after xreply_posts_publish returns upload_pending " +
-            "(whether publishing immediately or scheduling for a future time), " +
-            "call this tool with the post_account_id and the local video file path. " +
-            "The tool fetches the upload URL from the backend, PUTs the video directly to YouTube, " +
-            "then confirms the upload. For scheduled posts, YouTube automatically publishes the video " +
-            "at the scheduled time — no further action needed after upload. " +
-            "The post_account_id is the id field inside post_accounts[] in the publish response where platform is 'youtube'. " +
-            "Supports all YouTube-accepted video formats (MP4, MOV, AVI, WMV, FLV, WebM, MPEG, 3GPP). Maximum file size: 100 MB. " +
+        description: "Upload a local video file for a YouTube post draft BEFORE publishing. " +
+            "Call this after xreply_posts_create (with platform 'youtube' and content_type 'video') but BEFORE xreply_posts_publish. " +
+            "The tool uploads the video to staging storage, then patches the post metadata with the storage key so the backend can finish the YouTube upload automatically after you publish. " +
+            "Once this succeeds, call xreply_posts_publish — the backend handles the rest asynchronously. " +
+            "Supports MP4, MOV, M4V, WebM, MPEG, 3GPP. Maximum file size: 50 MB. " +
             "Note: requires filesystem access — works in Claude Code, Cursor, and mcporter (CLI). Not available in Claude.ai.",
         inputSchema: {
             type: "object",
             properties: {
-                post_account_id: {
+                post_id: {
                     type: "integer",
-                    description: "The post_account id for the YouTube platform entry (from post_accounts[] in the publish response)",
+                    description: "The id of the YouTube post draft (from xreply_posts_create)",
                 },
                 video_path: {
                     type: "string",
-                    description: "Absolute or relative path to the video file on disk (max 100 MB)",
+                    description: "Absolute or relative path to the video file on disk (max 50 MB)",
                 },
             },
-            required: ["post_account_id", "video_path"],
+            required: ["post_id", "video_path"],
         },
         async handler(args, client) {
             try {
-                const { post_account_id, video_path } = z
+                const { post_id, video_path } = z
                     .object({
-                    post_account_id: z.number().int().positive(),
+                    post_id: z.number().int().positive(),
                     video_path: z.string().min(1),
                 })
                     .parse(args);
                 const resolvedPath = path.resolve(video_path);
-                const SUPPORTED_EXTS = new Set([".mp4", ".mov", ".avi", ".wmv", ".flv", ".webm", ".mpeg", ".mpg", ".3gp"]);
+                const contentTypeMap = {
+                    ".mp4": "video/mp4",
+                    ".mov": "video/quicktime",
+                    ".m4v": "video/x-m4v",
+                    ".webm": "video/webm",
+                    ".mpeg": "video/mpeg",
+                    ".mpg": "video/mpeg",
+                    ".3gp": "video/3gpp",
+                };
                 const ext = path.extname(resolvedPath).toLowerCase();
-                if (!SUPPORTED_EXTS.has(ext)) {
-                    return err(`Unsupported video format "${ext}". Supported: ${[...SUPPORTED_EXTS].join(", ")}`);
+                const contentType = contentTypeMap[ext];
+                if (!contentType) {
+                    return err(`Unsupported video format "${ext}". Supported: ${Object.keys(contentTypeMap).join(", ")}`);
                 }
                 let fileData;
                 try {
@@ -557,34 +730,18 @@ export const postTools = [
                 catch (e) {
                     return err(`Cannot read file at ${resolvedPath}: ${e instanceof Error ? e.message : String(e)}`);
                 }
-                const MAX_SIZE = 100 * 1024 * 1024;
+                const MAX_SIZE = 50 * 1024 * 1024;
                 if (fileData.byteLength > MAX_SIZE) {
-                    return err(`Video file is ${(fileData.byteLength / 1024 / 1024).toFixed(1)} MB — maximum allowed is 100 MB.`);
+                    return err(`Video file is ${(fileData.byteLength / 1024 / 1024).toFixed(1)} MB — maximum allowed is 50 MB.`);
                 }
-                const status = await client.get(`/api/v1/youtube/uploads/${post_account_id}/status`);
-                if (status.platform_status !== "upload_pending") {
-                    return err(`Expected platform_status "upload_pending" but got "${status.platform_status}". Has this upload already been completed?`);
-                }
-                if (!status.upload_url) {
-                    return err("No upload_url found for this post account. The backend may not have successfully initiated the YouTube upload.");
-                }
-                const contentTypeMap = {
-                    ".mp4": "video/mp4",
-                    ".mov": "video/quicktime",
-                    ".avi": "video/x-msvideo",
-                    ".wmv": "video/x-ms-wmv",
-                    ".flv": "video/x-flv",
-                    ".webm": "video/webm",
-                    ".mpeg": "video/mpeg",
-                    ".mpg": "video/mpeg",
-                    ".3gp": "video/3gpp",
-                };
-                const contentType = contentTypeMap[ext] ?? "video/mp4";
+                // Get a presigned R2 URL from the backend
+                const presign = await client.post("/api/v1/youtube/uploads/presign", { content_type: contentType });
+                // PUT the video directly to R2
                 const uploadController = new AbortController();
                 const uploadTimer = setTimeout(() => uploadController.abort(), 300_000);
                 let uploadResponse;
                 try {
-                    uploadResponse = await fetch(status.upload_url, {
+                    uploadResponse = await fetch(presign.upload_url, {
                         method: "PUT",
                         headers: { "Content-Type": contentType },
                         body: fileData,
@@ -594,26 +751,33 @@ export const postTools = [
                 catch (e) {
                     clearTimeout(uploadTimer);
                     if (e instanceof Error && e.name === "AbortError") {
-                        return err("YouTube upload timed out after 5 minutes. Try a smaller file or check your connection.");
+                        return err("Video upload timed out after 5 minutes. Try a smaller file or check your connection.");
                     }
-                    return err(`YouTube upload failed: ${e instanceof Error ? e.message : String(e)}`);
+                    return err(`Video upload failed: ${e instanceof Error ? e.message : String(e)}`);
                 }
                 clearTimeout(uploadTimer);
                 if (!uploadResponse.ok) {
                     const body = await uploadResponse.text().catch(() => "");
-                    return err(`YouTube upload failed with HTTP ${uploadResponse.status}: ${body}`);
-                }
-                const location = uploadResponse.headers.get("Location") ?? uploadResponse.headers.get("location");
-                if (!location) {
-                    return err("YouTube did not return a video location after upload. The upload may have succeeded — check your YouTube Studio.");
-                }
-                const videoIdMatch = location.match(/[?&]id=([A-Za-z0-9_-]{11})/);
-                if (!videoIdMatch) {
-                    return err(`Could not extract video_id from YouTube response location: ${location}`);
+                    return err(`Video upload failed with HTTP ${uploadResponse.status}: ${body}`);
                 }
-                const videoId = videoIdMatch[1];
-                await client.post(`/api/v1/youtube/uploads/${post_account_id}/confirm`, { video_id: videoId });
-                return ok({ success: true, platform: "youtube", video_id: videoId, youtube_url: `https://www.youtube.com/watch?v=${videoId}` });
+                // Patch the post's YouTube content metadata with the r2_key so the backend
+                // can pick it up when the post is published
+                const post = await client.get(`/api/v1/posts/${post_id}`);
+                const ytContent = post.post?.post_contents?.find((pc) => pc.platform === "youtube");
+                const existingMeta = { ...ytContent?.metadata };
+                await client.patch(`/api/v1/posts/${post_id}`, {
+                    post_contents: [
+                        {
+                            platform: "youtube",
+                            metadata: { ...existingMeta, r2_key: presign.r2_key },
+                        },
+                    ],
+                });
+                return ok({
+                    success: true,
+                    r2_key: presign.r2_key,
+                    message: "Video uploaded to staging. Call xreply_posts_publish to complete the post.",
+                });
             }
             catch (e) {
                 return err(e);