posterly-mcp-server 0.8.2 → 0.19.0

package/dist/tools/get-video-job.js

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+export const getVideoJobTool = {
+    name: 'get_video_job',
+    description: 'Get one Veo video generation job by ID, or list recent video jobs when job_id is omitted. Use after generate_video to poll for completed video_url.',
+    inputSchema: z.object({
+        job_id: z.string().optional(),
+        status: z.enum(['pending', 'processing', 'completed', 'failed', 'dismissed']).optional(),
+        limit: z.number().int().min(1).max(50).default(10).optional(),
+    }),
+    async execute(client, input) {
+        const result = await client.getVideoJob(input);
+        if (result.job)
+            return formatJob(result.job, true);
+        const jobs = result.jobs || [];
+        return [
+            `Video jobs (${jobs.length})`,
+            jobs.map((job) => formatJob(job, false)).join('\n\n'),
+        ].filter(Boolean).join('\n');
+    },
+};
+function formatJob(job, includeRaw) {
+    const lines = [
+        `${job.id} — ${job.status}`,
+        `Prompt: ${job.prompt}`,
+        `Model: ${job.model}; duration: ${job.duration_seconds}s; resolution: ${job.resolution || 'n/a'}; cost: ${job.credit_cost}`,
+        job.video_url ? `Video URL: ${job.video_url}` : null,
+        job.error_message ? `Error: ${job.error_message}` : null,
+        includeRaw ? `\nRaw job:\n${JSON.stringify(job, null, 2)}` : null,
+    ];
+    return lines.filter(Boolean).join('\n');
+}

package/dist/tools/get-video-options.d.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import type { PosterlyClient } from '../lib/api-client.js';
+export declare const getVideoOptionsTool: {
+    name: string;
+    description: string;
+    inputSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    execute(client: PosterlyClient): Promise<string>;
+};

package/dist/tools/get-video-options.js

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+export const getVideoOptionsTool = {
+    name: 'get_video_options',
+    description: 'List read-only Veo video generation options, input modes, durations, resolutions, aspect ratios, and credit-cost estimates. This does not generate video or spend credits.',
+    inputSchema: z.object({}),
+    async execute(client) {
+        const options = await client.getVideoOptions();
+        const models = Array.isArray(options.models) ? options.models : [];
+        const inputModes = Array.isArray(options.input_modes) ? options.input_modes : [];
+        const lines = [
+            'Video generation options',
+            `Provider: ${options.provider || 'unknown'}`,
+            `Public generation status: ${options.public_generation_status || 'unknown'}`,
+            '',
+            `Models: ${models.map((model) => model.id).filter(Boolean).join(', ') || 'none'}`,
+            `Durations: ${(options.durations_seconds || []).join(', ')} seconds`,
+            `Resolutions: ${(options.resolutions || []).join(', ')}`,
+            `Aspect ratios: ${(options.aspect_ratios || []).join(', ')}`,
+            `Input modes: ${inputModes.map((mode) => mode.id).filter(Boolean).join(', ') || 'none'}`,
+            '',
+            'Raw options:',
+            JSON.stringify(options, null, 2),
+        ];
+        return lines.join('\n');
+    },
+};

package/dist/tools/get-x-posting-quota.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import type { PosterlyClient } from '../lib/api-client.js';
+export declare const getXPostingQuotaTool: {
+    name: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        workspace_id: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        workspace_id?: string | undefined;
+    }, {
+        workspace_id?: string | undefined;
+    }>;
+    execute(client: PosterlyClient, input: {
+        workspace_id?: string;
+    }): Promise<string>;
+};

package/dist/tools/get-x-posting-quota.js

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+export const getXPostingQuotaTool = {
+    name: 'get_x_posting_quota',
+    description: 'Get managed X posting quota for a workspace, including total monthly allowance, used posts, remaining posts, and URL-blocking status.',
+    inputSchema: z.object({
+        workspace_id: z.string().optional().describe('Workspace ID from whoami. Defaults to the caller personal workspace context.'),
+    }),
+    async execute(client, input) {
+        const quota = await client.getXPostingQuota(input);
+        return [
+            'X posting quota',
+            `• Workspace: ${quota.workspace_id || 'default'}`,
+            `• Tier: ${quota.tier || 'unknown'}`,
+            `• Total posts: ${quota.total_posts}`,
+            `• Used posts: ${quota.used_posts}`,
+            `• Remaining posts: ${quota.remaining_posts}`,
+            `• URL posting blocked: ${quota.urls_blocked ? 'yes' : 'no'}`,
+            `• Period: ${quota.current_period_start} -> ${quota.current_period_end}`,
+        ].join('\n');
+    },
+};

