posterly-mcp-server 0.48.4 → 0.49.0

package/src/tools/get-updates.ts

@@ -1,12 +1,14 @@
 import { z } from 'zod';
 import type { PosterlyClient } from '../lib/api-client.js';
+import { formatPagingNote } from '../lib/format.js';
 
 export const getUpdatesTool = {
   name: 'get_updates',
   description:
-    'Get the latest posterly product updates and news from the updates feed: new features, improvements, and fixes. Requires an active posterly subscription.',
+    'Get the latest posterly product updates and news from the updates feed: new features, improvements, and fixes, newest first. The output says whether more updates exist; page with offset or narrow with since. Requires an active posterly subscription.',
   inputSchema: z.object({
     limit: z.number().int().min(1).max(50).optional().describe('Number of updates to return. Default 10, max 50.'),
+    offset: z.number().int().min(0).optional().describe('How many updates to skip. Use the offset the previous page gives to get the next page.'),
     since: z.string().optional().describe('ISO date. Return updates published on or after this date.'),
     include_content: z.boolean().optional().describe('Include the full markdown body of each update. Defaults to false.'),
   }),
@@ -15,6 +17,7 @@ export const getUpdatesTool = {
     client: PosterlyClient,
     input: {
       limit?: number;
+      offset?: number;
       since?: string;
       include_content?: boolean;
     },
@@ -36,6 +39,17 @@ export const getUpdatesTool = {
       }
     }
 
+    lines.push('', formatPagingNote({
+      noun: 'updates',
+      tool: 'get_updates',
+      offset: result.offset ?? input.offset ?? 0,
+      count: result.updates.length,
+      total: result.total,
+      // An API older than has_more: a full page may mean more exist.
+      hasMore: result.has_more ?? result.updates.length >= (input.limit || 10),
+      nextOffset: result.next_offset,
+    }));
+
     return lines.join('\n');
   },
 };

package/src/tools/list-activity.ts

@@ -1,16 +1,18 @@
 import { z } from 'zod';
 import type { PosterlyClient } from '../lib/api-client.js';
+import { formatPagingNote } from '../lib/format.js';
 
 export const listActivityTool = {
   name: 'list_activity',
   description:
-    'List recent activity and publish events for posts, including status changes, publish attempts, failures, and retries. Use this as the agent notifications feed.',
+    'List recent activity and publish events for posts, including status changes, publish attempts, failures, and retries, newest first. Use this as the agent notifications feed. The output says whether more events exist; page with offset (offset + limit up to 1000) or narrow with since or post_id before concluding nothing else happened.',
   inputSchema: z.object({
     workspace_id: z.string().optional().describe('Filter to a workspace ID from whoami.'),
     post_id: z.number().int().positive().optional().describe('Filter to one post ID.'),
     since: z.string().optional().describe('ISO datetime. Return events created at or after this time.'),
     type: z.enum(['all', 'activity', 'publish']).optional().describe('Event source filter. Defaults to all.'),
     limit: z.number().int().min(1).max(100).optional().describe('Number of items to return. Default 50, max 100.'),
+    offset: z.number().int().min(0).optional().describe('How many events to skip. Use the offset the previous page gives to get the next page.'),
   }),
 
   async execute(
@@ -21,15 +23,18 @@ export const listActivityTool = {
       since?: string;
       type?: 'all' | 'activity' | 'publish';
       limit?: number;
+      offset?: number;
     },
   ) {
     const result = await client.listActivity(input);
     if (result.items.length === 0) {
-      return 'No activity found matching your filters.';
+      return (input.offset ?? 0) > 0
+        ? `No activity on this page: offset ${input.offset} is past the last matching event.`
+        : 'No activity found matching your filters.';
     }
 
     const lines = [
-      `Activity (${result.items.length} of ${result.total}):`,
+      `Activity (${result.items.length} on this page):`,
     ];
 
     for (const item of result.items) {
@@ -45,6 +50,16 @@ export const listActivityTool = {
       }
     }
 
+    lines.push('', formatPagingNote({
+      noun: 'events',
+      tool: 'list_activity',
+      offset: result.offset ?? input.offset ?? 0,
+      count: result.items.length,
+      // An API older than has_more: a full page may mean more exist.
+      hasMore: result.has_more ?? result.items.length >= (result.limit || 50),
+      nextOffset: result.next_offset,
+    }));
+
     return lines.join('\n');
   },
 };

