@hasna/microservices 0.0.6 → 0.0.8

package/microservices/microservice-social/src/mcp/index.ts

@@ -35,6 +35,17 @@ import {
   getHashtagStats,
   PLATFORM_LIMITS,
 } from "../db/social.js";
+import {
+  startScheduler,
+  stopScheduler,
+  getSchedulerStatus,
+  runOnce as runSchedulerOnce,
+} from "../lib/scheduler.js";
+import {
+  validateMedia,
+  getSupportedFormats,
+  uploadMedia,
+} from "../lib/media.js";
 
 const PlatformEnum = z.enum(["x", "linkedin", "instagram", "threads", "bluesky"]);
 const PostStatusEnum = z.enum(["draft", "scheduled", "published", "failed", "pending_review"]);
@@ -268,18 +279,135 @@ server.registerTool(
   "publish_post",
   {
     title: "Publish Post",
-    description: "Mark a post as published.",
+    description: "Publish a post. Set live=true to send via platform API (X, Meta), otherwise marks as published locally.",
     inputSchema: {
       id: z.string(),
       platform_post_id: z.string().optional(),
+      live: z.boolean().optional().describe("If true, publish via the platform API instead of just marking locally"),
     },
   },
-  async ({ id, platform_post_id }) => {
-    const post = publishPost(id, platform_post_id);
-    if (!post) {
-      return { content: [{ type: "text", text: `Post '${id}' not found.` }], isError: true };
+  async ({ id, platform_post_id, live }) => {
+    try {
+      let post;
+      if (live) {
+        const { publishToApi } = await import("../lib/publisher.js");
+        post = await publishToApi(id);
+      } else {
+        post = publishPost(id, platform_post_id);
+      }
+      if (!post) {
+        return { content: [{ type: "text", text: `Post '${id}' not found.` }], isError: true };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(post, null, 2) }] };
+    } catch (error) {
+      return {
+        content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
+        isError: true,
+      };
+    }
+  }
+);
+
+// --- Threads ---
+
+server.registerTool(
+  "create_thread",
+  {
+    title: "Create Thread",
+    description: "Create a thread of multiple posts linked by thread_id, ordered sequentially.",
+    inputSchema: {
+      contents: z.array(z.string()).describe("Content for each post in the thread"),
+      account_id: z.string(),
+      scheduled_at: z.string().optional(),
+      tags: z.array(z.string()).optional(),
+    },
+  },
+  async ({ contents, account_id, scheduled_at, tags }) => {
+    try {
+      const { createThread } = await import("../lib/threads.js");
+      const result = createThread(contents, account_id, { scheduledAt: scheduled_at, tags });
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    } catch (error) {
+      return {
+        content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
+        isError: true,
+      };
+    }
+  }
+);
+
+server.registerTool(
+  "get_thread",
+  {
+    title: "Get Thread",
+    description: "Get all posts in a thread ordered by position.",
+    inputSchema: {
+      thread_id: z.string(),
+    },
+  },
+  async ({ thread_id }) => {
+    try {
+      const { getThread } = await import("../lib/threads.js");
+      const posts = getThread(thread_id);
+      return {
+        content: [
+          { type: "text", text: JSON.stringify({ thread_id, posts, count: posts.length }, null, 2) },
+        ],
+      };
+    } catch (error) {
+      return {
+        content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
+        isError: true,
+      };
+    }
+  }
+);
+
+server.registerTool(
+  "publish_thread",
+  {
+    title: "Publish Thread",
+    description: "Publish a thread sequentially via platform APIs. X chains tweets as replies; Meta posts first then comments.",
+    inputSchema: {
+      thread_id: z.string(),
+    },
+  },
+  async ({ thread_id }) => {
+    try {
+      const { publishThread } = await import("../lib/threads.js");
+      const result = await publishThread(thread_id);
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    } catch (error) {
+      return {
+        content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
+        isError: true,
+      };
+    }
+  }
+);
+
+server.registerTool(
+  "create_carousel",
+  {
+    title: "Create Carousel",
+    description: "Create a carousel post with multiple images (Instagram/LinkedIn format).",
+    inputSchema: {
+      images: z.array(z.string()).describe("Image URLs for the carousel"),
+      captions: z.array(z.string()).optional().describe("Captions for the images"),
+      account_id: z.string(),
+    },
+  },
+  async ({ images, captions, account_id }) => {
+    try {
+      const { createCarousel } = await import("../lib/threads.js");
+      const post = createCarousel(images, captions || [], account_id);
+      return { content: [{ type: "text", text: JSON.stringify(post, null, 2) }] };
+    } catch (error) {
+      return {
+        content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
+        isError: true,
+      };
     }
-    return { content: [{ type: "text", text: JSON.stringify(post, null, 2) }] };
   }
 );
 