package/dist/tools/list-activity.d.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import type { PosterlyClient } from '../lib/api-client.js';
+export declare const listActivityTool: {
+    name: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        workspace_id: z.ZodOptional<z.ZodString>;
+        post_id: z.ZodOptional<z.ZodNumber>;
+        since: z.ZodOptional<z.ZodString>;
+        type: z.ZodOptional<z.ZodEnum<["all", "activity", "publish"]>>;
+        limit: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        workspace_id?: string | undefined;
+        limit?: number | undefined;
+        post_id?: number | undefined;
+        since?: string | undefined;
+        type?: "activity" | "publish" | "all" | undefined;
+    }, {
+        workspace_id?: string | undefined;
+        limit?: number | undefined;
+        post_id?: number | undefined;
+        since?: string | undefined;
+        type?: "activity" | "publish" | "all" | undefined;
+    }>;
+    execute(client: PosterlyClient, input: {
+        workspace_id?: string;
+        post_id?: number;
+        since?: string;
+        type?: "all" | "activity" | "publish";
+        limit?: number;
+    }): Promise<string>;
+};

package/dist/tools/list-activity.js

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+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.',
+    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.'),
+    }),
+    async execute(client, input) {
+        const result = await client.listActivity(input);
+        if (result.items.length === 0) {
+            return 'No activity found matching your filters.';
+        }
+        const lines = [
+            `Activity (${result.items.length} of ${result.total}):`,
+        ];
+        for (const item of result.items) {
+            const when = item.created_at ? new Date(item.created_at).toLocaleString() : 'unknown time';
+            if (item.type === 'publish') {
+                const outcome = item.outcome || 'publish';
+                const platform = item.platform ? ` on ${item.platform}` : '';
+                const detail = item.error_message ? ` - ${item.error_message}` : '';
+                lines.push(`- [${when}] post #${item.post_id || '?'} ${outcome}${platform}${detail}`);
+            }
+            else {
+                const label = item.description || item.action || 'activity';
+                lines.push(`- [${when}] post #${item.post_id || '?'} ${label}`);
+            }
+        }
+        return lines.join('\n');
+    },
+};

package/dist/tools/list-google-business-reviews.d.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import type { PosterlyClient } from '../lib/api-client.js';
+export declare const listGoogleBusinessReviewsTool: {
+    name: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        workspace_id: z.ZodOptional<z.ZodString>;
+        account_id: z.ZodOptional<z.ZodNumber>;
+        location_id: z.ZodOptional<z.ZodString>;
+        rating: z.ZodOptional<z.ZodNumber>;
+        unanswered: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        workspace_id?: string | undefined;
+        account_id?: number | undefined;
+        location_id?: string | undefined;
+        rating?: number | undefined;
+        unanswered?: boolean | undefined;
+    }, {
+        workspace_id?: string | undefined;
+        account_id?: number | undefined;
+        location_id?: string | undefined;
+        rating?: number | undefined;
+        unanswered?: boolean | undefined;
+    }>;
+    execute(client: PosterlyClient, input: {
+        workspace_id?: string;
+        account_id?: number;
+        location_id?: string;
+        rating?: number;
+        unanswered?: boolean;
+    }): Promise<string>;
+};

package/dist/tools/list-google-business-reviews.js

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+export const listGoogleBusinessReviewsTool = {
+    name: 'list_google_business_reviews',
+    description: 'List Google Business Profile reviews for one location/account or every accessible GBP location. Supports rating and unanswered-only filters.',
+    inputSchema: z.object({
+        workspace_id: z.string().optional().describe('Filter to a workspace ID from whoami.'),
+        account_id: z.number().int().positive().optional().describe('Google Business account ID from list_accounts.'),
+        location_id: z.string().optional().describe('Google Business location/platform_user_id.'),
+        rating: z.number().int().min(1).max(5).optional().describe('Filter to a 1-5 star rating.'),
+        unanswered: z.boolean().optional().describe('Only return reviews without owner replies.'),
+    }),
+    async execute(client, input) {
+        const result = await client.listGoogleBusinessReviews(input);
+        if (result.reviews.length === 0) {
+            return 'No Google Business reviews found matching your filters.';
+        }
+        const lines = [`Google Business reviews (${result.reviews.length} of ${result.total}):`];
+        for (const review of result.reviews.slice(0, 25)) {
+            const name = review.reviewer?.displayName || 'Anonymous';
+            const rating = review.starRating ? `${review.starRating} stars` : 'unrated';
+            const location = review.businessName || review.locationName || review.locationId || 'location';
+            const text = review.comment ? ` - ${review.comment.replace(/\s+/g, ' ').slice(0, 180)}` : '';
+            const replied = review.reviewReply ? ' replied' : ' unanswered';
+            lines.push(`- ${name} (${rating}, ${location},${replied})${text}`);
+        }
+        return lines.join('\n');
+    },
+};