package/src/tools/list-media.ts

@@ -1,10 +1,11 @@
 import { z } from 'zod';
 import type { PosterlyClient } from '../lib/api-client.js';
+import { formatPagingNote } from '../lib/format.js';
 
 export const listMediaTool = {
   name: 'list_media',
   description:
-    'List the newest media assets for the authenticated user. After create_media_drop, pass drop_session_id to see files the human uploaded on /drop/<token>. Use public_url with validate_post / create_post.',
+    'List the newest media assets for the authenticated user. After create_media_drop, pass drop_session_id to see files the human uploaded on /drop/<token>. Use public_url with validate_post / create_post. The output says whether every matching file is shown; page with offset (offset + limit up to 1000) when it is not.',
   inputSchema: z.object({
     limit: z
       .number()
@@ -13,6 +14,12 @@ export const listMediaTool = {
       .max(50)
       .optional()
       .describe('Number of assets to return (default 10, max 50)'),
+    offset: z
+      .number()
+      .int()
+      .min(0)
+      .optional()
+      .describe('How many assets to skip. Use the offset the previous page gives to get the next page.'),
     drop_session_id: z
       .string()
       .optional()
@@ -21,14 +28,18 @@ export const listMediaTool = {
 
   async execute(
     client: PosterlyClient,
-    input: { limit?: number; drop_session_id?: string },
+    input: { limit?: number; offset?: number; drop_session_id?: string },
   ) {
     const result = await client.listMedia({
       limit: input.limit,
+      offset: input.offset,
       dropSessionId: input.drop_session_id,
     });
 
     if (result.media.length === 0) {
+      if ((input.offset ?? 0) > 0 && result.total > 0) {
+        return `No media on this page: offset ${input.offset} is past the last of the ${result.total} matching files.`;
+      }
       return 'No media found. If you just sent a drop URL, wait for the user to finish uploading, then call list_media again.';
     }
 
@@ -38,10 +49,20 @@ export const listMediaTool = {
       return `• ${item.filename} (${item.mime || 'unknown'}, ${size})${drop}\n  public_url: ${item.public_url}`;
     });
 
+    const offset = result.offset ?? input.offset ?? 0;
     return [
       `Media (${result.media.length} of ${result.total}):`,
       ...lines,
       '',
+      formatPagingNote({
+        noun: 'files',
+        tool: 'list_media',
+        offset,
+        count: result.media.length,
+        total: result.total,
+        hasMore: result.has_more ?? offset + result.media.length < result.total,
+        nextOffset: result.next_offset,
+      }),
       'Pass public_url to validate_post / create_post. Do not invent URLs.',
     ].join('\n');
   },

package/src/tools/list-post-suggestions.ts

@@ -1,11 +1,11 @@
 import { z } from 'zod';
 import type { PosterlyClient } from '../lib/api-client.js';
-import { mdTitle, mdSection, mdKeyValue, mdEmpty, truncateText } from '../lib/format.js';
+import { formatPagingNote, mdTitle, mdSection, mdKeyValue, mdEmpty, truncateText } from '../lib/format.js';
 
 export const listPostSuggestionsTool = {
   name: 'list_post_suggestions',
   description:
-    "List proactive post suggestions: evidence-based weekly drafts posterly writes in each account's learned voice, each with a rationale tying it back to what has performed well for that account. Filter by account_id and status (pending, scheduled, dismissed; default pending). Read-only; requires a Pro plan or higher. Use dismiss_suggestion to hide one.",
+    "List proactive post suggestions: evidence-based weekly drafts posterly writes in each account's learned voice, each with a rationale tying it back to what has performed well for that account. Filter by account_id and status (pending, scheduled, dismissed; default pending). The output says whether every matching suggestion is shown; page with offset until it does. Read-only; requires a Pro plan or higher. Use dismiss_suggestion to hide one.",
   inputSchema: z.object({
     account_id: z
       .union([z.string(), z.number()])
@@ -16,6 +16,7 @@ export const listPostSuggestionsTool = {
       .optional()
       .describe('Suggestion status to list (default pending).'),
     limit: z.number().int().min(1).max(100).optional().describe('Max suggestions to return (default 20).'),
+    offset: z.number().int().min(0).optional().describe('How many suggestions to skip. Use the offset the previous page gives to get the next page.'),
   }),
 
   async execute(
@@ -24,9 +25,11 @@ export const listPostSuggestionsTool = {
       account_id?: string | number;
       status?: 'pending' | 'scheduled' | 'dismissed';
       limit?: number;
+      offset?: number;
     },
   ) {
-    const { suggestions } = await client.listPostSuggestions(input);
+    const page = await client.listPostSuggestions(input);
+    const { suggestions } = page;
 
     if (!suggestions.length) {
       return mdEmpty(
@@ -51,6 +54,16 @@ export const listPostSuggestionsTool = {
       );
     });
 
-    return [mdTitle(`Post suggestions (${suggestions.length})`), ...blocks].join('\n\n');
+    const note = formatPagingNote({
+      noun: 'suggestions',
+      tool: 'list_post_suggestions',
+      offset: page.offset ?? input.offset ?? 0,
+      count: suggestions.length,
+      total: page.total,
+      // An API older than has_more: a full page may mean more exist.
+      hasMore: page.has_more ?? suggestions.length >= (input.limit || 20),
+      nextOffset: page.next_offset,
+    });
+    return [mdTitle(`Post suggestions (${suggestions.length})`), ...blocks, note].join('\n\n');
   },
 };

package/src/tools/list-posts.ts

@@ -1,13 +1,31 @@
 import { z } from 'zod';
-import type { PosterlyClient } from '../lib/api-client.js';
-import { dashboardUrlForPostList, formatLocalDateTime, truncateText } from '../lib/format.js';
+import type { ListPostsParams, PosterlyClient } from '../lib/api-client.js';
+import { dashboardUrlForPostList, formatPostCounts, formatPostListPage } from '../lib/format.js';
+import { validateArgs, type ToolContext } from '../lib/tool-runtime.js';
 import { SUPPORTED_PLATFORM_INPUTS, SUPPORTED_PLATFORM_IDS } from '../generated/platform-manifest.js';
 
+type ListPostsInput = ListPostsParams & {
+  view?: 'list' | 'counts';
+  limit?: number;
+  offset?: number;
+  order?: 'asc' | 'desc';
+};
+
+export const LIST_POSTS_DESCRIPTION =
+  'Posts in your workspaces, teammates\' too, per your role there (brand-locked seats only see their assigned brands). If workspace_id is omitted, this searches every workspace you belong to. ' +
+  'view=list (default): posts filtered by status (scheduled, published, failed, draft), platform, account_id, workspace_id, brand_id, approval_status, approval_waiting_on, and a scheduled date range: scheduled_from (inclusive) and scheduled_to (a plain date includes that whole day), read in timezone (IANA, default UTC; also the zone times are shown in). Returns limit posts (default 20, max 200) starting at offset; with a date range the order defaults to oldest first (order=asc|desc). ' +
+  'The output always says whether every matching post was shown. If it says more are available, call again with the offset it gives and keep paging until all are shown before drawing any conclusion about totals, gaps, or how busy a client is. ' +
+  'view=counts (scheduled_from and scheduled_to required, up to 366 days): exact totals per day, status, account, and brand for the same filters (limit, offset, and order are ignored); use it for "how many" or "is this month full" questions. ' +
+  'approval_waiting_on=client is the same queue as approval_status=pending_client. Each post includes approval.pending_client_approval.';
+
 export const listPostsTool = {
   name: 'list_posts',
-  description:
-    'List upcoming or recent posts. Filter by status (scheduled, published, failed, draft), platform, account_id, workspace_id, approval_status, approval_waiting_on, or brand_id. approval_waiting_on=client is the same queue as approval_status=pending_client. Each post includes approval.pending_client_approval. Returns posts in your workspaces, teammates\' too, per your role there (brand-locked seats only see their assigned brands). If workspace_id is omitted, this searches every workspace you belong to.',
+  description: LIST_POSTS_DESCRIPTION,
   inputSchema: z.object({
+    view: z
+      .enum(['list', 'counts'])
+      .optional()
+      .describe('list (default): the posts themselves, one page at a time. counts: exact totals per day, status, account, and brand (needs scheduled_from and scheduled_to).'),
     status: z
       .string()
       .optional()
@@ -20,12 +38,34 @@ export const listPostsTool = {
       .string()
       .optional()
       .describe('Filter to a specific social account ID (from list_accounts).'),
+    scheduled_from: z
+      .string()
+      .optional()
+      .describe('Start of the scheduled range, inclusive: a date (2026-10-01) or an ISO date-time. Plain dates and times without an offset are read in timezone.'),
+    scheduled_to: z
+      .string()
+      .optional()
+      .describe('End of the scheduled range: a plain date (2026-10-31) includes that whole day; an ISO date-time is exclusive.'),
+    timezone: z
+      .string()
+      .optional()
+      .describe('IANA time zone such as Europe/London for reading plain dates and showing times. Default UTC.'),
+    order: z
+      .enum(['asc', 'desc'])
+      .optional()
+      .describe('asc (oldest first) or desc (newest first). Default asc with a date range, otherwise desc. Ignored by view=counts.'),
     limit: z
       .number()
       .min(1)
-      .max(100)
+      .max(200)
+      .optional()
+      .describe('Posts per page (default 20, max 200). Ignored by view=counts.'),
+    offset: z
+      .number()
+      .int()
+      .min(0)
       .optional()
-      .describe('Number of posts to return (default 20, max 100)'),
+      .describe('How many matching posts to skip. Use the offset the previous page gives to get the next page. Ignored by view=counts.'),
     workspace_id: z
       .string()
       .optional()
@@ -44,48 +84,37 @@ export const listPostsTool = {
       .describe('Filter to posts assigned to a specific brand/client (the id from list_brands).'),
   }),
 
-  async execute(
-    client: PosterlyClient,
-    input: {
-      status?: string;
-      platform?: string;
-      account_id?: string;
-      limit?: number;
-      workspace_id?: string;
-      approval_status?: string;
-      approval_waiting_on?: 'client' | 'team';
-      brand_id?: string;
-    }
-  ) {
-    const { posts, total } = await client.listPosts({
-      ...input,
-      limit: input.limit || 20,
-    });
+  async execute(client: PosterlyClient, input: ListPostsInput, ctx: ToolContext) {
+    const { mode, args } = validateArgs(ctx, 'list_posts', input);
+    const filters = postFilters(args as ListPostsInput);
+    const timeZone = filters.timezone || 'UTC';
 
-    if (posts.length === 0) {
-      return 'No posts found matching your criteria.\n\nNext step for the AI agent: tell the user their posterly queue is clear for that filter, then ask what they want to schedule next.';
+    if (mode === 'counts') {
+      return formatPostCounts(await client.countPosts(filters));
     }
 
-    const lines = posts.map((p) => {
-      const date = formatLocalDateTime(p.scheduled_at);
-      const caption = truncateText(p.content, 60);
-      const approvalBits: string[] = [];
-      if (p.approval && p.approval.status !== 'none') {
-        approvalBits.push(`approval: ${p.approval.status}`);
-        if (p.approval.waiting_on) approvalBits.push(`waiting on: ${p.approval.waiting_on}`);
-      }
-      if (p.brand_id) approvalBits.push(`brand: ${p.brand_id}`);
-      if (p.content_plan_id) approvalBits.push(`plan: ${p.content_plan_id}`);
-      const approvalSuffix = approvalBits.length > 0 ? ` [${approvalBits.join(', ')}]` : '';
-      return `• [${p.status}] #${p.id}: ${caption} (${date})${approvalSuffix}`;
+    const hasRange = Boolean(filters.scheduled_from || filters.scheduled_to);
+    const page = await client.listPosts({
+      ...filters,
+      limit: (args as ListPostsInput).limit || 20,
+      offset: (args as ListPostsInput).offset,
+      order: (args as ListPostsInput).order ?? (hasRange ? 'asc' : undefined),
     });
-
-    return [
-      `Posts (${posts.length} of ${total}):`,
-      ...lines,
-      '',
-      `View in posterly: ${dashboardUrlForPostList(posts)}`,
-      'Next step for the AI agent: summarize the queue in plain language and use the dashboard link above if the user wants to inspect it in posterly.',
-    ].join('\n');
+    return formatPostListPage(page, { timeZone, dashboardUrl: dashboardUrlForPostList(page.posts || []) });
   },
 };
+
+function postFilters(input: ListPostsInput): ListPostsParams {
+  return {
+    status: input.status,
+    platform: input.platform,
+    account_id: input.account_id,
+    workspace_id: input.workspace_id,
+    approval_status: input.approval_status,
+    approval_waiting_on: input.approval_waiting_on,
+    brand_id: input.brand_id,
+    scheduled_from: input.scheduled_from,
+    scheduled_to: input.scheduled_to,
+    timezone: input.timezone,
+  };
+}

package/src/tools/list-publishing-pauses.ts

@@ -0,0 +1,98 @@
+import { z } from 'zod';
+import type {
+  PosterlyClient,
+  PublishingPauseChangeResponse,
+  PublishingPauseState,
+  PublishMissedResponse,
+} from '../lib/api-client.js';
+
+// Plain-text output shared by list_publishing_pauses and
+// manage_publishing_pause. The hosted endpoint (lib/mcp/http-tools.ts) renders
+// the same text from the same API responses; scripts/test-publishing-pause-api.ts
+// checks the two surfaces match.
+
+function yesNo(value: unknown): string {
+  return value ? 'yes' : 'no';
+}
+
+function idList(ids: number[] | undefined): string {
+  return Array.isArray(ids) && ids.length > 0 ? ids.join(', ') : 'none';
+}
+
+function scopeText(data: { scope?: string; workspace_id?: string; brand_id?: string | null; brand_name?: string | null; workspace_name?: string | null }): string {
+  if (data.scope === 'brand') return `brand ${data.brand_name ? `${data.brand_name} ` : ''}(${data.brand_id})`;
+  return `the workspace ${data.workspace_name ? `${data.workspace_name} ` : ''}(${data.workspace_id})`;
+}
+
+export function formatPublishingPauseState(data: PublishingPauseState): string {
+  const workspace = data.workspace;
+  const brands = Array.isArray(data.brands) ? data.brands : [];
+  const viewer = data.viewer;
+  return [
+    `Publishing pause for ${workspace.name || 'this workspace'} (${workspace.id})`,
+    `Workspace: ${workspace.paused ? `paused since ${workspace.paused_at}` : 'publishing normally'}`,
+    brands.length > 0
+      ? ['Paused brands:', ...brands.map((brand) => `- ${brand.name || 'Unnamed brand'} (${brand.id}), paused since ${brand.paused_at}`)].join('\n')
+      : 'Paused brands: none',
+    `Your role: ${viewer.role}. Pause the workspace: ${yesNo(viewer.can_pause_workspace)}. Pause a brand: ${yesNo(viewer.can_pause_brand)}. Resume and publish missed posts: ${yesNo(viewer.can_resume)}.`,
+    'While paused, nothing in that scope publishes (scheduled posts are held, Post now is refused). Pause and resume with manage_publishing_pause.',
+  ].join('\n');
+}
+
+export function formatPublishingPauseChange(data: PublishingPauseChangeResponse): string {
+  if (data.requires_confirmation) {
+    return [
+      'Preview only: nothing has changed yet.',
+      data.error || '',
+      `Scope: ${scopeText(data)}`,
+      `Scheduled posts to hold: ${typeof data.scheduled_posts_to_hold === 'number' ? data.scheduled_posts_to_hold : 'unknown'}`,
+      `Already paused: ${yesNo(data.already_paused)}`,
+      'Next step: show this to the user. Only after they agree, call manage_publishing_pause again with action=pause, the same fields, and confirm=true.',
+    ].filter(Boolean).join('\n');
+  }
+
+  if (data.action === 'pause') {
+    const failed = data.failed_post_ids || [];
+    return [
+      `Publishing paused for ${scopeText(data)}.`,
+      `Held posts: ${data.held_count ?? 0}`,
+      failed.length > 0 ? `Posts that could not be marked as held (the publish guard still holds them): ${idList(failed)}` : '',
+      data.message || '',
+    ].filter(Boolean).join('\n');
+  }
+
+  const missed = data.missed_post_ids || [];
+  const failed = data.failed_post_ids || [];
+  return [
+    `Publishing resumed for ${scopeText(data)}.`,
+    `Scheduled again: ${data.resumed_count ?? 0}`,
+    `Missed their time while paused (still paused): ${missed.length}${missed.length > 0 ? ` [post IDs: ${idList(missed)}]` : ''}`,
+    `Still held by another pause: ${data.still_held_count ?? 0}`,
+    (data.disconnected_count ?? 0) > 0 ? `Still paused because the account is disconnected: ${data.disconnected_count}` : '',
+    failed.length > 0 ? `Could not be released (try resume again): ${idList(failed)}` : '',
+    missed.length > 0
+      ? 'Next step: missed posts never publish on their own. Ask the user whether to publish them now (action=publish_missed with these post_ids and confirm=true) or reschedule them.'
+      : '',
+  ].filter(Boolean).join('\n');
+}
+
+export function formatPublishMissed(data: PublishMissedResponse): string {
+  return [
+    `Missed posts: ${data.started} publishing now, ${data.skipped} skipped.`,
+    data.message || '',
+  ].filter(Boolean).join('\n');
+}
+
+export const listPublishingPausesTool = {
+  name: 'list_publishing_pauses',
+  description:
+    'Is publishing paused? Shows whether the workspace is paused, which brands are paused (only brands you can see), and whether you may pause, resume, or publish missed posts. Read-only. Change it with manage_publishing_pause.',
+  inputSchema: z.object({
+    workspace_id: z.string().optional().describe('Workspace ID from whoami. Defaults to your default workspace.'),
+  }),
+
+  async execute(client: PosterlyClient, input: { workspace_id?: string }) {
+    const state = await client.getPublishingPause(input.workspace_id ? { workspace_id: input.workspace_id } : undefined);
+    return formatPublishingPauseState(state);
+  },
+};

package/src/tools/manage-publishing-pause.ts

@@ -0,0 +1,62 @@
+import { z } from 'zod';
+import type { PosterlyClient } from '../lib/api-client.js';
+import { validateArgs, type ToolContext } from '../lib/tool-runtime.js';
+import { formatPublishingPauseChange, formatPublishMissed } from './list-publishing-pauses.js';
+
+/** Same wording as EMPTY_BRAND_ID_MESSAGE in lib/publish/publishing-pause-service.ts. */
+const EMPTY_BRAND_ID_MESSAGE = 'brand_id is empty; omit it to target the whole workspace.';
+
+type ManagePublishingPauseInput = {
+  action: 'pause' | 'resume' | 'publish_missed';
+  workspace_id?: string;
+  brand_id?: string;
+  post_ids?: number[];
+  confirm?: boolean;
+};
+
+export const managePublishingPauseTool = {
+  name: 'manage_publishing_pause',
+  description:
+    'Pause or resume publishing for a whole workspace or one brand (check it first with list_publishing_pauses). Only act when the user asks; never pause on your own initiative. action=pause (optional brand_id; leave it out for the whole workspace): holds every scheduled post in that scope and blocks Post now until an admin resumes. Call it first without confirm to get a preview (scope and how many scheduled posts it holds), show it to the user, and only after they agree call again with confirm=true. Publisher or higher; a seat limited to some brands can only pause those brands. action=resume (optional brand_id; admin or higher): future posts are scheduled again; posts whose time passed while paused stay paused and are listed as missed. Missed posts never publish on their own. action=publish_missed (post_ids from the resume, confirm=true after the user agrees; admin or higher): publishes those missed posts now.',
+  inputSchema: z.object({
+    action: z.enum(['pause', 'resume', 'publish_missed']).describe('pause, resume, or publish_missed.'),
+    workspace_id: z.string().optional().describe('Workspace ID from whoami. Defaults to your default workspace.'),
+    brand_id: z.string().optional().describe('pause and resume: a brand ID from list_brands. Leave it out (never empty) for the whole workspace.'),
+    post_ids: z.array(z.number().int().positive()).max(500).optional().describe('publish_missed: the missed post IDs a resume returned.'),
+    confirm: z.boolean().optional().describe('pause: leave out to get a preview; true only after the user agreed. publish_missed: true after the user agreed. resume: not needed.'),
+  }),
+
+  async execute(client: PosterlyClient, input: ManagePublishingPauseInput, ctx: ToolContext) {
+    // A present but empty brand_id is refused, never read as the whole
+    // workspace (same rule and wording as the API and the hosted endpoint).
+    if ((input?.action === 'pause' || input?.action === 'resume') && input && Object.prototype.hasOwnProperty.call(input, 'brand_id')) {
+      const value = (input as { brand_id?: unknown }).brand_id;
+      if (value === null || (typeof value === 'string' && value.trim() === '')) throw new Error(EMPTY_BRAND_ID_MESSAGE);
+    }
+    const { mode, args } = validateArgs(ctx, 'manage_publishing_pause', input);
+    const call = args as ManagePublishingPauseInput;
+    const workspace = call.workspace_id ? { workspace_id: call.workspace_id } : {};
+
+    if (mode === 'publish_missed') {
+      if (call.confirm !== true) {
+        throw new Error('Refusing to publish missed posts without confirm=true after explicit user confirmation.');
+      }
+      const result = await client.publishMissedPausedPosts({ ...workspace, post_ids: call.post_ids || [], confirm: true });
+      return formatPublishMissed(result);
+    }
+
+    const brand = call.brand_id ? { brand_id: call.brand_id } : {};
+    if (mode === 'pause') {
+      const result = await client.changePublishingPause({
+        action: 'pause',
+        ...workspace,
+        ...brand,
+        ...(call.confirm === true ? { confirm: true } : {}),
+      });
+      return formatPublishingPauseChange(result);
+    }
+
+    const result = await client.changePublishingPause({ action: 'resume', ...workspace, ...brand });
+    return formatPublishingPauseChange(result);
+  },
+};

package/tool-annotations.json

@@ -8,6 +8,8 @@
     "delete_api_key",
     "list_workspace_members",
     "manage_workspace_member",
+    "list_publishing_pauses",
+    "manage_publishing_pause",
     "list_accounts",
     "disconnect_account",
     "connect_account",
@@ -68,6 +70,7 @@
     "get_signup_session",
     "whoami",
     "list_workspace_members",
+    "list_publishing_pauses",
     "list_accounts",
     "list_oauth_clients",
     "list_platforms",
@@ -108,6 +111,7 @@
     "manage_comment",
     "manage_webhook",
     "cancel_subscription",
+    "manage_publishing_pause",
     "pause_subscription",
     "downgrade_subscription"
   ],
@@ -128,6 +132,7 @@
     "get_signup_session",
     "whoami",
     "manage_workspace_member",
+    "manage_publishing_pause",
     "list_accounts",
     "disconnect_account",
     "connect_account",