@@ -642,6 +770,648 @@ server.registerTool(
   }
 );
 
+// --- Publisher Bridge ---
+
+server.registerTool(
+  "check_providers",
+  {
+    title: "Check Providers",
+    description: "Check which platform API providers have env vars configured (X, Meta).",
+    inputSchema: {},
+  },
+  async () => {
+    const { checkProviders } = await import("../lib/publisher.js");
+    const providers = checkProviders();
+    return { content: [{ type: "text", text: JSON.stringify(providers, null, 2) }] };
+  }
+);
+
+server.registerTool(
+  "sync_post_metrics",
+  {
+    title: "Sync Post Metrics",
+    description: "Fetch engagement metrics from the platform API and update the post in DB.",
+    inputSchema: { id: z.string() },
+  },
+  async ({ id }) => {
+    try {
+      const { syncPostMetrics } = await import("../lib/publisher.js");
+      const post = await syncPostMetrics(id);
+      return { content: [{ type: "text", text: JSON.stringify(post, null, 2) }] };
+    } catch (error) {
+      return {
+        content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
+        isError: true,
+      };
+    }
+  }
+);
+
+// --- Scheduler ---
+
+server.registerTool(
+  "start_scheduler",
+  {
+    title: "Start Scheduler",
+    description: "Start the auto-publish scheduler that checks for due posts at a regular interval.",
+    inputSchema: {
+      interval_ms: z.number().optional(),
+    },
+  },
+  async ({ interval_ms }) => {
+    try {
+      startScheduler(interval_ms || 60000);
+      const status = getSchedulerStatus();
+      return { content: [{ type: "text", text: JSON.stringify({ message: "Scheduler started", ...status }, null, 2) }] };
+    } catch (error) {
+      return {
+        content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
+        isError: true,
+      };
+    }
+  }
+);
+
+server.registerTool(
+  "stop_scheduler",
+  {
+    title: "Stop Scheduler",
+    description: "Stop the auto-publish scheduler.",
+    inputSchema: {},
+  },
+  async () => {
+    stopScheduler();
+    const status = getSchedulerStatus();
+    return { content: [{ type: "text", text: JSON.stringify({ message: "Scheduler stopped", ...status }, null, 2) }] };
+  }
+);
+
+server.registerTool(
+  "scheduler_status",
+  {
+    title: "Scheduler Status",
+    description: "Get the current status of the auto-publish scheduler.",
+    inputSchema: {},
+  },
+  async () => {
+    const status = getSchedulerStatus();
+    return { content: [{ type: "text", text: JSON.stringify(status, null, 2) }] };
+  }
+);
+
+// --- Media ---
+
+server.registerTool(
+  "upload_media",
+  {
+    title: "Upload Media",
+    description: "Upload a media file to a social media platform.",
+    inputSchema: {
+      file_path: z.string(),
+      platform: PlatformEnum,
+      page_id: z.string().optional(),
+    },
+  },
+  async ({ file_path, platform, page_id }) => {
+    try {
+      const validation = validateMedia(file_path, platform);
+      if (!validation.valid) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ valid: false, errors: validation.errors }, null, 2) }],
+          isError: true,
+        };
+      }
+
+      const result = await uploadMedia(file_path, platform, page_id);
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    } catch (error) {
+      return {
+        content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
+        isError: true,
+      };
+    }
+  }
+);
+
+server.registerTool(
+  "validate_media",
+  {
+    title: "Validate Media",
+    description: "Validate a media file for a specific platform without uploading.",
+    inputSchema: {
+      file_path: z.string(),
+      platform: PlatformEnum,
+    },
+  },
+  async ({ file_path, platform }) => {
+    const result = validateMedia(file_path, platform);
+    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+  }
+);
+
+server.registerTool(
+  "get_supported_formats",
+  {
+    title: "Get Supported Formats",
+    description: "Get supported media formats for a platform.",
+    inputSchema: {
+      platform: PlatformEnum,
+    },
+  },
+  async ({ platform }) => {
+    const formats = getSupportedFormats(platform);
+    return { content: [{ type: "text", text: JSON.stringify({ platform, formats }, null, 2) }] };
+  }
+);
+
+// --- Metrics Sync ---
+
+server.registerTool(
+  "sync_all_metrics",
+  {
+    title: "Sync All Metrics",
+    description: "Sync engagement metrics for all published posts from the last 7 days via platform APIs.",
+    inputSchema: {},
+  },
+  async () => {
+    try {
+      const { syncAllMetrics } = await import("../lib/metrics-sync.js");
+      const report = await syncAllMetrics();
+      return { content: [{ type: "text", text: JSON.stringify(report, null, 2) }] };
+    } catch (error) {
+      return {
+        content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
+        isError: true,
+      };
+    }
+  }
+);
+
+server.registerTool(
+  "sync_account_metrics",
+  {
+    title: "Sync Account Metrics",
+    description: "Pull follower count and profile data from platform API for a specific account.",
+    inputSchema: {
+      account_id: z.string(),
+    },
+  },
+  async ({ account_id }) => {
+    try {
+      const { syncAccountMetrics } = await import("../lib/metrics-sync.js");
+      const account = await syncAccountMetrics(account_id);
+      if (!account) {
+        return { content: [{ type: "text", text: `Account '${account_id}' not found.` }], isError: true };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(account, null, 2) }] };
+    } catch (error) {
+      return {
+        content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
+        isError: true,
+      };
+    }
+  }
+);
+
+server.registerTool(
+  "metrics_sync_status",
+  {
+    title: "Metrics Sync Status",
+    description: "Get the current status of the metrics sync worker, including sync report.",
+    inputSchema: {},
+  },
+  async () => {
+    const { getMetricsSyncStatus, getSyncReport } = await import("../lib/metrics-sync.js");
+    const status = getMetricsSyncStatus();
+    const report = getSyncReport();
+    return { content: [{ type: "text", text: JSON.stringify({ status, report }, null, 2) }] };
+  }
+);
+
+// --- Mentions ---
+
+const MentionTypeEnum = z.enum(["mention", "reply", "quote", "dm"]);
+
+server.registerTool(
+  "list_mentions",
+  {
+    title: "List Mentions",
+    description: "List mentions for an account with optional filters (unread, type, platform).",
+    inputSchema: {
+      account_id: z.string().optional(),
+      unread: z.boolean().optional(),
+      type: MentionTypeEnum.optional(),
+      platform: z.string().optional(),
+      limit: z.number().optional(),
+    },
+  },
+  async ({ account_id, ...filters }) => {
+    const { listMentions } = await import("../lib/mentions.js");
+    const mentions = listMentions(account_id, filters);
+    return {
+      content: [
+        { type: "text", text: JSON.stringify({ mentions, count: mentions.length }, null, 2) },
+      ],
+    };
+  }
+);
+
+server.registerTool(
+  "reply_to_mention",
+  {
+    title: "Reply to Mention",
+    description: "Reply to a mention via the platform API (X or Meta).",
+    inputSchema: {
+      mention_id: z.string(),
+      content: z.string(),
+    },
+  },
+  async ({ mention_id, content }) => {
+    try {
+      const { replyToMention } = await import("../lib/mentions.js");
+      const result = await replyToMention(mention_id, content);
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    } catch (error) {
+      return {
+        content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
+        isError: true,
+      };
+    }
+  }
+);
+
+server.registerTool(
+  "mark_mention_read",
+  {
+    title: "Mark Mention Read",
+    description: "Mark a single mention as read, or all mentions for an account.",
+    inputSchema: {
+      mention_id: z.string().optional(),
+      account_id: z.string().optional(),
+    },
+  },
+  async ({ mention_id, account_id }) => {
+    const { markRead, markAllRead } = await import("../lib/mentions.js");
+    if (account_id) {
+      const count = markAllRead(account_id);
+      return { content: [{ type: "text", text: JSON.stringify({ account_id, marked_read: count }, null, 2) }] };
+    }
+    if (mention_id) {
+      const mention = markRead(mention_id);
+      if (!mention) {
+        return { content: [{ type: "text", text: `Mention '${mention_id}' not found.` }], isError: true };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(mention, null, 2) }] };
+    }
+    return { content: [{ type: "text", text: "Provide either mention_id or account_id." }], isError: true };
+  }
+);
+
+server.registerTool(
+  "poll_mentions",
+  {
+    title: "Poll Mentions",
+    description: "Start or stop the background mention poller.",
+    inputSchema: {
+      action: z.enum(["start", "stop", "status"]),
+      interval_ms: z.number().optional(),
+    },
+  },
+  async ({ action, interval_ms }) => {
+    const { pollMentions, stopPolling, isPolling } = await import("../lib/mentions.js");
+    try {
+      if (action === "start") {
+        pollMentions(interval_ms || 120000);
+        return { content: [{ type: "text", text: JSON.stringify({ status: "started", interval_ms: interval_ms || 120000 }, null, 2) }] };
+      } else if (action === "stop") {
+        stopPolling();
+        return { content: [{ type: "text", text: JSON.stringify({ status: "stopped" }, null, 2) }] };
+      } else {
+        return { content: [{ type: "text", text: JSON.stringify({ running: isPolling() }, null, 2) }] };
+      }
+    } catch (error) {
+      return {
+        content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
+        isError: true,
+      };
+    }
+  }
+);
+
+server.registerTool(
+  "mention_stats",
+  {
+    title: "Mention Stats",
+    description: "Get mention statistics for an account (total, unread, by type, by sentiment).",
+    inputSchema: {
+      account_id: z.string(),
+    },
+  },
+  async ({ account_id }) => {
+    const { getMentionStats } = await import("../lib/mentions.js");
+    const stats = getMentionStats(account_id);
+    return { content: [{ type: "text", text: JSON.stringify(stats, null, 2) }] };
+  }
+);
+
+// --- AI Content Generation ---
+
+const ToneEnum = z.enum(["professional", "casual", "witty"]);
+
+server.registerTool(
+  "generate_post",
+  {
+    title: "Generate Post with AI",
+    description: "Generate a social media post using AI. Provide a topic and platform; get back content, hashtags, and a suggested media prompt.",
+    inputSchema: {
+      topic: z.string(),
+      platform: PlatformEnum,
+      tone: ToneEnum.optional(),
+      includeHashtags: z.boolean().optional(),
+      includeEmoji: z.boolean().optional(),
+      language: z.string().optional(),
+    },
+  },
+  async ({ topic, platform, ...options }) => {
+    try {
+      const { generatePost } = await import("../lib/content-ai.js");
+      const result = await generatePost(topic, platform, options);
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    } catch (error) {
+      return {
+        content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
+        isError: true,
+      };
+    }
+  }
+);
+
+server.registerTool(
+  "suggest_hashtags",
+  {
+    title: "Suggest Hashtags",
+    description: "Analyze post content and suggest relevant hashtags using AI.",
+    inputSchema: {
+      content: z.string(),
+      platform: PlatformEnum,
+      count: z.number().optional(),
+    },
+  },
+  async ({ content, platform, count }) => {
+    try {
+      const { suggestHashtags } = await import("../lib/content-ai.js");
+      const hashtags = await suggestHashtags(content, platform, count || 5);
+      return { content: [{ type: "text", text: JSON.stringify({ hashtags }, null, 2) }] };
+    } catch (error) {
+      return {
+        content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
+        isError: true,
+      };
+    }
+  }
+);
+
+server.registerTool(
+  "optimize_post",
+  {
+    title: "Optimize Post",
+    description: "Rewrite a post for better engagement using AI. Returns optimized content and a list of improvements.",
+    inputSchema: {
+      content: z.string(),
+      platform: PlatformEnum,
+    },
+  },
+  async ({ content, platform }) => {
+    try {
+      const { optimizePost } = await import("../lib/content-ai.js");
+      const result = await optimizePost(content, platform);
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    } catch (error) {
+      return {
+        content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
+        isError: true,
+      };
+    }
+  }
+);
+
+server.registerTool(
+  "generate_thread",
+  {
+    title: "Generate Thread",
+    description: "Generate a multi-tweet thread using AI. Each tweet stays within 280 chars.",
+    inputSchema: {
+      topic: z.string(),
+      tweet_count: z.number().optional(),
+    },
+  },
+  async ({ topic, tweet_count }) => {
+    try {
+      const { generateThread } = await import("../lib/content-ai.js");
+      const tweets = await generateThread(topic, tweet_count || 5);
+      return { content: [{ type: "text", text: JSON.stringify({ tweets, count: tweets.length }, null, 2) }] };
+    } catch (error) {
+      return {
+        content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
+        isError: true,
+      };
+    }
+  }
+);
+
+server.registerTool(
+  "repurpose_post",
+  {
+    title: "Repurpose Post",
+    description: "Adapt a post from one platform's style to another using AI (e.g., X to LinkedIn).",
+    inputSchema: {
+      content: z.string(),
+      source_platform: PlatformEnum,
+      target_platform: PlatformEnum,
+    },
+  },
+  async ({ content, source_platform, target_platform }) => {
+    try {
+      const { repurposePost } = await import("../lib/content-ai.js");
+      const result = await repurposePost(content, source_platform, target_platform);
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    } catch (error) {
+      return {
+        content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
+        isError: true,
+      };
+    }
+  }
+);
+
+// --- Audience ---
+
+server.registerTool(
+  "sync_followers",
+  {
+    title: "Sync Followers",
+    description: "Sync followers from the platform API for an account. Returns sync results including new and unfollowed counts.",
+    inputSchema: {
+      account_id: z.string(),
+    },
+  },
+  async ({ account_id }) => {
+    try {
+      const { syncFollowers } = await import("../lib/audience.js");
+      const result = syncFollowers(account_id);
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    } catch (error) {
+      return {
+        content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
+        isError: true,
+      };
+    }
+  }
+);
+
+server.registerTool(
+  "audience_insights",
+  {
+    title: "Audience Insights",
+    description: "Get audience insights for an account: total followers, growth rates, new/lost followers, and top followers.",
+    inputSchema: {
+      account_id: z.string(),
+    },
+  },
+  async ({ account_id }) => {
+    try {
+      const { getAudienceInsights } = await import("../lib/audience.js");
+      const insights = getAudienceInsights(account_id);
+      return { content: [{ type: "text", text: JSON.stringify(insights, null, 2) }] };
+    } catch (error) {
+      return {
+        content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
+        isError: true,
+      };
+    }
+  }
+);
+
+server.registerTool(
+  "follower_growth",
+  {
+    title: "Follower Growth Chart",
+    description: "Get follower growth data points over a number of days for charting.",
+    inputSchema: {
+      account_id: z.string(),
+      days: z.number().optional(),
+    },
+  },
+  async ({ account_id, days }) => {
+    try {
+      const { getFollowerGrowthChart } = await import("../lib/audience.js");
+      const chart = getFollowerGrowthChart(account_id, days || 30);
+      return { content: [{ type: "text", text: JSON.stringify(chart, null, 2) }] };
+    } catch (error) {
+      return {
+        content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
+        isError: true,
+      };
+    }
+  }
+);
+
+server.registerTool(
+  "top_followers",
+  {
+    title: "Top Followers",
+    description: "Get top followers for an account, sorted by their follower count (most influential first).",
+    inputSchema: {
+      account_id: z.string(),
+      limit: z.number().optional(),
+    },
+  },
+  async ({ account_id, limit }) => {
+    try {
+      const { getTopFollowers } = await import("../lib/audience.js");
+      const followers = getTopFollowers(account_id, limit || 10);
+      return { content: [{ type: "text", text: JSON.stringify({ followers, count: followers.length }, null, 2) }] };
+    } catch (error) {
+      return {
+        content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
+        isError: true,
+      };
+    }
+  }
+);
+
+// --- Sentiment Analysis ---
+
+server.registerTool(
+  "analyze_sentiment",
+  {
+    title: "Analyze Sentiment",
+    description: "Analyze the sentiment of a text using AI. Returns sentiment label (positive/neutral/negative), score (0-1), and emotional keywords.",
+    inputSchema: {
+      text: z.string().describe("The text to analyze for sentiment"),
+    },
+  },
+  async ({ text }) => {
+    try {
+      const { analyzeSentiment } = await import("../lib/sentiment.js");
+      const result = await analyzeSentiment(text);
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    } catch (error) {
+      return {
+        content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
+        isError: true,
+      };
+    }
+  }
+);
+
+server.registerTool(
+  "sentiment_report",
+  {
+    title: "Sentiment Report",
+    description: "Get an aggregated sentiment report for an account's mentions. Shows positive/neutral/negative percentages, trending keywords, and most positive/negative mentions.",
+    inputSchema: {
+      account_id: z.string(),
+      days: z.number().optional().describe("Number of days to look back (default: all time)"),
+    },
+  },
+  async ({ account_id, days }) => {
+    try {
+      const { getSentimentReport } = await import("../lib/sentiment.js");
+      const report = getSentimentReport(account_id, days);
+      return { content: [{ type: "text", text: JSON.stringify(report, null, 2) }] };
+    } catch (error) {
+      return {
+        content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
+        isError: true,
+      };
+    }
+  }
+);
+
+server.registerTool(
+  "auto_analyze_mention",
+  {
+    title: "Auto-Analyze Mention Sentiment",
+    description: "Analyze a mention's content for sentiment and store the result in the mention record. Returns the sentiment analysis result.",
+    inputSchema: {
+      mention_id: z.string(),
+    },
+  },
+  async ({ mention_id }) => {
+    try {
+      const { autoAnalyzeMention } = await import("../lib/sentiment.js");
+      const result = await autoAnalyzeMention(mention_id);
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    } catch (error) {
+      return {
+        content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
+        isError: true,
+      };
+    }
+  }
+);
+
 // --- Start ---
 async function main() {
   const transport = new StdioServerTransport();