posterly-mcp-server 0.44.0 → 0.45.0

package/dist/index.js

@@ -1,938 +1,234 @@
 #!/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 { 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 } from './lib/alias-transport.js';
+import { StdioPreviewTokens } from './lib/preview-token.js';
+import { parseToolsets, toolsetInstructions, visibleTools } from './lib/tool-registry.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';
+/**
+ * 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 = [
+    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');
+/**
+ * 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() {
+    const flag = process.argv.find((arg) => arg.startsWith('--toolsets='));
+    if (flag)
+        return flag.slice('--toolsets='.length);
+    return process.env.POSTERLY_TOOLSETS;
+}
+const toolsets = parseToolsets(registry, requestedToolsets(), 'stdio');
+if (toolsets.unknown.length > 0) {
+    console.error(`posterly MCP: ignoring unknown tool set(s): ${toolsets.unknown.join(', ')}`);
+}
 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'),
 });
 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', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
-    }
-});
-server.tool(listActivityTool.name, listActivityTool.description, listActivityTool.inputSchema.shape, getToolAnnotations(listActivityTool.name), async (input) => {
-    try {
-        const text = await listActivityTool.execute(client, input);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
-    }
-});
-server.tool(getUpdatesTool.name, getUpdatesTool.description, getUpdatesTool.inputSchema.shape, getToolAnnotations(getUpdatesTool.name), async (input) => {
-    try {
-        const text = await getUpdatesTool.execute(client, input);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
-    }
-});
-server.tool(listWebhooksTool.name, listWebhooksTool.description, listWebhooksTool.inputSchema.shape, getToolAnnotations(listWebhooksTool.name), async (input) => {
-    try {
-        const text = await listWebhooksTool.execute(client, input);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
-    }
-});
-server.tool(createWebhookTool.name, createWebhookTool.description, createWebhookTool.inputSchema.shape, getToolAnnotations(createWebhookTool.name), async (input) => {
-    try {
-        const text = await createWebhookTool.execute(client, input);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
-    }
-});
-server.tool(updateWebhookTool.name, updateWebhookTool.description, updateWebhookTool.inputSchema.shape, getToolAnnotations(updateWebhookTool.name), async (input) => {
-    try {
-        const text = await updateWebhookTool.execute(client, input);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
-    }
-});
-server.tool(deleteWebhookTool.name, deleteWebhookTool.description, deleteWebhookTool.inputSchema.shape, getToolAnnotations(deleteWebhookTool.name), async (input) => {
-    try {
-        const text = await deleteWebhookTool.execute(client, input);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
-    }
-});
-server.tool(testWebhookTool.name, testWebhookTool.description, testWebhookTool.inputSchema.shape, getToolAnnotations(testWebhookTool.name), async (input) => {
-    try {
-        const text = await testWebhookTool.execute(client, input);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
-        return { content: [{ type: 'text', text }] };
-    }
-    catch (err) {
-        return { content: [{ type: 'text', 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);
+// Old tools' exact input schemas, keyed by alias name, from the merged tool
+// modules that replaced them.
+const LEGACY_SCHEMAS = new Map();
+for (const tool of STDIO_TOOLS) {
+    for (const [alias, schema] of Object.entries(tool.legacySchemas ?? {}))
+        LEGACY_SCHEMAS.set(alias, schema);
+}
+/**
+ * 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 = (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 };
+    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) {
+    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 = {
+                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', text }] };
+            }
+            catch (err) {
+                return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+            }
+        });
     }
-});
+}
+registerAll(STDIO_TOOLS);
 // Start the server
 async function main() {
-    const transport = new StdioServerTransport();
     await server.connect(transport);
 }
 main().catch((err) => {