package/dist/tools/list-oauth-clients.d.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import type { PosterlyClient } from '../lib/api-client.js';
+export declare const listOAuthClientsTool: {
+    name: string;
+    description: string;
+    inputSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    execute(client: PosterlyClient): Promise<string>;
+};

package/dist/tools/list-oauth-clients.js

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+export const listOAuthClientsTool = {
+    name: 'list_oauth_clients',
+    description: 'List self-serve OAuth developer clients owned by the user. These are public PKCE clients for third-party app integrations.',
+    inputSchema: z.object({}),
+    async execute(client) {
+        const result = await client.listOAuthClients();
+        if (result.clients.length === 0)
+            return 'No OAuth developer clients found.';
+        return [
+            `OAuth developer clients (${result.clients.length}):`,
+            ...result.clients.map((item) => `- ${item.client_name} (${item.client_id}) scopes=${item.default_scopes.join(', ')} active=${item.is_active}`),
+        ].join('\n');
+    },
+};

package/dist/tools/list-platforms.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import type { PosterlyClient } from '../lib/api-client.js';
+export declare const listPlatformsTool: {
+    name: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        include_planned: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        include_planned?: boolean | undefined;
+    }, {
+        include_planned?: boolean | undefined;
+    }>;
+    execute(client: PosterlyClient, input: {
+        include_planned?: boolean;
+    }): Promise<string>;
+};

package/dist/tools/list-platforms.js

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { PLANNED_PLATFORM_IDS } from '../generated/platform-manifest.js';
+export const listPlatformsTool = {
+    name: 'list_platforms',
+    description: 'List posterly platform integrations, posting capabilities, content/media limits, settings schemas, helper tools, and analytics support. Use include_planned to show future integration possibilities from the Postiz parity audit.',
+    inputSchema: z.object({
+        include_planned: z
+            .boolean()
+            .optional()
+            .describe(`Include planned integrations such as ${PLANNED_PLATFORM_IDS.join(', ')}.`),
+    }),
+    async execute(client, input) {
+        const result = await client.listPlatforms(input);
+        const lines = result.platforms.map((platform) => {
+            const helperCount = platform.helper_tools?.length || 0;
+            return `• ${platform.label} (${platform.id}) — ${platform.status}; post types: ${platform.post_types.join(', ') || 'n/a'}; helpers: ${helperCount}; analytics: ${platform.analytics_supported ? 'yes' : 'no'}`;
+        });
+        return `Posterly platforms (${result.platforms.length}):\n${lines.join('\n')}`;
+    },
+};

package/dist/tools/list-posts.d.ts

