posterly-mcp-server 0.44.0 → 0.45.0

package/src/index.ts

@@ -1,1494 +1,278 @@
 #!/usr/bin/env node
 
+import { createRequire } from 'node:module';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { PosterlyClient } from './lib/api-client.js';
+import type { z } from 'zod';
+import { PosterlyClient, setMcpClientNameResolver } from './lib/api-client.js';
 import { POSTERLY_MCP_VERSION } from './lib/version.js';
 import { getToolAnnotations } from './lib/tool-annotations.js';
+import { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js';
+import { AliasTransport, type LegacyAliasValidator } from './lib/alias-transport.js';
+import { StdioPreviewTokens } from './lib/preview-token.js';
+import { parseToolsets, toolsetInstructions, visibleTools, type ToolRegistry } from './lib/tool-registry.js';
+import type { ToolContext } from './lib/tool-runtime.js';
 import { getAgentSignupInfoTool } from './tools/get-agent-signup-info.js';
 import { getSignupSessionTool } from './tools/get-signup-session.js';
 import { startSignupTool } from './tools/start-signup.js';
-import { getMcpStatusTool } from './tools/get-mcp-status.js';
+import { whoamiTool } from './tools/whoami.js';
 import { listAccountsTool } from './tools/list-accounts.js';
 import { disconnectAccountTool } from './tools/disconnect-account.js';
+import { connectAccountTool } from './tools/connect-account.js';
+import { createConnectSessionTool } from './tools/create-connect-session.js';
+import { createApiKeyTool } from './tools/create-api-key.js';
+import { deleteApiKeyTool } from './tools/delete-api-key.js';
+import { listWorkspaceMembersTool } from './tools/list-workspace-members.js';
+import { manageWorkspaceMemberTool } from './tools/manage-workspace-member.js';
+import { getCreditsTool } from './tools/get-credits.js';
+import { getSubscriptionTool } from './tools/get-subscription.js';
+import { cancelSubscriptionTool } from './tools/cancel-subscription.js';
+import { pauseSubscriptionTool } from './tools/pause-subscription.js';
+import { resumeSubscriptionTool } from './tools/resume-subscription.js';
+import { downgradeSubscriptionTool } from './tools/downgrade-subscription.js';
+import { listOAuthClientsTool } from './tools/list-oauth-clients.js';
+import { manageOAuthClientTool } from './tools/manage-oauth-client.js';
+import { listPlatformsTool } from './tools/list-platforms.js';
+import { triggerPlatformHelperTool } from './tools/trigger-platform-helper.js';
 import { listBrandsTool } from './tools/list-brands.js';
-import { getBrandTool } from './tools/get-brand.js';
-import { listBrandAccountsTool } from './tools/list-brand-accounts.js';
-import { getBrandProfileTool } from './tools/get-brand-profile.js';
-import { getLearnedVoiceTool } from './tools/get-learned-voice.js';
-import { getPerformanceProfileTool } from './tools/get-performance-profile.js';
-import { getPostInsightsTool } from './tools/get-post-insights.js';
 import { listPostSuggestionsTool } from './tools/list-post-suggestions.js';
 import { dismissSuggestionTool } from './tools/dismiss-suggestion.js';
-import { createPostTool } from './tools/create-post.js';
-import { validatePostTool } from './tools/validate-post.js';
 import { submitAgentFeedbackTool } from './tools/submit-agent-feedback.js';
 import { submitProductFeedbackTool } from './tools/submit-product-feedback.js';
+import { validatePostTool } from './tools/validate-post.js';
+import { createPostTool } from './tools/create-post.js';
 import { createPostsBatchTool } from './tools/create-posts-batch.js';
 import { findSlotTool } from './tools/find-slot.js';
 import { listPostsTool } from './tools/list-posts.js';
 import { uploadMediaTool } from './tools/upload-media.js';
+import { createSignedUploadTool } from './tools/create-signed-upload.js';
+import { createMediaDropTool } from './tools/create-media-drop.js';
+import { listMediaTool } from './tools/list-media.js';
+import { getVideoOptionsTool } from './tools/get-video-options.js';
+import { runVideoFunctionTool } from './tools/run-video-function.js';
+import { generateVideoTool } from './tools/generate-video.js';
+import { listJobsTool } from './tools/list-jobs.js';
+import { generateCaptionsTool } from './tools/generate-captions.js';
+import { generateImageTool } from './tools/generate-image.js';
 import { getPostTool } from './tools/get-post.js';
-import { getPostMissingTool } from './tools/get-post-missing.js';
 import { askSupportTool } from './tools/ask-support.js';
 import { updatePostTool } from './tools/update-post.js';
-import { updatePostStatusTool } from './tools/update-post-status.js';
-import { updatePostReleaseIdTool } from './tools/update-post-release-id.js';
 import { deletePostTool } from './tools/delete-post.js';
-import { deletePostGroupTool } from './tools/delete-post-group.js';
-import { whoamiTool } from './tools/whoami.js';
-import { generateCaptionsTool } from './tools/generate-captions.js';
-import { generateImageTool } from './tools/generate-image.js';
-import { getImageJobTool } from './tools/get-image-job.js';
-import { getVideoOptionsTool } from './tools/get-video-options.js';
-import { runVideoFunctionTool } from './tools/run-video-function.js';
-import { generateVideoTool } from './tools/generate-video.js';
-import { getVideoJobTool } from './tools/get-video-job.js';
-import { getAccountAnalyticsTool } from './tools/get-account-analytics.js';
-import { getPostAnalyticsTool } from './tools/get-post-analytics.js';
+import { listAnalyticsTool } from './tools/list-analytics.js';
 import { listGoogleBusinessReviewsTool } from './tools/list-google-business-reviews.js';
-import { getGoogleBusinessReviewLinkTool } from './tools/get-google-business-review-link.js';
 import { auditGoogleBusinessProfileTool } from './tools/audit-google-business-profile.js';
-import { suggestGoogleBusinessReviewReplyTool } from './tools/suggest-google-business-review-reply.js';
-import { replyGoogleBusinessReviewTool } from './tools/reply-google-business-review.js';
-import { deleteGoogleBusinessReviewReplyTool } from './tools/delete-google-business-review-reply.js';
+import { manageGoogleBusinessReviewTool } from './tools/manage-google-business-review.js';
 import { listGoogleBusinessMediaTool } from './tools/list-google-business-media.js';
-import { addGoogleBusinessMediaTool } from './tools/add-google-business-media.js';
-import { deleteGoogleBusinessMediaTool } from './tools/delete-google-business-media.js';
+import { manageGoogleBusinessMediaTool } from './tools/manage-google-business-media.js';
 import { listConversationsTool } from './tools/list-conversations.js';
-import { getConversationTool } from './tools/get-conversation.js';
-import { sendMessageTool } from './tools/send-message.js';
+import { manageConversationTool } from './tools/manage-conversation.js';
 import { listCommentsTool } from './tools/list-comments.js';
-import { getCommentTool } from './tools/get-comment.js';
-import { replyToCommentTool } from './tools/reply-to-comment.js';
-import { updateCommentTool } from './tools/update-comment.js';
-import { deleteCommentTool } from './tools/delete-comment.js';
-import { syncInboxTool } from './tools/sync-inbox.js';
+import { manageCommentTool } from './tools/manage-comment.js';
 import { listActivityTool } from './tools/list-activity.js';
 import { getUpdatesTool } from './tools/get-updates.js';
 import { listWebhooksTool } from './tools/list-webhooks.js';
 import { createWebhookTool } from './tools/create-webhook.js';
-import { updateWebhookTool } from './tools/update-webhook.js';
-import { deleteWebhookTool } from './tools/delete-webhook.js';
-import { testWebhookTool } from './tools/test-webhook.js';
-import { listPlatformsTool } from './tools/list-platforms.js';
-import { getPlatformSchemaTool } from './tools/get-platform-schema.js';
-import { triggerPlatformHelperTool } from './tools/trigger-platform-helper.js';
+import { manageWebhookTool } from './tools/manage-webhook.js';
 import { getXPostingQuotaTool } from './tools/get-x-posting-quota.js';
-import { createSignedUploadTool } from './tools/create-signed-upload.js';
-import { createMediaDropTool } from './tools/create-media-drop.js';
-import { listMediaTool } from './tools/list-media.js';
-import { uploadMediaFromUrlTool } from './tools/upload-media-from-url.js';
-import { getConnectLinkTool } from './tools/get-connect-link.js';
-import { connectAccountTool } from './tools/connect-account.js';
-import { createConnectSessionTool } from './tools/create-connect-session.js';
-import { getConnectSessionTool } from './tools/get-connect-session.js';
-import { createApiKeyTool } from './tools/create-api-key.js';
-import { deleteApiKeyTool } from './tools/delete-api-key.js';
-import { listWorkspaceMembersTool } from './tools/list-workspace-members.js';
-import { manageWorkspaceMemberTool } from './tools/manage-workspace-member.js';
-import { getCreditsTool } from './tools/get-credits.js';
-import { getSubscriptionTool } from './tools/get-subscription.js';
-import { cancelSubscriptionTool } from './tools/cancel-subscription.js';
-import { pauseSubscriptionTool } from './tools/pause-subscription.js';
-import { resumeSubscriptionTool } from './tools/resume-subscription.js';
-import { downgradeSubscriptionTool } from './tools/downgrade-subscription.js';
-import { listOAuthClientsTool } from './tools/list-oauth-clients.js';
-import { createOAuthClientTool } from './tools/create-oauth-client.js';
-import { updateOAuthClientTool } from './tools/update-oauth-client.js';
-import { deleteOAuthClientTool } from './tools/delete-oauth-client.js';
-
-const server = new McpServer({
-  name: 'posterly',
-  version: POSTERLY_MCP_VERSION,
-});
-
-const client = new PosterlyClient();
-
-// Register tools
-server.tool(
-  getAgentSignupInfoTool.name,
-  getAgentSignupInfoTool.description,
-  getAgentSignupInfoTool.inputSchema.shape,
-  getToolAnnotations(getAgentSignupInfoTool.name),
-  async () => {
-    try {
-      const text = await getAgentSignupInfoTool.execute(client);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  startSignupTool.name,
-  startSignupTool.description,
-  startSignupTool.inputSchema.shape,
-  getToolAnnotations(startSignupTool.name),
-  async (input) => {
-    try {
-      const text = await startSignupTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  getSignupSessionTool.name,
-  getSignupSessionTool.description,
-  getSignupSessionTool.inputSchema.shape,
-  getToolAnnotations(getSignupSessionTool.name),
-  async (input) => {
-    try {
-      const text = await getSignupSessionTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  getMcpStatusTool.name,
-  getMcpStatusTool.description,
-  getMcpStatusTool.inputSchema.shape,
-  getToolAnnotations(getMcpStatusTool.name),
-  async () => {
-    try {
-      const text = await getMcpStatusTool.execute(client);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  whoamiTool.name,
-  whoamiTool.description,
-  whoamiTool.inputSchema.shape,
-  getToolAnnotations(whoamiTool.name),
-  async () => {
-    try {
-      const text = await whoamiTool.execute(client);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  listAccountsTool.name,
-  listAccountsTool.description,
-  listAccountsTool.inputSchema.shape,
-  getToolAnnotations(listAccountsTool.name),
-  async (input) => {
-    try {
-      const text = await listAccountsTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  disconnectAccountTool.name,
-  disconnectAccountTool.description,
-  disconnectAccountTool.inputSchema.shape,
-  getToolAnnotations(disconnectAccountTool.name),
-  async (input) => {
-    try {
-      const text = await disconnectAccountTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  getConnectLinkTool.name,
-  getConnectLinkTool.description,
-  getConnectLinkTool.inputSchema.shape,
-  getToolAnnotations(getConnectLinkTool.name),
-  async (input) => {
-    try {
-      const text = await getConnectLinkTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  connectAccountTool.name,
-  connectAccountTool.description,
-  connectAccountTool.inputSchema.shape,
-  getToolAnnotations(connectAccountTool.name),
-  async (input) => {
-    try {
-      const text = await connectAccountTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  createConnectSessionTool.name,
-  createConnectSessionTool.description,
-  createConnectSessionTool.inputSchema.shape,
-  getToolAnnotations(createConnectSessionTool.name),
-  async (input) => {
-    try {
-      const text = await createConnectSessionTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  getConnectSessionTool.name,
-  getConnectSessionTool.description,
-  getConnectSessionTool.inputSchema.shape,
-  getToolAnnotations(getConnectSessionTool.name),
-  async (input) => {
-    try {
-      const text = await getConnectSessionTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  createApiKeyTool.name,
-  createApiKeyTool.description,
-  createApiKeyTool.inputSchema.shape,
-  getToolAnnotations(createApiKeyTool.name),
-  async (input) => {
-    try {
-      const text = await createApiKeyTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  deleteApiKeyTool.name,
-  deleteApiKeyTool.description,
-  deleteApiKeyTool.inputSchema.shape,
-  getToolAnnotations(deleteApiKeyTool.name),
-  async (input) => {
-    try {
-      const text = await deleteApiKeyTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  listWorkspaceMembersTool.name,
-  listWorkspaceMembersTool.description,
-  listWorkspaceMembersTool.inputSchema.shape,
-  getToolAnnotations(listWorkspaceMembersTool.name),
-  async (input) => {
-    try {
-      const text = await listWorkspaceMembersTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  manageWorkspaceMemberTool.name,
-  manageWorkspaceMemberTool.description,
-  manageWorkspaceMemberTool.inputSchema.shape,
-  getToolAnnotations(manageWorkspaceMemberTool.name),
-  async (input) => {
-    try {
-      const text = await manageWorkspaceMemberTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  getCreditsTool.name,
-  getCreditsTool.description,
-  getCreditsTool.inputSchema.shape,
-  getToolAnnotations(getCreditsTool.name),
-  async () => {
-    try {
-      const text = await getCreditsTool.execute(client);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  getSubscriptionTool.name,
-  getSubscriptionTool.description,
-  getSubscriptionTool.inputSchema.shape,
-  getToolAnnotations(getSubscriptionTool.name),
-  async () => {
-    try {
-      const text = await getSubscriptionTool.execute(client);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  cancelSubscriptionTool.name,
-  cancelSubscriptionTool.description,
-  cancelSubscriptionTool.inputSchema.shape,
-  getToolAnnotations(cancelSubscriptionTool.name),
-  async (input) => {
-    try {
-      const text = await cancelSubscriptionTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  pauseSubscriptionTool.name,
-  pauseSubscriptionTool.description,
-  pauseSubscriptionTool.inputSchema.shape,
-  getToolAnnotations(pauseSubscriptionTool.name),
-  async (input) => {
-    try {
-      const text = await pauseSubscriptionTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  resumeSubscriptionTool.name,
-  resumeSubscriptionTool.description,
-  resumeSubscriptionTool.inputSchema.shape,
-  getToolAnnotations(resumeSubscriptionTool.name),
-  async () => {
-    try {
-      const text = await resumeSubscriptionTool.execute(client);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  downgradeSubscriptionTool.name,
-  downgradeSubscriptionTool.description,
-  downgradeSubscriptionTool.inputSchema.shape,
-  getToolAnnotations(downgradeSubscriptionTool.name),
-  async (input) => {
-    try {
-      const text = await downgradeSubscriptionTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  listOAuthClientsTool.name,
-  listOAuthClientsTool.description,
-  listOAuthClientsTool.inputSchema.shape,
-  getToolAnnotations(listOAuthClientsTool.name),
-  async () => {
-    try {
-      const text = await listOAuthClientsTool.execute(client);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  createOAuthClientTool.name,
-  createOAuthClientTool.description,
-  createOAuthClientTool.inputSchema.shape,
-  getToolAnnotations(createOAuthClientTool.name),
-  async (input) => {
-    try {
-      const text = await createOAuthClientTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  updateOAuthClientTool.name,
-  updateOAuthClientTool.description,
-  updateOAuthClientTool.inputSchema.shape,
-  getToolAnnotations(updateOAuthClientTool.name),
-  async (input) => {
-    try {
-      const text = await updateOAuthClientTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  deleteOAuthClientTool.name,
-  deleteOAuthClientTool.description,
-  deleteOAuthClientTool.inputSchema.shape,
-  getToolAnnotations(deleteOAuthClientTool.name),
-  async (input) => {
-    try {
-      const text = await deleteOAuthClientTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  listPlatformsTool.name,
-  listPlatformsTool.description,
-  listPlatformsTool.inputSchema.shape,
-  getToolAnnotations(listPlatformsTool.name),
-  async (input) => {
-    try {
-      const text = await listPlatformsTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  getPlatformSchemaTool.name,
-  getPlatformSchemaTool.description,
-  getPlatformSchemaTool.inputSchema.shape,
-  getToolAnnotations(getPlatformSchemaTool.name),
-  async (input) => {
-    try {
-      const text = await getPlatformSchemaTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  triggerPlatformHelperTool.name,
-  triggerPlatformHelperTool.description,
-  triggerPlatformHelperTool.inputSchema.shape,
-  getToolAnnotations(triggerPlatformHelperTool.name),
-  async (input) => {
-    try {
-      const text = await triggerPlatformHelperTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  listBrandsTool.name,
-  listBrandsTool.description,
-  listBrandsTool.inputSchema.shape,
-  getToolAnnotations(listBrandsTool.name),
-  async (input) => {
-    try {
-      const text = await listBrandsTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  getBrandTool.name,
-  getBrandTool.description,
-  getBrandTool.inputSchema.shape,
-  getToolAnnotations(getBrandTool.name),
-  async (input) => {
-    try {
-      const text = await getBrandTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  listBrandAccountsTool.name,
-  listBrandAccountsTool.description,
-  listBrandAccountsTool.inputSchema.shape,
-  getToolAnnotations(listBrandAccountsTool.name),
-  async (input) => {
-    try {
-      const text = await listBrandAccountsTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  getBrandProfileTool.name,
-  getBrandProfileTool.description,
-  getBrandProfileTool.inputSchema.shape,
-  getToolAnnotations(getBrandProfileTool.name),
-  async (input) => {
-    try {
-      const text = await getBrandProfileTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  getLearnedVoiceTool.name,
-  getLearnedVoiceTool.description,
-  getLearnedVoiceTool.inputSchema.shape,
-  getToolAnnotations(getLearnedVoiceTool.name),
-  async (input) => {
-    try {
-      const text = await getLearnedVoiceTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  getPerformanceProfileTool.name,
-  getPerformanceProfileTool.description,
-  getPerformanceProfileTool.inputSchema.shape,
-  getToolAnnotations(getPerformanceProfileTool.name),
-  async (input) => {
-    try {
-      const text = await getPerformanceProfileTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  getPostInsightsTool.name,
-  getPostInsightsTool.description,
-  getPostInsightsTool.inputSchema.shape,
-  getToolAnnotations(getPostInsightsTool.name),
-  async (input) => {
-    try {
-      const text = await getPostInsightsTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  listPostSuggestionsTool.name,
-  listPostSuggestionsTool.description,
-  listPostSuggestionsTool.inputSchema.shape,
-  getToolAnnotations(listPostSuggestionsTool.name),
-  async (input) => {
-    try {
-      const text = await listPostSuggestionsTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
 
-server.tool(
-  dismissSuggestionTool.name,
-  dismissSuggestionTool.description,
-  dismissSuggestionTool.inputSchema.shape,
-  getToolAnnotations(dismissSuggestionTool.name),
-  async (input) => {
-    try {
-      const text = await dismissSuggestionTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  submitAgentFeedbackTool.name,
-  submitAgentFeedbackTool.description,
-  submitAgentFeedbackTool.inputSchema.shape,
-  getToolAnnotations(submitAgentFeedbackTool.name),
-  async (input) => {
-    try {
-      const text = await submitAgentFeedbackTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  submitProductFeedbackTool.name,
-  submitProductFeedbackTool.description,
-  submitProductFeedbackTool.inputSchema.shape,
-  getToolAnnotations(submitProductFeedbackTool.name),
-  async (input) => {
-    try {
-      const text = await submitProductFeedbackTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  validatePostTool.name,
-  validatePostTool.description,
-  validatePostTool.inputSchema.shape,
-  getToolAnnotations(validatePostTool.name),
-  async (input) => {
-    try {
-      const text = await validatePostTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  createPostTool.name,
-  createPostTool.description,
-  createPostTool.inputSchema.shape,
-  getToolAnnotations(createPostTool.name),
-  async (input) => {
-    try {
-      const text = await createPostTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  createPostsBatchTool.name,
-  createPostsBatchTool.description,
-  createPostsBatchTool.inputSchema.shape,
-  getToolAnnotations(createPostsBatchTool.name),
-  async (input) => {
-    try {
-      const text = await createPostsBatchTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  findSlotTool.name,
-  findSlotTool.description,
-  findSlotTool.inputSchema.shape,
-  getToolAnnotations(findSlotTool.name),
-  async (input) => {
-    try {
-      const text = await findSlotTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  listPostsTool.name,
-  listPostsTool.description,
-  listPostsTool.inputSchema.shape,
-  getToolAnnotations(listPostsTool.name),
-  async (input) => {
-    try {
-      const text = await listPostsTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  uploadMediaTool.name,
-  uploadMediaTool.description,
-  uploadMediaTool.inputSchema.shape,
-  getToolAnnotations(uploadMediaTool.name),
-  async (input) => {
-    try {
-      const text = await uploadMediaTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  uploadMediaFromUrlTool.name,
-  uploadMediaFromUrlTool.description,
-  uploadMediaFromUrlTool.inputSchema.shape,
-  getToolAnnotations(uploadMediaFromUrlTool.name),
-  async (input) => {
-    try {
-      const text = await uploadMediaFromUrlTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  createSignedUploadTool.name,
-  createSignedUploadTool.description,
-  createSignedUploadTool.inputSchema.shape,
-  getToolAnnotations(createSignedUploadTool.name),
-  async (input) => {
-    try {
-      const text = await createSignedUploadTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  createMediaDropTool.name,
-  createMediaDropTool.description,
-  createMediaDropTool.inputSchema.shape,
-  getToolAnnotations(createMediaDropTool.name),
-  async (input) => {
-    try {
-      const text = await createMediaDropTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  listMediaTool.name,
-  listMediaTool.description,
-  listMediaTool.inputSchema.shape,
-  getToolAnnotations(listMediaTool.name),
-  async (input) => {
-    try {
-      const text = await listMediaTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  getVideoOptionsTool.name,
-  getVideoOptionsTool.description,
-  getVideoOptionsTool.inputSchema.shape,
-  getToolAnnotations(getVideoOptionsTool.name),
-  async () => {
-    try {
-      const text = await getVideoOptionsTool.execute(client);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  runVideoFunctionTool.name,
-  runVideoFunctionTool.description,
-  runVideoFunctionTool.inputSchema.shape,
-  getToolAnnotations(runVideoFunctionTool.name),
-  async (input) => {
-    try {
-      const text = await runVideoFunctionTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  generateVideoTool.name,
-  generateVideoTool.description,
-  generateVideoTool.inputSchema.shape,
-  getToolAnnotations(generateVideoTool.name),
-  async (input) => {
-    try {
-      const text = await generateVideoTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  getVideoJobTool.name,
-  getVideoJobTool.description,
-  getVideoJobTool.inputSchema.shape,
-  getToolAnnotations(getVideoJobTool.name),
-  async (input) => {
-    try {
-      const text = await getVideoJobTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  generateCaptionsTool.name,
-  generateCaptionsTool.description,
-  generateCaptionsTool.inputSchema.shape,
-  getToolAnnotations(generateCaptionsTool.name),
-  async (input) => {
-    try {
-      const text = await generateCaptionsTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  generateImageTool.name,
-  generateImageTool.description,
-  generateImageTool.inputSchema.shape,
-  getToolAnnotations(generateImageTool.name),
-  async (input) => {
-    try {
-      const text = await generateImageTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  getImageJobTool.name,
-  getImageJobTool.description,
-  getImageJobTool.inputSchema.shape,
-  getToolAnnotations(getImageJobTool.name),
-  async (input) => {
-    try {
-      const text = await getImageJobTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  getPostTool.name,
-  getPostTool.description,
-  getPostTool.inputSchema.shape,
-  getToolAnnotations(getPostTool.name),
-  async (input) => {
-    try {
-      const text = await getPostTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  getPostMissingTool.name,
-  getPostMissingTool.description,
-  getPostMissingTool.inputSchema.shape,
-  getToolAnnotations(getPostMissingTool.name),
-  async (input) => {
-    try {
-      const text = await getPostMissingTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  askSupportTool.name,
-  askSupportTool.description,
-  askSupportTool.inputSchema.shape,
-  getToolAnnotations(askSupportTool.name),
-  async (input) => {
-    try {
-      const text = await askSupportTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  updatePostTool.name,
-  updatePostTool.description,
-  updatePostTool.inputSchema.shape,
-  getToolAnnotations(updatePostTool.name),
-  async (input) => {
-    try {
-      const text = await updatePostTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  updatePostStatusTool.name,
-  updatePostStatusTool.description,
-  updatePostStatusTool.inputSchema.shape,
-  getToolAnnotations(updatePostStatusTool.name),
-  async (input) => {
-    try {
-      const text = await updatePostStatusTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  updatePostReleaseIdTool.name,
-  updatePostReleaseIdTool.description,
-  updatePostReleaseIdTool.inputSchema.shape,
-  getToolAnnotations(updatePostReleaseIdTool.name),
-  async (input) => {
-    try {
-      const text = await updatePostReleaseIdTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  deletePostTool.name,
-  deletePostTool.description,
-  deletePostTool.inputSchema.shape,
-  getToolAnnotations(deletePostTool.name),
-  async (input) => {
-    try {
-      const text = await deletePostTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  deletePostGroupTool.name,
-  deletePostGroupTool.description,
-  deletePostGroupTool.inputSchema.shape,
-  getToolAnnotations(deletePostGroupTool.name),
-  async (input) => {
-    try {
-      const text = await deletePostGroupTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  getAccountAnalyticsTool.name,
-  getAccountAnalyticsTool.description,
-  getAccountAnalyticsTool.inputSchema.shape,
-  getToolAnnotations(getAccountAnalyticsTool.name),
-  async (input) => {
-    try {
-      const text = await getAccountAnalyticsTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  getPostAnalyticsTool.name,
-  getPostAnalyticsTool.description,
-  getPostAnalyticsTool.inputSchema.shape,
-  getToolAnnotations(getPostAnalyticsTool.name),
-  async (input) => {
-    try {
-      const text = await getPostAnalyticsTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  listGoogleBusinessReviewsTool.name,
-  listGoogleBusinessReviewsTool.description,
-  listGoogleBusinessReviewsTool.inputSchema.shape,
-  getToolAnnotations(listGoogleBusinessReviewsTool.name),
-  async (input) => {
-    try {
-      const text = await listGoogleBusinessReviewsTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  getGoogleBusinessReviewLinkTool.name,
-  getGoogleBusinessReviewLinkTool.description,
-  getGoogleBusinessReviewLinkTool.inputSchema.shape,
-  getToolAnnotations(getGoogleBusinessReviewLinkTool.name),
-  async (input) => {
-    try {
-      const text = await getGoogleBusinessReviewLinkTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  auditGoogleBusinessProfileTool.name,
-  auditGoogleBusinessProfileTool.description,
-  auditGoogleBusinessProfileTool.inputSchema.shape,
-  getToolAnnotations(auditGoogleBusinessProfileTool.name),
-  async (input) => {
-    try {
-      const text = await auditGoogleBusinessProfileTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  suggestGoogleBusinessReviewReplyTool.name,
-  suggestGoogleBusinessReviewReplyTool.description,
-  suggestGoogleBusinessReviewReplyTool.inputSchema.shape,
-  getToolAnnotations(suggestGoogleBusinessReviewReplyTool.name),
-  async (input) => {
-    try {
-      const text = await suggestGoogleBusinessReviewReplyTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  replyGoogleBusinessReviewTool.name,
-  replyGoogleBusinessReviewTool.description,
-  replyGoogleBusinessReviewTool.inputSchema.shape,
-  getToolAnnotations(replyGoogleBusinessReviewTool.name),
-  async (input) => {
-    try {
-      const text = await replyGoogleBusinessReviewTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  deleteGoogleBusinessReviewReplyTool.name,
-  deleteGoogleBusinessReviewReplyTool.description,
-  deleteGoogleBusinessReviewReplyTool.inputSchema.shape,
-  getToolAnnotations(deleteGoogleBusinessReviewReplyTool.name),
-  async (input) => {
-    try {
-      const text = await deleteGoogleBusinessReviewReplyTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  listGoogleBusinessMediaTool.name,
-  listGoogleBusinessMediaTool.description,
-  listGoogleBusinessMediaTool.inputSchema.shape,
-  getToolAnnotations(listGoogleBusinessMediaTool.name),
-  async (input) => {
-    try {
-      const text = await listGoogleBusinessMediaTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  addGoogleBusinessMediaTool.name,
-  addGoogleBusinessMediaTool.description,
-  addGoogleBusinessMediaTool.inputSchema.shape,
-  getToolAnnotations(addGoogleBusinessMediaTool.name),
-  async (input) => {
-    try {
-      const text = await addGoogleBusinessMediaTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  deleteGoogleBusinessMediaTool.name,
-  deleteGoogleBusinessMediaTool.description,
-  deleteGoogleBusinessMediaTool.inputSchema.shape,
-  getToolAnnotations(deleteGoogleBusinessMediaTool.name),
-  async (input) => {
-    try {
-      const text = await deleteGoogleBusinessMediaTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  listConversationsTool.name,
-  listConversationsTool.description,
-  listConversationsTool.inputSchema.shape,
-  getToolAnnotations(listConversationsTool.name),
-  async (input) => {
-    try {
-      const text = await listConversationsTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  getConversationTool.name,
-  getConversationTool.description,
-  getConversationTool.inputSchema.shape,
-  getToolAnnotations(getConversationTool.name),
-  async (input) => {
-    try {
-      const text = await getConversationTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  sendMessageTool.name,
-  sendMessageTool.description,
-  sendMessageTool.inputSchema.shape,
-  getToolAnnotations(sendMessageTool.name),
-  async (input) => {
-    try {
-      const text = await sendMessageTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  listCommentsTool.name,
-  listCommentsTool.description,
-  listCommentsTool.inputSchema.shape,
-  getToolAnnotations(listCommentsTool.name),
-  async (input) => {
-    try {
-      const text = await listCommentsTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  getCommentTool.name,
-  getCommentTool.description,
-  getCommentTool.inputSchema.shape,
-  getToolAnnotations(getCommentTool.name),
-  async (input) => {
-    try {
-      const text = await getCommentTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  replyToCommentTool.name,
-  replyToCommentTool.description,
-  replyToCommentTool.inputSchema.shape,
-  getToolAnnotations(replyToCommentTool.name),
-  async (input) => {
-    try {
-      const text = await replyToCommentTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  updateCommentTool.name,
-  updateCommentTool.description,
-  updateCommentTool.inputSchema.shape,
-  getToolAnnotations(updateCommentTool.name),
-  async (input) => {
-    try {
-      const text = await updateCommentTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  deleteCommentTool.name,
-  deleteCommentTool.description,
-  deleteCommentTool.inputSchema.shape,
-  getToolAnnotations(deleteCommentTool.name),
-  async (input) => {
-    try {
-      const text = await deleteCommentTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
-
-server.tool(
-  syncInboxTool.name,
-  syncInboxTool.description,
-  syncInboxTool.inputSchema.shape,
-  getToolAnnotations(syncInboxTool.name),
-  async (input) => {
-    try {
-      const text = await syncInboxTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
+/**
+ * One tool module per file in ./tools. `execute` takes the shared client,
+ * the validated input, and the per-call context (tools that do not need the
+ * input or context simply ignore them). Merged tools also carry the exact
+ * input schemas of the old tools they replaced (`legacySchemas`), so alias
+ * calls are validated exactly as before until the alias sunset date.
+ */
+interface ToolModule {
+  name: string;
+  description: string;
+  inputSchema: z.ZodObject<z.ZodRawShape>;
+  legacySchemas?: Record<string, z.ZodTypeAny>;
+  execute(client: PosterlyClient, input: any, ctx: ToolContext): Promise<string>;
+}
 
-server.tool(
-  listActivityTool.name,
-  listActivityTool.description,
-  listActivityTool.inputSchema.shape,
-  getToolAnnotations(listActivityTool.name),
-  async (input) => {
-    try {
-      const text = await listActivityTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
+/**
+ * Every stdio tool, in registration order. The order is what tools/list
+ * returns, so keep new tools appended where they belong rather than
+ * re-sorting: reordering changes the published tool list.
+ */
+const STDIO_TOOLS: ToolModule[] = [
+  getAgentSignupInfoTool,
+  startSignupTool,
+  getSignupSessionTool,
+  whoamiTool,
+  listAccountsTool,
+  disconnectAccountTool,
+  connectAccountTool,
+  createConnectSessionTool,
+  createApiKeyTool,
+  deleteApiKeyTool,
+  listWorkspaceMembersTool,
+  manageWorkspaceMemberTool,
+  getCreditsTool,
+  getSubscriptionTool,
+  cancelSubscriptionTool,
+  pauseSubscriptionTool,
+  resumeSubscriptionTool,
+  downgradeSubscriptionTool,
+  listOAuthClientsTool,
+  manageOAuthClientTool,
+  listPlatformsTool,
+  triggerPlatformHelperTool,
+  listBrandsTool,
+  listPostSuggestionsTool,
+  dismissSuggestionTool,
+  submitAgentFeedbackTool,
+  submitProductFeedbackTool,
+  validatePostTool,
+  createPostTool,
+  createPostsBatchTool,
+  findSlotTool,
+  listPostsTool,
+  uploadMediaTool,
+  createSignedUploadTool,
+  createMediaDropTool,
+  listMediaTool,
+  getVideoOptionsTool,
+  runVideoFunctionTool,
+  generateVideoTool,
+  listJobsTool,
+  generateCaptionsTool,
+  generateImageTool,
+  getPostTool,
+  askSupportTool,
+  updatePostTool,
+  deletePostTool,
+  listAnalyticsTool,
+  listGoogleBusinessReviewsTool,
+  auditGoogleBusinessProfileTool,
+  manageGoogleBusinessReviewTool,
+  listGoogleBusinessMediaTool,
+  manageGoogleBusinessMediaTool,
+  listConversationsTool,
+  manageConversationTool,
+  listCommentsTool,
+  manageCommentTool,
+  listActivityTool,
+  getUpdatesTool,
+  listWebhooksTool,
+  createWebhookTool,
+  manageWebhookTool,
+  getXPostingQuotaTool,
+];
+
+// The tool registry (sets, labels, aliases) ships at the package root next to
+// tool-annotations.json; dist/index.js reads it from one level up.
+const require = createRequire(import.meta.url);
+const registry = require('../tool-registry.json') as ToolRegistry;
+
+/**
+ * Tool sets to list (POSTERLY_TOOLSETS env or --toolsets=core,inbox). Default
+ * is every set, so nobody loses tools. Signup tools are always listed. Sets
+ * only filter tools/list: every tool is still registered and callable.
+ */
+function requestedToolsets(): string | undefined {
+  const flag = process.argv.find((arg) => arg.startsWith('--toolsets='));
+  if (flag) return flag.slice('--toolsets='.length);
+  return process.env.POSTERLY_TOOLSETS;
+}
 
-server.tool(
-  getUpdatesTool.name,
-  getUpdatesTool.description,
-  getUpdatesTool.inputSchema.shape,
-  getToolAnnotations(getUpdatesTool.name),
-  async (input) => {
-    try {
-      const text = await getUpdatesTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
+const toolsets = parseToolsets(registry, requestedToolsets(), 'stdio');
+if (toolsets.unknown.length > 0) {
+  console.error(`posterly MCP: ignoring unknown tool set(s): ${toolsets.unknown.join(', ')}`);
+}
 
-server.tool(
-  listWebhooksTool.name,
-  listWebhooksTool.description,
-  listWebhooksTool.inputSchema.shape,
-  getToolAnnotations(listWebhooksTool.name),
-  async (input) => {
-    try {
-      const text = await listWebhooksTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
+const server = new McpServer(
+  {
+    name: 'posterly',
+    version: POSTERLY_MCP_VERSION,
+  },
+  {
+    // Which tool sets exist, that every set is on by default, how to load
+    // fewer, and how preview then confirm works (built from the registry).
+    instructions: toolsetInstructions(registry, 'stdio'),
+  },
 );
 
-server.tool(
-  createWebhookTool.name,
-  createWebhookTool.description,
-  createWebhookTool.inputSchema.shape,
-  getToolAnnotations(createWebhookTool.name),
-  async (input) => {
-    try {
-      const text = await createWebhookTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
+const client = new PosterlyClient();
 
-server.tool(
-  updateWebhookTool.name,
-  updateWebhookTool.description,
-  updateWebhookTool.inputSchema.shape,
-  getToolAnnotations(updateWebhookTool.name),
-  async (input) => {
-    try {
-      const text = await updateWebhookTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
+// The SDK only learns the connected client's identity (e.g. "claude-ai",
+// "chatgpt") once the initialize handshake completes, so this is a resolver
+// read fresh on every request rather than a value captured once here.
+setMcpClientNameResolver(() => server.server.getClientVersion()?.name);
 
-server.tool(
-  deleteWebhookTool.name,
-  deleteWebhookTool.description,
-  deleteWebhookTool.inputSchema.shape,
-  getToolAnnotations(deleteWebhookTool.name),
-  async (input) => {
-    try {
-      const text = await deleteWebhookTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
+// Old tools' exact input schemas, keyed by alias name, from the merged tool
+// modules that replaced them.
+const LEGACY_SCHEMAS = new Map<string, z.ZodTypeAny>();
+for (const tool of STDIO_TOOLS) {
+  for (const [alias, schema] of Object.entries(tool.legacySchemas ?? {})) LEGACY_SCHEMAS.set(alias, schema);
+}
 
-server.tool(
-  testWebhookTool.name,
-  testWebhookTool.description,
-  testWebhookTool.inputSchema.shape,
-  getToolAnnotations(testWebhookTool.name),
-  async (input) => {
-    try {
-      const text = await testWebhookTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
+/**
+ * Validates an alias call against the old tool's own schema, so a call the
+ * old tool rejected gets the same SDK error text it always got (same wording
+ * the SDK builds for any tool), and a valid call keeps the old defaults.
+ */
+const legacyValidator: LegacyAliasValidator = (aliasName, args) => {
+  const schema = LEGACY_SCHEMAS.get(aliasName);
+  if (!schema) return null;
+  const parsed = schema.safeParse(args ?? {});
+  if (parsed.success) return { ok: true, args: parsed.data as Record<string, unknown> };
+  const message = new McpError(
+    ErrorCode.InvalidParams,
+    `Input validation error: Invalid arguments for tool ${aliasName}: ${parsed.error.message}`,
+  ).message;
+  return { ok: false, message };
+};
+
+// Renamed tools (aliases) are never registered with McpServer: the transport
+// rewrites an alias call onto its target before the SDK sees it, and handlers
+// read the called name back through getCallInfo(extra.requestId).
+const transport = new AliasTransport(
+  new StdioServerTransport(),
+  registry,
+  toolsets.all ? null : visibleTools(registry, toolsets.enabled, 'stdio'),
+  legacyValidator,
+);
+
+// Preview then confirm tokens: a random key and an in-memory one-time-use
+// set per process (UX protection only; REST authorization is unchanged).
+const previews = new StdioPreviewTokens();
+
+function registerAll(tools: ToolModule[]): void {
+  for (const tool of tools) {
+    server.tool(
+      tool.name,
+      tool.description,
+      tool.inputSchema.shape,
+      getToolAnnotations(tool.name),
+      async (input, extra) => {
+        // The CALLED name (an alias, or the tool itself) is what telemetry
+        // records as X-Posterly-Tool. The per-call context lives only here:
+        // never in the arguments, never on shared state.
+        const callInfo = transport.getCallInfo(extra.requestId);
+        const calledName = callInfo?.calledName ?? tool.name;
+        const ctx: ToolContext = {
+          calledName,
+          legacyConfirm: callInfo?.legacyConfirm === true,
+          registry,
+          previews,
+          toolsets: { enabled: toolsets.enabled, all: toolsets.all },
+        };
+        try {
+          const text = await client.runToolCall(calledName, () => tool.execute(client, input, ctx));
+          return { content: [{ type: 'text' as const, text }] };
+        } catch (err: any) {
+          return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
+        }
+      },
+    );
   }
-);
+}
 
-server.tool(
-  getXPostingQuotaTool.name,
-  getXPostingQuotaTool.description,
-  getXPostingQuotaTool.inputSchema.shape,
-  getToolAnnotations(getXPostingQuotaTool.name),
-  async (input) => {
-    try {
-      const text = await getXPostingQuotaTool.execute(client, input as any);
-      return { content: [{ type: 'text' as const, text }] };
-    } catch (err: any) {
-      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
-    }
-  }
-);
+registerAll(STDIO_TOOLS);
 
 // Start the server
 async function main() {
-  const transport = new StdioServerTransport();
   await server.connect(transport);
 }