outx-mcp-server 1.2.1 → 1.7.0

package/src/tools/linkedin.ts

@@ -25,8 +25,8 @@ export function registerLinkedInTools(
   );
 
   server.tool(
-    "fetch_linkedin_posts",
-    "Fetch recent posts from LinkedIn profiles by URN. Use fetch_linkedin_profile first to get the profile URN. Requires the OutX Chrome extension to be active. This tool handles async polling automatically.",
+    "fetch_linkedin_profile_posts",
+    "Fetch recent posts from one or more LinkedIn profiles by URN. Use fetch_linkedin_profile first to get the profile URN. Requires the OutX Chrome extension to be active. This tool handles async polling automatically.",
     {
       profile_urns: z
         .array(z.string())
@@ -45,8 +45,8 @@ export function registerLinkedInTools(
   );
 
   server.tool(
-    "linkedin_like_post",
-    "Like a LinkedIn post by its activity URN. This uses the LinkedIn Data API (direct LinkedIn action). Requires the OutX Chrome extension to be active. This tool handles async polling automatically.",
+    "like_linkedin_post",
+    "Like a LinkedIn post by its activity URN (direct LinkedIn action). Use this when you have a `social_urn` and don't need a watchlist. For liking a post that came from one of your watchlists (using its OutX `post_id`), use `like_watchlist_post` instead. Requires the OutX Chrome extension to be active. Polls automatically.",
     {
       social_urn: z
         .string()
@@ -63,8 +63,8 @@ export function registerLinkedInTools(
   );
 
   server.tool(
-    "linkedin_comment_on_post",
-    "Comment on a LinkedIn post by its activity URN. This uses the LinkedIn Data API (direct LinkedIn action). Requires the OutX Chrome extension to be active. This tool handles async polling automatically.",
+    "comment_on_linkedin_post",
+    "Comment on a LinkedIn post by its activity URN (direct LinkedIn action). Use this when you have a `social_urn` and don't need a watchlist. For commenting on a post that came from one of your watchlists (using its OutX `post_id`), use `comment_on_watchlist_post` instead. Requires the OutX Chrome extension to be active. Polls automatically.",
     {
       social_urn: z
         .string()
@@ -119,8 +119,8 @@ export function registerLinkedInTools(
   );
 
   server.tool(
-    "linkedin_send_message",
-    "Send a LinkedIn direct message to a 1st-degree connection. Requires the recipient's person URN (get it from fetch_linkedin_profile or linkedin_search_profiles). Message is sent from your team's oldest admin member's LinkedIn account. Requires the OutX Chrome extension to be active. This tool handles async polling automatically.",
+    "send_linkedin_message",
+    "Send a LinkedIn direct message to a 1st-degree connection. Requires the recipient's person URN (get it from fetch_linkedin_profile or search_linkedin_profiles). Message is sent from your team's oldest admin member's LinkedIn account. Requires the OutX Chrome extension to be active. Polls automatically.",
     {
       recipient_urn: z
         .string()
@@ -141,8 +141,33 @@ export function registerLinkedInTools(
   );
 
   server.tool(
-    "linkedin_search_profiles",
-    "Search LinkedIn profiles by keywords, title, company, location, industry, and more. Returns matching profiles with name, headline, location, profile slug, and connection degree. At least one filter is required. Requires the OutX Chrome extension to be active. This tool handles async polling automatically.",
+    "send_linkedin_connection_request",
+    "Send a LinkedIn connection request to a profile, with an optional note. Requires the person URN (get it from fetch_linkedin_profile or search_linkedin_profiles). Sent from your team's oldest admin member's LinkedIn account. Requires the OutX Chrome extension to be active. Polls automatically.",
+    {
+      profile_urn: z
+        .string()
+        .describe("LinkedIn person URN to connect with (e.g. 'urn:li:person:ACoAABCDEFG')"),
+      note: z
+        .string()
+        .optional()
+        .describe("Optional connection note (max 300 characters)."),
+    },
+    async (params) => {
+      const body: Record<string, unknown> = { profile_urn: params.profile_urn };
+      if (params.note) body.note = params.note;
+      const response = (await client.post(
+        "/linkedin-agent/send-connection-request",
+        body
+      )) as { api_agent_task_id: string };
+
+      const result = await client.pollTask(response.api_agent_task_id);
+      return { content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+
+  server.tool(
+    "search_linkedin_profiles",
+    "Search LinkedIn profiles by keywords, title, company, location, industry, and more. Returns matching profiles with name, headline, location, profile slug, and connection degree. At least one filter is required. Requires the OutX Chrome extension to be active. Polls automatically.",
     {
       keywords: z.string().optional().describe("General keyword search across name, headline, and profile text"),
       title: z.string().optional().describe("Filter by job title (e.g. 'VP of Engineering')"),
@@ -182,8 +207,8 @@ export function registerLinkedInTools(
   );
 
   server.tool(
-    "linkedin_fetch_connections",
-    "Fetch your 1st-degree LinkedIn connections. Optionally filter by keyword, sort by recently added, and paginate. Connections are from your team's oldest admin member's LinkedIn account. Requires the OutX Chrome extension to be active. This tool handles async polling automatically.",
+    "fetch_linkedin_connections",
+    "Fetch your 1st-degree LinkedIn connections. Optionally filter by keyword, sort by recently added, and paginate. Connections are from your team's oldest admin member's LinkedIn account. Requires the OutX Chrome extension to be active. Polls automatically.",
     {
       keyword: z.string().optional().describe("Filter connections by name (e.g. 'John')"),
       sort_type: z.string().optional().describe("Sort order. Pass 'RECENTLY_ADDED' for newest first"),
@@ -208,9 +233,9 @@ export function registerLinkedInTools(
 
   server.tool(
     "get_task_status",
-    "Check the status of an async LinkedIn Data API task. Use this to manually check tasks that timed out. Status values: pending, processing, completed, failed.",
+    "Recovery tool. Every other LinkedIn Data API tool polls automatically for ~150 seconds and returns the result directly, so you almost never need this. Use it ONLY when another tool returns a 'did not complete within 150s' error: pass the `api_agent_task_id` from that error message to check whether the task has since finished. Calling the original tool again would create a duplicate task and consume another LinkedIn-side daily quota slot. Status values: pending, processing, completed, failed.",
     {
-      task_id: z.string().describe("The api_agent_task_id to check"),
+      task_id: z.string().describe("The `api_agent_task_id` from the timeout error message of another LinkedIn Data tool."),
     },
     async (params) => {
       const result = await client.get("/linkedin-agent/get-task-status", {

package/src/tools/posts.ts

@@ -13,9 +13,9 @@ export function registerPostTools(
       watchlist_id: z.string().optional().describe("Filter by watchlist ID (omit for all)"),
       search_term: z.string().optional().describe("Search within post content"),
       sort_by: z
-        .enum(["recent_first", "oldest_first", "engagement"])
+        .enum(["recent", "popular_first", "engagement", "relevance_first"])
         .optional()
-        .describe("Sort order (default: recent_first)"),
+        .describe("Sort order (default: recent)"),
       page: z.string().optional().describe("Page number (default: 1)"),
       start_date: z.string().optional().describe("Filter posts after this date (ISO 8601)"),
       end_date: z.string().optional().describe("Filter posts before this date (ISO 8601)"),

package/src/tools/watchlists.ts

@@ -6,6 +6,41 @@ const fetchFreqEnum = z
   .enum(["1", "3", "6", "12", "24", "48", "72"])
   .describe("How often to scan for new posts (hours)");
 
+// A label (intent category) is either a bare name string, or an object with an
+// optional `default` flag that controls whether the label shows in the feed by
+// default. At most 2 labels may be default-true; the API caps any extras to false.
+// `key` is accepted as an alias for `name` so a label object returned by a GET
+// (which uses `key`) can be passed straight back on update.
+const labelSchema = z.union([
+  z.string(),
+  z.object({
+    name: z.string().optional().describe("Label name (use for new labels)"),
+    key: z
+      .string()
+      .optional()
+      .describe("Alias for `name`; the value GET returns, so a label from a GET can be sent back unchanged"),
+    description: z.string().optional().describe("What this label represents"),
+    default: z
+      .boolean()
+      .optional()
+      .describe(
+        "Show this label in the feed by default. At most 2 labels may be true; extras are capped to false."
+      ),
+  }),
+]);
+
+type LabelParam =
+  | string
+  | { name?: string; key?: string; description?: string; default?: boolean };
+
+// Normalize to the object array the API expects. A bare string becomes { name },
+// so callers that pass plain label names keep working (and now actually persist).
+function toApiLabels(
+  labels: LabelParam[]
+): Array<{ name?: string; key?: string; description?: string; default?: boolean }> {
+  return labels.map((l) => (typeof l === "string" ? { name: l } : l));
+}
+
 export function registerWatchlistTools(
   server: McpServer,
   client: OutxClient
@@ -14,37 +49,72 @@ export function registerWatchlistTools(
 
   server.tool(
     "create_keyword_watchlist",
-    "Create a watchlist that monitors LinkedIn posts matching keywords. Posts appear after the first scan cycle.",
+    "Create a watchlist that monitors LinkedIn posts matching keywords. Two modes: provide `keywords` to track exact terms, OR provide `prompt` to have OutX generate keywords and intent labels from a plain-English description. Pass one or the other, not both.",
     {
       keywords: z
         .array(z.string())
-        .min(1)
-        .describe("Keywords to track (e.g. ['AI startup funding', 'series A'])"),
+        .optional()
+        .describe(
+          "Direct mode. Keywords to track (e.g. ['AI startup funding', 'series A']). Mutually exclusive with `prompt`."
+        ),
       required_keywords: z
         .array(z.string())
         .optional()
-        .describe("Posts MUST contain at least one of these words"),
+        .describe("Direct mode only. Applied to every keyword. Posts MUST contain at least one of these words."),
       exclude_keywords: z
         .array(z.string())
         .optional()
-        .describe("Exclude posts containing any of these words"),
-      name: z.string().optional().describe("Watchlist name"),
-      description: z.string().optional(),
-      labels: z.array(z.string()).optional().describe("Custom labels for categorization"),
+        .describe("Direct mode only. Applied to every keyword. Posts containing any of these are excluded."),
+      prompt: z
+        .string()
+        .optional()
+        .describe(
+          "AI mode. Plain-English description of what to track (e.g. 'People looking for remote software engineering jobs'). OutX generates keywords and intent labels in the background. Mutually exclusive with `keywords`."
+        ),
+      name: z.string().optional().describe("Watchlist name. Auto-generated if omitted."),
+      description: z.string().optional().describe("Direct mode only. Optional description for the watchlist."),
+      objective: z
+        .string()
+        .optional()
+        .describe(
+          "Direct mode only. One-sentence objective (who/what you want to find and why). Drives the relevance-scoring vector so direct-mode lists rank like prompt-built ones. Omit and the list ranks only by keyword match."
+        ),
+      labels: z
+        .array(labelSchema)
+        .optional()
+        .describe(
+          "Direct mode only. Intent labels for categorization. Each is a name string, or an object {name, description, default} where `default` controls feed visibility (max 2 default-true)."
+        ),
       fetchFreqInHours: fetchFreqEnum.optional(),
     },
     async (params) => {
-      const body: Record<string, unknown> = {
-        keywords: params.keywords.map((kw) => {
+      const hasKeywords = Array.isArray(params.keywords) && params.keywords.length > 0;
+      const hasPrompt = typeof params.prompt === "string" && params.prompt.trim().length > 0;
+
+      if (hasKeywords && hasPrompt) {
+        throw new Error("Provide either `keywords` or `prompt`, not both.");
+      }
+      if (!hasKeywords && !hasPrompt) {
+        throw new Error("Provide either `keywords` (array) or `prompt` (string).");
+      }
+
+      const body: Record<string, unknown> = {};
+
+      if (hasPrompt) {
+        body.prompt = params.prompt!.trim();
+      } else {
+        body.keywords = params.keywords!.map((kw) => {
           const obj: Record<string, unknown> = { keyword: kw };
           if (params.required_keywords) obj.required_keywords = params.required_keywords;
           if (params.exclude_keywords) obj.exclude_keywords = params.exclude_keywords;
           return obj;
-        }),
-      };
+        });
+        if (params.description) body.description = params.description;
+        if (params.objective) body.objective = params.objective;
+        if (params.labels) body.labels = toApiLabels(params.labels);
+      }
+
       if (params.name) body.name = params.name;
-      if (params.description) body.description = params.description;
-      if (params.labels) body.labels = params.labels;
       if (params.fetchFreqInHours)
         body.fetchFreqInHours = parseInt(params.fetchFreqInHours);
 
@@ -65,7 +135,7 @@ export function registerWatchlistTools(
 
   server.tool(
     "update_keyword_watchlist",
-    "Update a keyword watchlist. Can change name, fetch frequency, Slack webhook, pause/resume tracking via `disable`, and replace the tracked keywords or labels.",
+    "Update a keyword watchlist. Patch any fields (name, fetchFreqInHours, disable, slack_webhook_url, keywords, labels), OR pass `prompt` to have OutX regenerate keywords and labels from a new description. Patch and prompt modes are mutually exclusive.",
     {
       id: z.string().describe("Watchlist ID"),
       name: z.string().optional(),
@@ -83,38 +153,66 @@ export function registerWatchlistTools(
         .array(z.string())
         .optional()
         .describe(
-          "Replace tracked keywords. All existing keywords are removed and these are inserted."
+          "Patch mode. Replace tracked keywords; all existing keywords are removed and these are inserted. Mutually exclusive with `prompt`."
         ),
       required_keywords: z
         .array(z.string())
         .optional()
-        .describe("Applied to every keyword above. Posts MUST contain at least one."),
+        .describe("Patch mode only. Applied to every keyword above. Posts MUST contain at least one."),
       exclude_keywords: z
         .array(z.string())
         .optional()
-        .describe("Applied to every keyword above. Posts containing any are excluded."),
+        .describe("Patch mode only. Applied to every keyword above. Posts containing any are excluded."),
       labels: z
-        .array(z.string())
+        .array(labelSchema)
         .optional()
-        .describe("Replace label set used to categorize matched posts."),
+        .describe(
+          "Patch mode only. Replaces the label set. Each is a name string, or an object {name, description, default}. GET the watchlist first to see current labels and their `default` flags so you can preserve them."
+        ),
+      prompt: z
+        .string()
+        .optional()
+        .describe(
+          "Regenerate mode. New plain-English prompt. OutX wipes the existing keywords and labels and regenerates them in the background. Mutually exclusive with patch fields above (other than `id`)."
+        ),
     },
     async (params) => {
+      const hasPrompt = typeof params.prompt === "string" && params.prompt.trim().length > 0;
+      const hasPatch =
+        params.name !== undefined ||
+        params.fetchFreqInHours !== undefined ||
+        params.disable !== undefined ||
+        params.slack_webhook_url !== undefined ||
+        params.keywords !== undefined ||
+        params.labels !== undefined;
+
+      if (hasPrompt && hasPatch) {
+        throw new Error(
+          "Provide either patch fields (name, fetchFreqInHours, disable, slack_webhook_url, keywords, labels) or `prompt` for regeneration, not both."
+        );
+      }
+
       const body: Record<string, unknown> = { id: params.id };
-      if (params.name) body.name = params.name;
-      if (params.fetchFreqInHours)
-        body.fetchFreqInHours = parseInt(params.fetchFreqInHours);
-      if (params.disable !== undefined) body.disable = params.disable;
-      if (params.slack_webhook_url !== undefined)
-        body.slack_webhook_url = params.slack_webhook_url;
-      if (params.keywords) {
-        body.keywords = params.keywords.map((kw) => {
-          const obj: Record<string, unknown> = { keyword: kw };
-          if (params.required_keywords) obj.required_keywords = params.required_keywords;
-          if (params.exclude_keywords) obj.exclude_keywords = params.exclude_keywords;
-          return obj;
-        });
+
+      if (hasPrompt) {
+        body.prompt = params.prompt!.trim();
+      } else {
+        if (params.name) body.name = params.name;
+        if (params.fetchFreqInHours)
+          body.fetchFreqInHours = parseInt(params.fetchFreqInHours);
+        if (params.disable !== undefined) body.disable = params.disable;
+        if (params.slack_webhook_url !== undefined)
+          body.slack_webhook_url = params.slack_webhook_url;
+        if (params.keywords) {
+          body.keywords = params.keywords.map((kw) => {
+            const obj: Record<string, unknown> = { keyword: kw };
+            if (params.required_keywords) obj.required_keywords = params.required_keywords;
+            if (params.exclude_keywords) obj.exclude_keywords = params.exclude_keywords;
+            return obj;
+          });
+        }
+        if (params.labels) body.labels = toApiLabels(params.labels);
       }
-      if (params.labels) body.labels = params.labels;
 
       const result = await client.put("/api-keyword-watchlist", body);
       return { content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }] };
@@ -135,49 +233,6 @@ export function registerWatchlistTools(
     }
   );
 
-  server.tool(
-    "create_keyword_watchlist_from_prompt",
-    "Create a keyword watchlist from a natural-language prompt. OutX generates optimized keywords and intent labels automatically using AI. The watchlist is created immediately; keyword generation runs in the background. Hits the same endpoint as create_keyword_watchlist with a different body shape (prompt instead of keywords).",
-    {
-      prompt: z
-        .string()
-        .describe(
-          "Plain English description of what to track (e.g. 'People looking for remote software engineering jobs'). Can include URLs for better keyword quality."
-        ),
-      name: z.string().optional().describe("Watchlist name (auto-generated if omitted)"),
-      fetchFreqInHours: fetchFreqEnum.optional(),
-    },
-    async (params) => {
-      const body: Record<string, unknown> = { prompt: params.prompt };
-      if (params.name) body.name = params.name;
-      if (params.fetchFreqInHours)
-        body.fetchFreqInHours = parseInt(params.fetchFreqInHours);
-
-      const result = await client.post("/api-keyword-watchlist", body);
-      return { content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }] };
-    }
-  );
-
-  server.tool(
-    "regenerate_keyword_watchlist_from_prompt",
-    "Replace the prompt on an existing keyword watchlist. OutX wipes the current keywords and labels and regenerates them from the new prompt. Regeneration runs in the background. Hits the same endpoint as update_keyword_watchlist with a prompt body.",
-    {
-      id: z.string().describe("Watchlist ID to update"),
-      prompt: z
-        .string()
-        .describe("New natural-language prompt. OutX will regenerate keywords and labels from this."),
-    },
-    async (params) => {
-      const body: Record<string, unknown> = {
-        id: params.id,
-        prompt: params.prompt,
-      };
-
-      const result = await client.put("/api-keyword-watchlist", body);
-      return { content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }] };
-    }
-  );
-
   // ── People Watchlists ───────────────────────────────────
 
   server.tool(
@@ -343,4 +398,178 @@ export function registerWatchlistTools(
       return { content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }] };
     }
   );
+
+  // ── Reddit Watchlists ───────────────────────────────────
+
+  server.tool(
+    "create_reddit_watchlist",
+    "Create a watchlist that monitors Reddit posts matching keywords. Two modes: provide `keywords` to track exact terms, OR provide `prompt` to have OutX generate keywords and intent labels from a plain-English description. Pass one or the other, not both.",
+    {
+      keywords: z
+        .array(z.string())
+        .optional()
+        .describe("Direct mode. Keywords to track on Reddit. Mutually exclusive with `prompt`."),
+      required_keywords: z
+        .array(z.string())
+        .optional()
+        .describe("Direct mode only. Applied to every keyword. Posts MUST contain at least one of these words."),
+      exclude_keywords: z
+        .array(z.string())
+        .optional()
+        .describe("Direct mode only. Applied to every keyword. Posts containing any of these are excluded."),
+      prompt: z
+        .string()
+        .optional()
+        .describe("AI mode. Plain-English description of what to track on Reddit. Mutually exclusive with `keywords`."),
+      name: z.string().optional().describe("Watchlist name. Auto-generated if omitted."),
+      description: z.string().optional().describe("Direct mode only. Optional description for the watchlist."),
+      objective: z
+        .string()
+        .optional()
+        .describe("Direct mode only. One-sentence objective; drives the relevance-scoring vector so direct-mode lists rank like prompt-built ones."),
+      labels: z
+        .array(labelSchema)
+        .optional()
+        .describe("Direct mode only. Intent labels. Each is a name string, or an object {name, description, default} (max 2 default-true)."),
+      fetchFreqInHours: fetchFreqEnum.optional().describe("Scan frequency in hours (Reddit default 24)."),
+    },
+    async (params) => {
+      const hasKeywords = Array.isArray(params.keywords) && params.keywords.length > 0;
+      const hasPrompt = typeof params.prompt === "string" && params.prompt.trim().length > 0;
+
+      if (hasKeywords && hasPrompt) {
+        throw new Error("Provide either `keywords` or `prompt`, not both.");
+      }
+      if (!hasKeywords && !hasPrompt) {
+        throw new Error("Provide either `keywords` (array) or `prompt` (string).");
+      }
+
+      const body: Record<string, unknown> = {};
+
+      if (hasPrompt) {
+        body.prompt = params.prompt!.trim();
+      } else {
+        body.keywords = params.keywords!.map((kw) => {
+          const obj: Record<string, unknown> = { keyword: kw };
+          if (params.required_keywords) obj.required_keywords = params.required_keywords;
+          if (params.exclude_keywords) obj.exclude_keywords = params.exclude_keywords;
+          return obj;
+        });
+        if (params.description) body.description = params.description;
+        if (params.objective) body.objective = params.objective;
+        if (params.labels) body.labels = toApiLabels(params.labels);
+      }
+
+      if (params.name) body.name = params.name;
+      if (params.fetchFreqInHours)
+        body.fetchFreqInHours = parseInt(params.fetchFreqInHours);
+
+      const result = await client.post("/api-reddit-watchlist", body);
+      return { content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+
+  server.tool(
+    "list_reddit_watchlists",
+    "List all reddit watchlists for your account.",
+    {},
+    async () => {
+      const result = await client.get("/api-reddit-watchlist");
+      return { content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+
+  server.tool(
+    "update_reddit_watchlist",
+    "Update a reddit watchlist. Patch any fields (name, fetchFreqInHours, disable, slack_webhook_url, keywords, labels), OR pass `prompt` to regenerate keywords and labels. Patch and prompt modes are mutually exclusive.",
+    {
+      id: z.string().describe("Watchlist ID"),
+      name: z.string().optional(),
+      fetchFreqInHours: fetchFreqEnum.optional(),
+      disable: z
+        .boolean()
+        .optional()
+        .describe("Set to true to pause tracking, false to resume"),
+      slack_webhook_url: z
+        .string()
+        .nullable()
+        .optional()
+        .describe("Slack incoming webhook URL for alerts. Pass null to clear."),
+      keywords: z
+        .array(z.string())
+        .optional()
+        .describe("Patch mode. Replace tracked keywords. Mutually exclusive with `prompt`."),
+      required_keywords: z
+        .array(z.string())
+        .optional()
+        .describe("Patch mode only. Applied to every keyword above."),
+      exclude_keywords: z
+        .array(z.string())
+        .optional()
+        .describe("Patch mode only. Applied to every keyword above."),
+      labels: z
+        .array(labelSchema)
+        .optional()
+        .describe("Patch mode only. Replaces the label set. GET the watchlist first to preserve current `default` flags."),
+      prompt: z
+        .string()
+        .optional()
+        .describe("Regenerate mode. New plain-English prompt. Mutually exclusive with the patch fields above."),
+    },
+    async (params) => {
+      const hasPrompt = typeof params.prompt === "string" && params.prompt.trim().length > 0;
+      const hasPatch =
+        params.name !== undefined ||
+        params.fetchFreqInHours !== undefined ||
+        params.disable !== undefined ||
+        params.slack_webhook_url !== undefined ||
+        params.keywords !== undefined ||
+        params.labels !== undefined;
+
+      if (hasPrompt && hasPatch) {
+        throw new Error(
+          "Provide either patch fields (name, fetchFreqInHours, disable, slack_webhook_url, keywords, labels) or `prompt` for regeneration, not both."
+        );
+      }
+
+      const body: Record<string, unknown> = { id: params.id };
+
+      if (hasPrompt) {
+        body.prompt = params.prompt!.trim();
+      } else {
+        if (params.name) body.name = params.name;
+        if (params.fetchFreqInHours)
+          body.fetchFreqInHours = parseInt(params.fetchFreqInHours);
+        if (params.disable !== undefined) body.disable = params.disable;
+        if (params.slack_webhook_url !== undefined)
+          body.slack_webhook_url = params.slack_webhook_url;
+        if (params.keywords) {
+          body.keywords = params.keywords.map((kw) => {
+            const obj: Record<string, unknown> = { keyword: kw };
+            if (params.required_keywords) obj.required_keywords = params.required_keywords;
+            if (params.exclude_keywords) obj.exclude_keywords = params.exclude_keywords;
+            return obj;
+          });
+        }
+        if (params.labels) body.labels = toApiLabels(params.labels);
+      }
+
+      const result = await client.put("/api-reddit-watchlist", body);
+      return { content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+
+  server.tool(
+    "delete_reddit_watchlist",
+    "Delete a reddit watchlist and all its tracked data.",
+    {
+      id: z.string().describe("Watchlist ID to delete"),
+    },
+    async (params) => {
+      const result = await client.delete("/api-reddit-watchlist", {
+        id: params.id,
+      });
+      return { content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }] };
+    }
+  );
 }