@@ -5,20 +5,20 @@ export declare const listPostsTool: {
     description: string;
     inputSchema: z.ZodObject<{
         status: z.ZodOptional<z.ZodString>;
-        platform: z.ZodOptional<z.ZodString>;
+        platform: z.ZodOptional<z.ZodEnum<["bluesky", "facebook", "gmb", "google-business", "google_business", "google_business_profile", "instagram", "instagram-standalone", "linkedin", "pinterest", "telegram", "threads", "tiktok", "twitter", "x", "youtube"]>>;
         account_id: z.ZodOptional<z.ZodString>;
         limit: z.ZodOptional<z.ZodNumber>;
         workspace_id: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         workspace_id?: string | undefined;
+        platform?: "instagram" | "instagram-standalone" | "facebook" | "tiktok" | "twitter" | "linkedin" | "youtube" | "pinterest" | "threads" | "google_business" | "telegram" | "bluesky" | "gmb" | "google-business" | "google_business_profile" | "x" | undefined;
         status?: string | undefined;
-        platform?: string | undefined;
         account_id?: string | undefined;
         limit?: number | undefined;
     }, {
         workspace_id?: string | undefined;
+        platform?: "instagram" | "instagram-standalone" | "facebook" | "tiktok" | "twitter" | "linkedin" | "youtube" | "pinterest" | "threads" | "google_business" | "telegram" | "bluesky" | "gmb" | "google-business" | "google_business_profile" | "x" | undefined;
         status?: string | undefined;
-        platform?: string | undefined;
         account_id?: string | undefined;
         limit?: number | undefined;
     }>;

package/dist/tools/list-posts.js

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { SUPPORTED_PLATFORM_INPUTS, SUPPORTED_PLATFORM_IDS } from '../generated/platform-manifest.js';
 export const listPostsTool = {
     name: 'list_posts',
     description: 'List upcoming or recent posts. Filter by status (scheduled, published, failed, draft), platform, account_id, or workspace_id. If workspace_id is omitted, posts across every workspace the caller is a member of are returned.',
@@ -8,9 +9,9 @@ export const listPostsTool = {
             .optional()
             .describe('Filter by status: draft, scheduled, published, failed'),
         platform: z
-            .string()
+            .enum(SUPPORTED_PLATFORM_INPUTS)
             .optional()
-            .describe('Filter by platform: instagram, twitter, linkedin, etc.'),
+            .describe(`Filter by platform: ${SUPPORTED_PLATFORM_IDS.join(', ')}.`),
         account_id: z
             .string()
             .optional()

package/dist/tools/list-webhooks.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import type { PosterlyClient } from '../lib/api-client.js';
+export declare const listWebhooksTool: {
+    name: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        workspace_id: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        workspace_id?: string | undefined;
+    }, {
+        workspace_id?: string | undefined;
+    }>;
+    execute(client: PosterlyClient, input: {
+        workspace_id?: string;
+    }): Promise<string>;
+};

package/dist/tools/list-webhooks.js

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+export const listWebhooksTool = {
+    name: 'list_webhooks',
+    description: 'List API webhook subscriptions, their event filters, active state, and most recent delivery status.',
+    inputSchema: z.object({
+        workspace_id: z.string().optional().describe('Filter to a workspace ID from whoami.'),
+    }),
+    async execute(client, input) {
+        const { webhooks } = await client.listWebhooks(input);
+        if (webhooks.length === 0) {
+            return 'No webhooks found.';
+        }
+        const lines = [`Webhooks (${webhooks.length}):`];
+        for (const webhook of webhooks) {
+            const active = webhook.is_active ? 'active' : 'inactive';
+            const events = webhook.events?.length ? webhook.events.join(', ') : 'default events';
+            const last = webhook.last_delivery_at
+                ? ` last ${webhook.last_delivery_status || 'n/a'} at ${new Date(webhook.last_delivery_at).toLocaleString()}`
+                : '';
+            lines.push(`- ${webhook.id} [${active}] ${webhook.url} (${events})${last}`);
+        }
+        return lines.join('\n');
+    },
+};

package/dist/tools/reply-google-business-review.d.ts

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+import type { PosterlyClient } from '../lib/api-client.js';
+export declare const replyGoogleBusinessReviewTool: {
+    name: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        workspace_id: z.ZodOptional<z.ZodString>;
+        account_id: z.ZodOptional<z.ZodNumber>;
+        location_id: z.ZodOptional<z.ZodString>;
+        review_name: z.ZodString;
+        comment: z.ZodString;
+        confirm: z.ZodLiteral<true>;
+    }, "strip", z.ZodTypeAny, {
+        confirm: true;
+        review_name: string;
+        comment: string;
+        workspace_id?: string | undefined;
+        account_id?: number | undefined;
+        location_id?: string | undefined;
+    }, {
+        confirm: true;
+        review_name: string;
+        comment: string;
+        workspace_id?: string | undefined;
+        account_id?: number | undefined;
+        location_id?: string | undefined;
+    }>;
+    execute(client: PosterlyClient, input: {
+        workspace_id?: string;
+        account_id?: number;
+        location_id?: string;
+        review_name: string;
+        comment: string;
+        confirm: true;
+    }): Promise<any>;
+};

package/dist/tools/reply-google-business-review.js

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+export const replyGoogleBusinessReviewTool = {
+    name: 'reply_google_business_review',
+    description: 'Post or update the owner reply on a Google Business Profile review. WRITE: show the review, location, and exact reply text to the user, then pass confirm=true only after explicit confirmation.',
+    inputSchema: z.object({
+        workspace_id: z.string().optional().describe('Filter to a workspace ID from whoami.'),
+        account_id: z.number().int().positive().optional().describe('Google Business account ID from list_accounts.'),
+        location_id: z.string().optional().describe('Google Business location/platform_user_id.'),
+        review_name: z.string().min(1).describe('Full Google review resource name.'),
+        comment: z.string().min(1).max(4096).describe('Exact owner reply text to post.'),
+        confirm: z.literal(true).describe('Must be true after explicit user confirmation.'),
+    }),
+    async execute(client, input) {
+        const { confirm: _confirm, ...payload } = input;
+        const result = await client.replyGoogleBusinessReview(payload);
+        return result.message || 'Google Business review reply posted successfully.';
+    },
+};

package/dist/tools/run-video-function.d.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import type { PosterlyClient } from '../lib/api-client.js';
+export declare const runVideoFunctionTool: {
+    name: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        identifier: z.ZodEnum<["google_veo", "veo3"]>;
+        functionName: z.ZodEnum<["list_input_modes", "estimate_cost", "validate_request"]>;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        identifier: "google_veo" | "veo3";
+        functionName: "list_input_modes" | "estimate_cost" | "validate_request";
+        params?: Record<string, unknown> | undefined;
+    }, {
+        identifier: "google_veo" | "veo3";
+        functionName: "list_input_modes" | "estimate_cost" | "validate_request";
+        params?: Record<string, unknown> | undefined;
+    }>;
+    execute(client: PosterlyClient, input: {
+        identifier: string;
+        functionName: string;
+        params?: Record<string, unknown>;
+    }): Promise<string>;
+};

package/dist/tools/run-video-function.js

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+export const runVideoFunctionTool = {
+    name: 'run_video_function',
+    description: 'Run a read-only Veo helper function before generation: list_input_modes, estimate_cost, or validate_request. This does not generate video or spend credits.',
+    inputSchema: z.object({
+        identifier: z
+            .enum(['google_veo', 'veo3'])
+            .describe('Video generator identifier from get_video_options.'),
+        functionName: z
+            .enum(['list_input_modes', 'estimate_cost', 'validate_request'])
+            .describe('Helper function name from get_video_options.tools.'),
+        params: z
+            .record(z.unknown())
+            .optional()
+            .describe('Function parameters. estimate_cost accepts model, duration_seconds, resolution, and output. validate_request accepts a generate_video-style payload.'),
+    }),
+    async execute(client, input) {
+        const result = await client.runVideoFunction(input);
+        return [
+            `Video function ${input.functionName} completed`,
+            '',
+            JSON.stringify(result, null, 2),
+        ].join('\n');
+    },
+};

package/dist/tools/suggest-google-business-review-reply.d.ts

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+import type { PosterlyClient } from '../lib/api-client.js';
+export declare const suggestGoogleBusinessReviewReplyTool: {
+    name: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        workspace_id: z.ZodOptional<z.ZodString>;
+        account_id: z.ZodOptional<z.ZodNumber>;
+        location_id: z.ZodOptional<z.ZodString>;
+        review_text: z.ZodOptional<z.ZodString>;
+        star_rating: z.ZodNumber;
+        reviewer_name: z.ZodOptional<z.ZodString>;
+        business_name: z.ZodOptional<z.ZodString>;
+        tone: z.ZodOptional<z.ZodEnum<["professional", "friendly", "apologetic"]>>;
+        count: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        star_rating: number;
+        workspace_id?: string | undefined;
+        account_id?: number | undefined;
+        count?: number | undefined;
+        location_id?: string | undefined;
+        review_text?: string | undefined;
+        reviewer_name?: string | undefined;
+        business_name?: string | undefined;
+        tone?: "professional" | "friendly" | "apologetic" | undefined;
+    }, {
+        star_rating: number;
+        workspace_id?: string | undefined;
+        account_id?: number | undefined;
+        count?: number | undefined;
+        location_id?: string | undefined;
+        review_text?: string | undefined;
+        reviewer_name?: string | undefined;
+        business_name?: string | undefined;
+        tone?: "professional" | "friendly" | "apologetic" | undefined;
+    }>;
+    execute(client: PosterlyClient, input: {
+        workspace_id?: string;
+        account_id?: number;
+        location_id?: string;
+        review_text?: string;
+        star_rating: number;
+        reviewer_name?: string;
+        business_name?: string;
+        tone?: "professional" | "friendly" | "apologetic";
+        count?: number;
+    }): Promise<string>;
+};

package/dist/tools/suggest-google-business-review-reply.js

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+export const suggestGoogleBusinessReviewReplyTool = {
+    name: 'suggest_google_business_review_reply',
+    description: 'Generate short, brand-aware AI reply suggestions for a Google review. Uses the AI Caption Assist allowance; does not post the reply.',
+    inputSchema: z.object({
+        workspace_id: z.string().optional().describe('Filter to a workspace ID from whoami.'),
+        account_id: z.number().int().positive().optional().describe('Optional Google Business account ID for brand voice context.'),
+        location_id: z.string().optional().describe('Google Business location/platform_user_id.'),
+        review_text: z.string().optional().describe('Review text. Leave empty for rating-only reviews.'),
+        star_rating: z.number().min(1).max(5).describe('Review rating from 1 to 5.'),
+        reviewer_name: z.string().optional(),
+        business_name: z.string().optional(),
+        tone: z.enum(['professional', 'friendly', 'apologetic']).optional(),
+        count: z.number().int().min(1).max(5).optional(),
+    }),
+    async execute(client, input) {
+        const result = await client.suggestGoogleBusinessReviewReply(input);
+        const suggestions = Array.isArray(result.suggestions) ? result.suggestions : [];
+        if (suggestions.length === 0) {
+            return 'No reply suggestions were generated.';
+        }
+        return [
+            `Suggested replies (${result.tone || 'professional'}, ${result.rating || input.star_rating} stars):`,
+            ...suggestions.map((text, index) => `${index + 1}. ${text}`),
+        ].join('\n');
+    },
+};

package/dist/tools/test-webhook.d.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import type { PosterlyClient } from '../lib/api-client.js';
+export declare const testWebhookTool: {
+    name: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        webhook_id: z.ZodString;
+        confirm: z.ZodLiteral<true>;
+    }, "strip", z.ZodTypeAny, {
+        confirm: true;
+        webhook_id: string;
+    }, {
+        confirm: true;
+        webhook_id: string;
+    }>;
+    execute(client: PosterlyClient, input: {
+        webhook_id: string;
+        confirm: true;
+    }): Promise<string>;
+};

package/dist/tools/test-webhook.js

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+export const testWebhookTool = {
+    name: 'test_webhook',
+    description: 'Send a signed webhook.test delivery to a webhook URL. OUTBOUND SIDE EFFECT: get explicit confirmation before sending a test request.',
+    inputSchema: z.object({
+        webhook_id: z.string().describe('Webhook ID from list_webhooks.'),
+        confirm: z.literal(true).describe('Must be true after the user explicitly confirms the test delivery.'),
+    }),
+    async execute(client, input) {
+        const result = await client.testWebhook(input.webhook_id);
+        const delivery = result.delivery || {};
+        return `Webhook test sent.\nDelivery: ${JSON.stringify(delivery, null, 2)}`;
+    },
+};

package/dist/tools/trigger-platform-helper.d.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import type { PosterlyClient } from '../lib/api-client.js';
+export declare const triggerPlatformHelperTool: {
+    name: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        helper: z.ZodEnum<["linkedin.recent_mentions", "pinterest.boards", "tiktok.creator_info", "x.quota", "youtube.playlists"]>;
+        account_id: z.ZodOptional<z.ZodString>;
+        platform: z.ZodOptional<z.ZodEnum<["bluesky", "facebook", "gmb", "google-business", "google_business", "google_business_profile", "instagram", "instagram-standalone", "linkedin", "pinterest", "telegram", "threads", "tiktok", "twitter", "x", "youtube"]>>;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        helper: "linkedin.recent_mentions" | "pinterest.boards" | "tiktok.creator_info" | "x.quota" | "youtube.playlists";
+        platform?: "instagram" | "instagram-standalone" | "facebook" | "tiktok" | "twitter" | "linkedin" | "youtube" | "pinterest" | "threads" | "google_business" | "telegram" | "bluesky" | "gmb" | "google-business" | "google_business_profile" | "x" | undefined;
+        account_id?: string | undefined;
+        params?: Record<string, unknown> | undefined;
+    }, {
+        helper: "linkedin.recent_mentions" | "pinterest.boards" | "tiktok.creator_info" | "x.quota" | "youtube.playlists";
+        platform?: "instagram" | "instagram-standalone" | "facebook" | "tiktok" | "twitter" | "linkedin" | "youtube" | "pinterest" | "threads" | "google_business" | "telegram" | "bluesky" | "gmb" | "google-business" | "google_business_profile" | "x" | undefined;
+        account_id?: string | undefined;
+        params?: Record<string, unknown> | undefined;
+    }>;
+    execute(client: PosterlyClient, input: {
+        helper: string;
+        account_id?: string;
+        platform?: string;
+        params?: Record<string, unknown>;
+    }): Promise<string>;
+};