@socialneuron/mcp-server 1.7.15 → 1.7.18

package/dist/http.js

@@ -420,8 +420,8 @@ async function getDefaultUserId() {
 async function getDefaultProjectId() {
   const userId = await getDefaultUserId().catch(() => null);
   if (userId) {
-    const cached2 = projectIdCache.get(userId);
-    if (cached2) return cached2;
+    const cached3 = projectIdCache.get(userId);
+    if (cached3) return cached3;
   }
   const envProjectId = process.env.SOCIALNEURON_PROJECT_ID;
   if (envProjectId) {
@@ -568,7 +568,7 @@ var init_supabase = __esm({
 // src/http.ts
 import express from "express";
 import { randomUUID as randomUUID4 } from "node:crypto";
-import { McpServer as McpServer2 } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { McpServer as McpServer3 } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import {
   mcpAuthRouter,
@@ -620,6 +620,7 @@ var TOOL_SCOPES = {
   adapt_content: "mcp:write",
   generate_video: "mcp:write",
   generate_image: "mcp:write",
+  // check_status is read-only (polls job state) despite living in this write block.
   check_status: "mcp:read",
   render_demo_video: "mcp:write",
   render_template_video: "mcp:write",
@@ -891,6 +892,24 @@ function buildWwwAuthenticateHeader(opts) {
   return `Bearer ${params.join(", ")}`;
 }
 
+// src/lib/tool-error.ts
+function toolError(code, message, opts = {}) {
+  const errorObj = {
+    error_type: code,
+    message,
+    ...opts.recover_with && opts.recover_with.length ? { recover_with: opts.recover_with } : {},
+    ...opts.details ?? {}
+  };
+  return {
+    // Text mirror: models read the JSON; `error_type` is the first line so it
+    // is cheap to grep from the text block even without structuredContent support.
+    content: [{ type: "text", text: JSON.stringify(errorObj, null, 2) }],
+    structuredContent: { error: errorObj },
+    isError: true,
+    ...opts.meta ? { _meta: opts.meta } : {}
+  };
+}
+
 // src/lib/agent-harness/constants.json
 var constants_default = {
   ZERO_WIDTH_CHARS: "[\\u200B\\u200C\\u200D\\u2060\\uFEFF\\u{E0020}-\\u{E007F}]",
@@ -1144,11 +1163,15 @@ async function callEdgeFunction(functionName, body, options) {
 // src/lib/rate-limit.ts
 var CATEGORY_CONFIGS = {
   posting: { maxTokens: 30, refillRate: 30 / 60 },
-  // 30 req/min
+  // 30 req/min — publish/schedule/comment
+  generation: { maxTokens: 15, refillRate: 15 / 60 },
+  // 15 req/min — expensive AI media gen
+  upload: { maxTokens: 20, refillRate: 20 / 60 },
+  // 20 req/min — media upload
   screenshot: { maxTokens: 10, refillRate: 10 / 60 },
-  // 10 req/min
+  // 10 req/min — browser capture
   read: { maxTokens: 60, refillRate: 60 / 60 }
-  // 60 req/min
+  // 60 req/min — default
 };
 var RateLimiter = class {
   tokens;
@@ -1190,18 +1213,19 @@ var RateLimiter = class {
   }
 };
 var limiters = /* @__PURE__ */ new Map();
-function getRateLimiter(category) {
-  let limiter = limiters.get(category);
+function getRateLimiter(bucketKey, category) {
+  let limiter = limiters.get(bucketKey);
   if (!limiter) {
-    const config = CATEGORY_CONFIGS[category] ?? CATEGORY_CONFIGS.read;
+    const resolved = category ?? bucketKey;
+    const config = CATEGORY_CONFIGS[resolved] ?? CATEGORY_CONFIGS.read;
     limiter = new RateLimiter(config);
-    limiters.set(category, limiter);
+    limiters.set(bucketKey, limiter);
   }
   return limiter;
 }
 function checkRateLimit(category, key) {
   const bucketKey = key ? `${category}:${key}` : category;
-  const limiter = getRateLimiter(bucketKey);
+  const limiter = getRateLimiter(bucketKey, category);
   const allowed = limiter.consume();
   return {
     allowed,
@@ -1213,7 +1237,7 @@ function checkRateLimit(category, key) {
 init_supabase();
 
 // src/lib/version.ts
-var MCP_VERSION = "1.7.15";
+var MCP_VERSION = "1.7.18";
 
 // src/tools/ideation.ts
 function asEnvelope(data) {
@@ -2913,7 +2937,11 @@ async function rehostExternalUrl(mediaUrl, projectId) {
   if (isAlreadyR2Signed(mediaUrl)) {
     return { signedUrl: mediaUrl, r2Key: "" };
   }
-  const { data, error } = await callEdgeFunction("upload-to-r2", { url: ssrf.sanitizedUrl ?? mediaUrl, projectId }, { timeoutMs: 6e4 });
+  const { data, error } = await callEdgeFunction(
+    "upload-to-r2",
+    { url: ssrf.sanitizedUrl ?? mediaUrl, projectId },
+    { timeoutMs: 6e4 }
+  );
   if (error || !data?.key || !data?.url) {
     return { error: error ?? "upload-to-r2 returned no key" };
   }
@@ -2949,14 +2977,18 @@ function registerDistributionTools(server) {
             "MUTUAL_FOLLOW_FRIENDS",
             "FOLLOWER_OF_CREATOR",
             "SELF_ONLY"
-          ]).optional().describe("Required unless useInbox=true. Who can view the video."),
+          ]).optional().describe(
+            "Required unless useInbox=true. Who can view the video."
+          ),
           enable_duet: z3.boolean().optional(),
           enable_comment: z3.boolean().optional(),
           enable_stitch: z3.boolean().optional(),
           is_ai_generated: z3.boolean().optional(),
           brand_content: z3.boolean().optional(),
           brand_organic: z3.boolean().optional(),
-          use_inbox: z3.boolean().optional().describe("Post to TikTok inbox/draft instead of direct publish.")
+          use_inbox: z3.boolean().optional().describe(
+            "Post to TikTok inbox/draft instead of direct publish."
+          )
         }).optional(),
         youtube: z3.object({
           title: z3.string().optional().describe("Video title (required for YouTube)."),
@@ -3034,7 +3066,9 @@ function registerDistributionTools(server) {
       ),
       project_id: z3.string().optional().describe("Social Neuron project ID to associate this post with."),
       response_format: z3.enum(["text", "json"]).optional().describe("Optional response format. Defaults to text."),
-      attribution: z3.boolean().optional().describe('If true, appends "Created with Social Neuron" to the caption. Default: false.'),
+      attribution: z3.boolean().optional().describe(
+        'If true, appends "Created with Social Neuron" to the caption. Default: false.'
+      ),
       account_id: z3.string().optional().describe(
         "Connected account ID to post from. Use list_connected_accounts to find the right ID. Required when multiple accounts exist for the same platform."
       ),
@@ -3048,10 +3082,10 @@ function registerDistributionTools(server) {
         "Visual QA gate verdict from the carousel/image generation pipeline. Required when mediaType is CAROUSEL_ALBUM, IMAGE, or VIDEO and VISUAL_GATE_ENFORCE is enabled on the EF. Produce with visual_quality_check tool. Must have passed=true for the gate to allow the publish."
       ),
       origin: z3.enum(["human", "hermes", "user"]).optional().describe(
-        "Originator lineage for the post. 'hermes' marks the post as scheduled by the Hermes autonomous agent \u2014 surfaces the Hermes badge + filter in Distribution. Default 'human'. Use only when calling from an autonomous workflow (cron, Slack bot, etc.)."
+        "Originator lineage for the post. Marks who scheduled it; use the agent value when calling from an autonomous workflow, otherwise default 'human'."
       ),
       hermes_run_id: z3.string().optional().describe(
-        "Hermes cron run identifier \u2014 e.g. 'cron_<id>_<timestamp>'. Persists to posts.hermes_run_id when origin='hermes'. Use for traceability between drafts and the cron that produced them."
+        "Optional agent run identifier for traceability between a draft and the run that produced it."
       )
     },
     async ({
@@ -3081,7 +3115,12 @@ function registerDistributionTools(server) {
       const format = response_format ?? "text";
       if ((!caption || caption.trim().length === 0) && (!title || title.trim().length === 0)) {
         return {
-          content: [{ type: "text", text: "Either caption or title is required." }],
+          content: [
+            {
+              type: "text",
+              text: "Either caption or title is required."
+            }
+          ],
           isError: true
         };
       }
@@ -3110,7 +3149,11 @@ function registerDistributionTools(server) {
         return signData?.signedUrl ?? signData?.url ?? null;
       };
       const resolveJobId = async (jid) => {
-        const { data: jobData } = await callEdgeFunction("mcp-data", { action: "job-status", jobId: jid }, { timeoutMs: 1e4 });
+        const { data: jobData } = await callEdgeFunction(
+          "mcp-data",
+          { action: "job-status", jobId: jid },
+          { timeoutMs: 1e4 }
+        );
         const resultUrl = jobData?.job?.result_url;
         if (!resultUrl) return null;
         if (!resultUrl.startsWith("http")) return signR2Key(resultUrl);
@@ -3210,9 +3253,7 @@ function registerDistributionTools(server) {
               isError: true
             };
           }
-          resolvedMediaUrls = rehosted.map(
-            (r) => r.signedUrl
-          );
+          resolvedMediaUrls = rehosted.map((r) => r.signedUrl);
         }
       } catch (resolveErr) {
         return {
@@ -3225,8 +3266,12 @@ function registerDistributionTools(server) {
           isError: true
         };
       }
-      const normalizedPlatforms = platforms.map((p) => PLATFORM_CASE_MAP[p.toLowerCase()] || p);
-      const blockedPlatforms = normalizedPlatforms.filter((p) => MCP_NOT_LIVE_FOR_POSTING.has(p));
+      const normalizedPlatforms = platforms.map(
+        (p) => PLATFORM_CASE_MAP[p.toLowerCase()] || p
+      );
+      const blockedPlatforms = normalizedPlatforms.filter(
+        (p) => MCP_NOT_LIVE_FOR_POSTING.has(p)
+      );
       if (blockedPlatforms.length > 0) {
         return {
           content: [
@@ -3329,7 +3374,9 @@ Created with Social Neuron`;
           projectId: project_id,
           ...connectedAccountIds ? { connectedAccountIds } : {},
           ...normalizedPlatformMetadata ? {
-            platformMetadata: convertPlatformMetadata(normalizedPlatformMetadata)
+            platformMetadata: convertPlatformMetadata(
+              normalizedPlatformMetadata
+            )
           } : {},
           // Forward visual gate verdict + source so the EF can enforce on media posts.
           ...visual_gate_result ? { visualGateResult: visual_gate_result } : {},
@@ -3377,7 +3424,9 @@ Created with Social Neuron`;
       lines.push("", "Platform results:");
       for (const [platform2, result] of Object.entries(data.results)) {
         if (result.success) {
-          lines.push(`  ${platform2}: OK (jobId=${result.jobId}, postId=${result.postId})`);
+          lines.push(
+            `  ${platform2}: OK (jobId=${result.jobId}, postId=${result.postId})`
+          );
         } else {
           lines.push(`  ${platform2}: FAILED - ${result.error}`);
         }
@@ -3386,7 +3435,12 @@ Created with Social Neuron`;
         const structuredContent = asEnvelope3(data);
         return {
           structuredContent,
-          content: [{ type: "text", text: JSON.stringify(structuredContent, null, 2) }],
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(structuredContent, null, 2)
+            }
+          ],
           isError: !data.success
         };
       }
@@ -3442,12 +3496,17 @@ Created with Social Neuron`;
       for (const account of accounts) {
         const name = account.username || "(unnamed)";
         const platformLower = account.platform.toLowerCase();
-        lines.push(`  ${platformLower}: ${name} (connected ${account.created_at.split("T")[0]})`);
+        lines.push(
+          `  ${platformLower}: ${name} (connected ${account.created_at.split("T")[0]})`
+        );
       }
       if (format === "json") {
         return {
           content: [
-            { type: "text", text: JSON.stringify(asEnvelope3({ accounts }), null, 2) }
+            {
+              type: "text",
+              text: JSON.stringify(asEnvelope3({ accounts }), null, 2)
+            }
           ]
         };
       }
@@ -3502,7 +3561,12 @@ Created with Social Neuron`;
           const structuredContent2 = asEnvelope3({ posts: [] });
           return {
             structuredContent: structuredContent2,
-            content: [{ type: "text", text: JSON.stringify(structuredContent2, null, 2) }]
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify(structuredContent2, null, 2)
+              }
+            ]
           };
         }
         return {
@@ -3519,7 +3583,12 @@ Created with Social Neuron`;
       if (format === "json") {
         return {
           structuredContent,
-          content: [{ type: "text", text: JSON.stringify(structuredContent, null, 2) }]
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(structuredContent, null, 2)
+            }
+          ]
         };
       }
       const statusIcon = {
@@ -3580,7 +3649,13 @@ Created with Social Neuron`;
       min_gap_hours: z3.number().min(1).max(24).default(4).describe("Minimum gap between posts on same platform"),
       response_format: z3.enum(["text", "json"]).default("text")
     },
-    async ({ platforms, count, start_after, min_gap_hours, response_format }) => {
+    async ({
+      platforms,
+      count,
+      start_after,
+      min_gap_hours,
+      response_format
+    }) => {
       try {
         const startDate = start_after ? new Date(start_after) : /* @__PURE__ */ new Date();
         const endDate = new Date(startDate.getTime() + 7 * 24 * 60 * 60 * 1e3);
@@ -3594,7 +3669,9 @@ Created with Social Neuron`;
         const gapMs = min_gap_hours * 60 * 60 * 1e3;
         const candidates = [];
         for (let dayOffset = 0; dayOffset < 7; dayOffset++) {
-          const date = new Date(startDate.getTime() + dayOffset * 24 * 60 * 60 * 1e3);
+          const date = new Date(
+            startDate.getTime() + dayOffset * 24 * 60 * 60 * 1e3
+          );
           const dayOfWeek = date.getUTCDay();
           for (const platform2 of platforms) {
             const hours = PREFERRED_HOURS[platform2] ?? [12, 16];
@@ -3603,8 +3680,11 @@ Created with Social Neuron`;
               slotDate.setUTCHours(hours[hourIdx], 0, 0, 0);
               if (slotDate <= startDate) continue;
               const hasConflict = (existingPosts ?? []).some((post) => {
-                if (String(post.platform).toLowerCase() !== platform2) return false;
-                const postTime = new Date(post.scheduled_at ?? post.published_at).getTime();
+                if (String(post.platform).toLowerCase() !== platform2)
+                  return false;
+                const postTime = new Date(
+                  post.scheduled_at ?? post.published_at
+                ).getTime();
                 return Math.abs(postTime - slotDate.getTime()) < gapMs;
               });
               let engagementScore = hours.length - hourIdx;
@@ -3642,19 +3722,28 @@ Created with Social Neuron`;
           };
         }
         const lines = [];
-        lines.push(`Found ${slots.length} optimal slots (${conflictsAvoided} conflicts avoided):`);
+        lines.push(
+          `Found ${slots.length} optimal slots (${conflictsAvoided} conflicts avoided):`
+        );
         lines.push("");
         lines.push("Datetime (UTC)           | Platform   | Score");
         lines.push("-------------------------+------------+------");
         for (const s of slots) {
           const dt = s.datetime.replace("T", " ").slice(0, 19);
-          lines.push(`${dt.padEnd(25)}| ${s.platform.padEnd(11)}| ${s.engagement_score}`);
+          lines.push(
+            `${dt.padEnd(25)}| ${s.platform.padEnd(11)}| ${s.engagement_score}`
+          );
         }
-        return { content: [{ type: "text", text: lines.join("\n") }], isError: false };
+        return {
+          content: [{ type: "text", text: lines.join("\n") }],
+          isError: false
+        };
       } catch (err) {
         const message = sanitizeError(err);
         return {
-          content: [{ type: "text", text: `Failed to find slots: ${message}` }],
+          content: [
+            { type: "text", text: `Failed to find slots: ${message}` }
+          ],
           isError: true
         };
       }
@@ -3681,8 +3770,12 @@ Created with Social Neuron`;
       auto_slot: z3.boolean().default(true).describe("Auto-assign time slots for posts without schedule_at"),
       dry_run: z3.boolean().default(false).describe("Preview without actually scheduling"),
       response_format: z3.enum(["text", "json"]).default("text"),
-      enforce_quality: z3.boolean().default(true).describe("When true, block scheduling for posts that fail quality checks."),
-      quality_threshold: z3.number().int().min(0).max(35).optional().describe("Optional quality threshold override. Defaults to project setting or 26."),
+      enforce_quality: z3.boolean().default(true).describe(
+        "When true, block scheduling for posts that fail quality checks."
+      ),
+      quality_threshold: z3.number().int().min(0).max(35).optional().describe(
+        "Optional quality threshold override. Defaults to project setting or 26."
+      ),
       batch_size: z3.number().int().min(1).max(10).default(4).describe("Concurrent schedule calls per platform batch."),
       idempotency_seed: z3.string().max(128).optional().describe("Optional stable seed used when building idempotency keys.")
     },
@@ -3719,17 +3812,25 @@ Created with Social Neuron`;
           if (!stored?.plan_payload) {
             return {
               content: [
-                { type: "text", text: `No content plan found for plan_id=${plan_id}` }
+                {
+                  type: "text",
+                  text: `No content plan found for plan_id=${plan_id}`
+                }
               ],
               isError: true
             };
           }
           const payload = stored.plan_payload;
-          const postsFromPayload = Array.isArray(payload.posts) ? payload.posts : Array.isArray(payload.data?.posts) ? payload.data.posts : null;
+          const postsFromPayload = Array.isArray(payload.posts) ? payload.posts : Array.isArray(
+            payload.data?.posts
+          ) ? payload.data.posts : null;
           if (!postsFromPayload) {
             return {
               content: [
-                { type: "text", text: `Stored plan ${plan_id} has no posts array.` }
+                {
+                  type: "text",
+                  text: `Stored plan ${plan_id} has no posts array.`
+                }
               ],
               isError: true
             };
@@ -3759,7 +3860,10 @@ Created with Social Neuron`;
           }
         }
         if (effectivePlanId) {
-          const { data: approvalsResult, error: approvalsError } = await callEdgeFunction("mcp-data", { action: "list-plan-approvals", plan_id: effectivePlanId });
+          const { data: approvalsResult, error: approvalsError } = await callEdgeFunction("mcp-data", {
+            action: "list-plan-approvals",
+            plan_id: effectivePlanId
+          });
           if (approvalsError) {
             return {
               content: [
@@ -3820,7 +3924,10 @@ Created with Social Neuron`;
             approvalSummary = {
               total: approvals.length,
               eligible: approvedPosts.length,
-              skipped: Math.max(0, workingPlan.posts.length - approvedPosts.length)
+              skipped: Math.max(
+                0,
+                workingPlan.posts.length - approvedPosts.length
+              )
             };
             workingPlan = {
               ...workingPlan,
@@ -3890,13 +3997,18 @@ Created with Social Neuron`;
             }
           };
         });
-        const qualityPassed = postsWithResults.filter((post) => post.quality.passed).length;
+        const qualityPassed = postsWithResults.filter(
+          (post) => post.quality.passed
+        ).length;
         const qualitySummary = {
           total_posts: postsWithResults.length,
           passed: qualityPassed,
           failed: postsWithResults.length - qualityPassed,
           avg_score: postsWithResults.length > 0 ? Number(
-            (postsWithResults.reduce((sum, post) => sum + post.quality.score, 0) / postsWithResults.length).toFixed(2)
+            (postsWithResults.reduce(
+              (sum, post) => sum + post.quality.score,
+              0
+            ) / postsWithResults.length).toFixed(2)
           ) : 0
         };
         if (dry_run) {
@@ -3955,8 +4067,13 @@ Created with Social Neuron`;
             }
           }
           lines2.push("");
-          lines2.push(`Summary: ${passed}/${workingPlan.posts.length} passed quality check`);
-          return { content: [{ type: "text", text: lines2.join("\n") }], isError: false };
+          lines2.push(
+            `Summary: ${passed}/${workingPlan.posts.length} passed quality check`
+          );
+          return {
+            content: [{ type: "text", text: lines2.join("\n") }],
+            isError: false
+          };
         }
         let scheduled = 0;
         let failed = 0;
@@ -4048,7 +4165,8 @@ Created with Social Neuron`;
         }
         const chunk = (arr, size) => {
           const out = [];
-          for (let i = 0; i < arr.length; i += size) out.push(arr.slice(i, i + size));
+          for (let i = 0; i < arr.length; i += size)
+            out.push(arr.slice(i, i + size));
           return out;
         };
         const platformBatches = Array.from(grouped.entries()).map(
@@ -4056,7 +4174,9 @@ Created with Social Neuron`;
             const platformResults = [];
             const batches = chunk(platformPosts, batch_size);
             for (const batch of batches) {
-              const settled = await Promise.allSettled(batch.map((post) => scheduleOne(post)));
+              const settled = await Promise.allSettled(
+                batch.map((post) => scheduleOne(post))
+              );
               for (const outcome of settled) {
                 if (outcome.status === "fulfilled") {
                   platformResults.push(outcome.value);
@@ -4109,7 +4229,11 @@ Created with Social Neuron`;
                     plan_id: effectivePlanId,
                     approvals: approvalSummary,
                     posts: results,
-                    summary: { total_posts: workingPlan.posts.length, scheduled, failed }
+                    summary: {
+                      total_posts: workingPlan.posts.length,
+                      scheduled,
+                      failed
+                    }
                   }),
                   null,
                   2
@@ -4140,7 +4264,12 @@ Created with Social Neuron`;
       } catch (err) {
         const message = sanitizeError(err);
         return {
-          content: [{ type: "text", text: `Batch scheduling failed: ${message}` }],
+          content: [
+            {
+              type: "text",
+              text: `Batch scheduling failed: ${message}`
+            }
+          ],
           isError: true
         };
       }
@@ -14043,15 +14172,12 @@ function wrapToolWithScanner(toolName, handler) {
         ctx?.logScan?.(toolName, "input", inputScan);
       } catch {
       }
-      return {
-        content: [
-          {
-            type: "text",
-            text: `harness:input_blocked patterns=${inputScan.flagged_patterns.join(",")}`
-          }
-        ],
-        isError: true
-      };
+      return toolError("policy_block", "Request blocked by the input safety policy.", {
+        details: { blocked_patterns: inputScan.flagged_patterns },
+        recover_with: [
+          "Remove instruction-like or unsafe phrasing from the input and retry."
+        ]
+      });
     }
     const result = await handler(...handlerArgs);
     const outputText = JSON.stringify(result);
@@ -14134,34 +14260,34 @@ function applyScopeEnforcement(server, scopeResolver) {
   }
 }
 function scopeDeniedResult(name, requiredScope, userScopes) {
-  const error = requiredScope ? {
-    error: "permission_denied",
-    tool: name,
-    required_scope: requiredScope,
-    available_scopes: userScopes,
-    recover_with: [
-      "Call search_tools with available_only=true to find tools this key can use.",
-      "Use a read-only alternative if one is available for the task.",
-      "Regenerate the API key with the required scope or upgrade the plan tier."
-    ],
-    developer_url: "https://socialneuron.com/settings/developer"
-  } : {
-    error: "tool_scope_missing",
-    tool: name,
-    available_scopes: userScopes,
-    recover_with: ["Contact support; this tool is not mapped to a required scope."]
-  };
   const challenge = requiredScope ? buildWwwAuthenticateHeader({
     issuerUrl: getChallengeIssuerUrl(),
     error: "insufficient_scope",
     errorDescription: `Tool ${name} requires scope ${requiredScope}.`,
     scope: requiredScope
   }) : void 0;
-  return {
-    content: [{ type: "text", text: JSON.stringify(error, null, 2) }],
-    ...challenge ? { _meta: { "mcp/www_authenticate": [challenge] } } : {},
-    isError: true
-  };
+  if (requiredScope) {
+    return toolError("permission_denied", `Tool ${name} requires scope ${requiredScope}.`, {
+      details: {
+        // Preserve the pre-#188 field names for existing clients that branch on them.
+        error: "permission_denied",
+        tool: name,
+        required_scope: requiredScope,
+        available_scopes: userScopes,
+        developer_url: "https://socialneuron.com/settings/developer"
+      },
+      recover_with: [
+        "Call search_tools with available_only=true to find tools this key can use.",
+        "Use a read-only alternative if one is available for the task.",
+        "Regenerate the API key with the required scope or upgrade the plan tier."
+      ],
+      ...challenge ? { meta: { "mcp/www_authenticate": [challenge] } } : {}
+    });
+  }
+  return toolError("server_error", `Tool ${name} is not mapped to a required scope.`, {
+    details: { error: "tool_scope_missing", tool: name, available_scopes: userScopes },
+    recover_with: ["Contact support; this tool is not mapped to a required scope."]
+  });
 }
 function getChallengeIssuerUrl() {
   if (process.env.OAUTH_ISSUER_URL) return process.env.OAUTH_ISSUER_URL;
@@ -14614,10 +14740,20 @@ function registerResources(server) {
         tiers: {
           free: {
             price: "$0/mo",
-            credits: 100,
+            credits: 50,
             mcp_access: "None",
             features: ["5 free tools", "Basic content generation"]
           },
+          trial: {
+            price: "$0 (14 days)",
+            credits: 300,
+            mcp_access: "Full engine (read + write + distribute + analytics), 15 rpm",
+            features: [
+              "Full MCP agent engine for 14 days",
+              "One-time 300 credits",
+              "Generate, gate, and publish via MCP"
+            ]
+          },
           starter: {
             price: "$19/mo",
             credits: 500,
@@ -14742,6 +14878,265 @@ function registerResources(server) {
 // src/http.ts
 init_request_context();
 
+// src/lib/discovery-catalog.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+var cached = null;
+function buildDiscoveryCatalog() {
+  if (!cached) cached = computeDiscoveryCatalog();
+  return cached;
+}
+async function computeDiscoveryCatalog() {
+  const schemaByName = /* @__PURE__ */ new Map();
+  try {
+    const probe = new McpServer({ name: "discovery-probe", version: MCP_VERSION });
+    registerAllTools(probe, { skipScreenshots: true });
+    const handlers = probe.server._requestHandlers;
+    const listHandler = handlers.get("tools/list");
+    if (listHandler) {
+      const out = await listHandler({ method: "tools/list", params: {} }, {});
+      for (const t of out.tools) {
+        const props = t.inputSchema?.properties;
+        if (props && Object.keys(props).length > 0) {
+          schemaByName.set(t.name, {
+            type: "object",
+            properties: props,
+            ...t.inputSchema?.required ? { required: t.inputSchema.required } : {}
+          });
+        }
+      }
+    }
+  } catch (err) {
+    console.error(
+      "[mcp] discovery schema build failed; serving names-only catalog:",
+      err?.message
+    );
+  }
+  return TOOL_CATALOG.filter((t) => !t.localOnly && !t.internal).map((t) => ({
+    name: t.name,
+    description: t.description,
+    inputSchema: schemaByName.get(t.name) ?? { type: "object", properties: {} }
+  }));
+}
+
+// src/lib/openapi.ts
+var SERVER_URL = process.env.MCP_SERVER_URL ? `${process.env.MCP_SERVER_URL.replace(/\/$/, "")}/v1` : "https://mcp.socialneuron.com/v1";
+var TOOL_ERROR_SCHEMA = {
+  type: "object",
+  required: ["error"],
+  properties: {
+    error: {
+      type: "object",
+      required: ["error_type", "message"],
+      properties: {
+        error_type: {
+          type: "string",
+          enum: [
+            "policy_block",
+            "validation_error",
+            "permission_denied",
+            "billing_error",
+            "rate_limited",
+            "not_found",
+            "upstream_error",
+            "server_error"
+          ],
+          description: "Machine-readable error classification."
+        },
+        message: { type: "string" },
+        recover_with: { type: "array", items: { type: "string" } }
+      },
+      additionalProperties: true
+    }
+  }
+};
+var TOOL_RESULT_SCHEMA = {
+  type: "object",
+  description: "MCP CallToolResult. `content` carries text/structured blocks; `structuredContent` is present when the tool declares structured output.",
+  properties: {
+    content: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          type: { type: "string" },
+          text: { type: "string" }
+        },
+        additionalProperties: true
+      }
+    },
+    structuredContent: { type: "object", additionalProperties: true },
+    isError: { type: "boolean" }
+  }
+};
+var ERROR_RESPONSE = (description) => ({
+  description,
+  content: { "application/json": { schema: { $ref: "#/components/schemas/ToolError" } } }
+});
+var cached2 = null;
+function buildOpenApiDocument() {
+  if (!cached2) cached2 = computeOpenApiDocument();
+  return cached2;
+}
+async function computeOpenApiDocument() {
+  const discovery = await buildDiscoveryCatalog();
+  const schemaByName = new Map(discovery.map((t) => [t.name, t.inputSchema]));
+  const publicTools = TOOL_CATALOG.filter((t) => !t.localOnly && !t.internal);
+  const paths = {};
+  for (const tool of publicTools) {
+    const scope = TOOL_SCOPES[tool.name];
+    const inputSchema = schemaByName.get(tool.name) ?? {
+      type: "object",
+      properties: {}
+    };
+    paths[`/tools/${tool.name}`] = {
+      post: {
+        operationId: tool.name,
+        summary: tool.description,
+        tags: [tool.module],
+        ...scope ? { "x-required-scope": scope } : {},
+        security: [{ bearerAuth: [] }],
+        requestBody: {
+          required: Object.keys(inputSchema.properties ?? {}).length > 0,
+          content: { "application/json": { schema: inputSchema } }
+        },
+        responses: {
+          "200": {
+            description: "Tool executed. `isError:true` in the body indicates a tool-level error.",
+            content: {
+              "application/json": { schema: { $ref: "#/components/schemas/ToolResult" } }
+            }
+          },
+          "400": ERROR_RESPONSE("Validation error or policy block."),
+          "401": { description: "Missing or invalid bearer token." },
+          "402": ERROR_RESPONSE("Billing error (insufficient credits)."),
+          "403": ERROR_RESPONSE("Insufficient scope for this tool."),
+          "404": ERROR_RESPONSE("Referenced object not found."),
+          "429": ERROR_RESPONSE("Rate limit exceeded.")
+        }
+      }
+    };
+  }
+  return {
+    openapi: "3.1.0",
+    info: {
+      title: "Social Neuron REST API",
+      version: MCP_VERSION,
+      description: "REST projection of the Social Neuron MCP tool catalog. Every tool is callable as `POST /v1/tools/{name}` with the same auth, scopes, rate limits, and credit pool as the hosted MCP endpoint. Generated from the tool catalog \u2014 never hand-edited.",
+      license: { name: "MIT" }
+    },
+    servers: [{ url: SERVER_URL }],
+    security: [{ bearerAuth: [] }],
+    tags: [...new Set(publicTools.map((t) => t.module))].sort().map((m) => ({ name: m })),
+    paths,
+    components: {
+      securitySchemes: {
+        bearerAuth: {
+          type: "http",
+          scheme: "bearer",
+          description: 'Social Neuron API key (`snk_live_\u2026`) or OAuth access token. Scopes are derived from the plan tier; a 403 with `error_type:"permission_denied"` signals an upgrade is needed.'
+        }
+      },
+      schemas: {
+        ToolResult: TOOL_RESULT_SCHEMA,
+        ToolError: TOOL_ERROR_SCHEMA
+      }
+    }
+  };
+}
+
+// src/lib/rest-invoke.ts
+import { McpServer as McpServer2 } from "@modelcontextprotocol/sdk/server/mcp.js";
+init_request_context();
+var cachedCallHandler;
+function getCallHandler() {
+  if (cachedCallHandler !== void 0) return cachedCallHandler;
+  try {
+    const server = new McpServer2({ name: "socialneuron-rest", version: MCP_VERSION });
+    applyScopeEnforcement(server, () => getRequestScopes() ?? []);
+    registerAllTools(server, { skipScreenshots: true });
+    const handlers = server.server._requestHandlers;
+    cachedCallHandler = handlers.get("tools/call") ?? null;
+  } catch (err) {
+    console.error("[rest] failed to build REST invocation server:", err?.message);
+    cachedCallHandler = null;
+  }
+  return cachedCallHandler;
+}
+function restToolNames() {
+  return new Set(TOOL_CATALOG.filter((t) => !t.localOnly && !t.internal).map((t) => t.name));
+}
+async function invokeToolRest(name, args) {
+  const handler = getCallHandler();
+  if (!handler) {
+    return {
+      isError: true,
+      structuredContent: {
+        error: { error_type: "server_error", message: "REST invocation is unavailable." }
+      },
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            error_type: "server_error",
+            message: "REST invocation is unavailable."
+          })
+        }
+      ]
+    };
+  }
+  return handler({ method: "tools/call", params: { name, arguments: args ?? {} } }, {});
+}
+var KNOWN_ERROR_TYPES = /* @__PURE__ */ new Set([
+  "policy_block",
+  "validation_error",
+  "permission_denied",
+  "billing_error",
+  "rate_limited",
+  "not_found",
+  "upstream_error",
+  "server_error"
+]);
+function extractRestError(result) {
+  const sc = result.structuredContent?.error;
+  if (sc?.error_type && KNOWN_ERROR_TYPES.has(sc.error_type)) {
+    return { error_type: sc.error_type, message: sc.message ?? "Tool error." };
+  }
+  const text = result.content?.find((c) => c.type === "text")?.text ?? "";
+  try {
+    const parsed = JSON.parse(text);
+    if (parsed.error_type && KNOWN_ERROR_TYPES.has(parsed.error_type)) {
+      return { error_type: parsed.error_type, message: parsed.message ?? text };
+    }
+  } catch {
+  }
+  if (/-32602|Input validation error|Invalid arguments/i.test(text)) {
+    return { error_type: "validation_error", message: "Invalid arguments for this tool." };
+  }
+  return { error_type: "server_error", message: text || "Tool error." };
+}
+function httpStatusForResult(result) {
+  if (!result.isError) return 200;
+  switch (extractRestError(result).error_type) {
+    case "validation_error":
+    case "policy_block":
+      return 400;
+    case "billing_error":
+      return 402;
+    case "permission_denied":
+      return 403;
+    case "not_found":
+      return 404;
+    case "rate_limited":
+      return 429;
+    case "upstream_error":
+      return 502;
+    case "server_error":
+      return 500;
+    default:
+      return 400;
+  }
+}
+
 // src/lib/token-verifier.ts
 import { createHash as createHash3 } from "node:crypto";
 import * as jose from "jose";
@@ -14764,15 +15159,15 @@ function evictFromCache(token) {
 }
 async function verifyCachedOpaqueToken(token, validate, ttlMs) {
   const key = cacheKey(token);
-  const cached2 = tokenValidationCache.get(key);
+  const cached3 = tokenValidationCache.get(key);
   const now = Date.now();
-  if (cached2 && cached2.expiresAt > now) {
-    const tokenExpiresAtMs2 = cached2.authInfo.expiresAt ? cached2.authInfo.expiresAt * 1e3 : void 0;
+  if (cached3 && cached3.expiresAt > now) {
+    const tokenExpiresAtMs2 = cached3.authInfo.expiresAt ? cached3.authInfo.expiresAt * 1e3 : void 0;
     if (!tokenExpiresAtMs2 || tokenExpiresAtMs2 > now) {
-      return cached2.authInfo;
+      return cached3.authInfo;
     }
   }
-  if (cached2) tokenValidationCache.delete(key);
+  if (cached3) tokenValidationCache.delete(key);
   const authInfo = await validate();
   const tokenExpiresAtMs = authInfo.expiresAt ? authInfo.expiresAt * 1e3 : void 0;
   const cacheExpiresAt = Math.min(Date.now() + ttlMs, tokenExpiresAtMs ?? Number.POSITIVE_INFINITY);
@@ -15068,8 +15463,8 @@ function createClientsStore() {
   }
   return {
     async getClient(clientId) {
-      const cached2 = cache.get(clientId);
-      if (cached2) return cached2;
+      const cached3 = cache.get(clientId);
+      if (cached3) return cached3;
       if (!supabaseAvailable) return void 0;
       try {
         const supabase = getSupabaseClient();
@@ -15307,46 +15702,6 @@ function createOAuthProvider(options) {
 // src/http.ts
 init_posthog();
 
-// src/lib/discovery-catalog.ts
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-var cached = null;
-function buildDiscoveryCatalog() {
-  if (!cached) cached = computeDiscoveryCatalog();
-  return cached;
-}
-async function computeDiscoveryCatalog() {
-  const schemaByName = /* @__PURE__ */ new Map();
-  try {
-    const probe = new McpServer({ name: "discovery-probe", version: MCP_VERSION });
-    registerAllTools(probe, { skipScreenshots: true });
-    const handlers = probe.server._requestHandlers;
-    const listHandler = handlers.get("tools/list");
-    if (listHandler) {
-      const out = await listHandler({ method: "tools/list", params: {} }, {});
-      for (const t of out.tools) {
-        const props = t.inputSchema?.properties;
-        if (props && Object.keys(props).length > 0) {
-          schemaByName.set(t.name, {
-            type: "object",
-            properties: props,
-            ...t.inputSchema?.required ? { required: t.inputSchema.required } : {}
-          });
-        }
-      }
-    }
-  } catch (err) {
-    console.error(
-      "[mcp] discovery schema build failed; serving names-only catalog:",
-      err?.message
-    );
-  }
-  return TOOL_CATALOG.filter((t) => !t.localOnly && !t.internal).map((t) => ({
-    name: t.name,
-    description: t.description,
-    inputSchema: schemaByName.get(t.name) ?? { type: "object", properties: {} }
-  }));
-}
-
 // src/lib/origin-policy.ts
 var PRODUCTION_FALLBACK_ORIGINS = [
   "https://socialneuron.com",
@@ -15519,7 +15874,10 @@ app.use((req, res, next) => {
     ipBuckets.set(ip, bucket);
   }
   const elapsed = (now - bucket.lastRefill) / 1e3;
-  bucket.tokens = Math.min(IP_RATE_MAX, bucket.tokens + elapsed * IP_RATE_REFILL);
+  bucket.tokens = Math.min(
+    IP_RATE_MAX,
+    bucket.tokens + elapsed * IP_RATE_REFILL
+  );
   bucket.lastRefill = now;
   if (bucket.tokens < 1) {
     const retryAfter = Math.ceil((1 - bucket.tokens) / IP_RATE_REFILL);
@@ -15535,7 +15893,10 @@ app.use((req, res, next) => {
   next();
 });
 app.use((_req, res, next) => {
-  res.setHeader("Strict-Transport-Security", "max-age=63072000; includeSubDomains");
+  res.setHeader(
+    "Strict-Transport-Security",
+    "max-age=63072000; includeSubDomains"
+  );
   res.setHeader("X-Content-Type-Options", "nosniff");
   next();
 });
@@ -15557,7 +15918,10 @@ app.use((req, res, next) => {
     "Access-Control-Allow-Headers",
     "Content-Type, Authorization, Mcp-Session-Id, MCP-Protocol-Version"
   );
-  res.setHeader("Access-Control-Expose-Headers", "Mcp-Session-Id, WWW-Authenticate");
+  res.setHeader(
+    "Access-Control-Expose-Headers",
+    "Mcp-Session-Id, WWW-Authenticate"
+  );
   if (req.method === "OPTIONS") {
     res.status(204).end();
     return;
@@ -15636,7 +16000,10 @@ app.use((req, res, next) => {
 async function authenticateRequest(req, res, next) {
   const authHeader = req.headers.authorization;
   if (!authHeader?.startsWith("Bearer ")) {
-    res.setHeader("WWW-Authenticate", buildWwwAuthenticateHeader({ issuerUrl: OAUTH_ISSUER_URL }));
+    res.setHeader(
+      "WWW-Authenticate",
+      buildWwwAuthenticateHeader({ issuerUrl: OAUTH_ISSUER_URL })
+    );
     res.status(401).end();
     return;
   }
@@ -15756,50 +16123,131 @@ app.get("/config", (_req, res) => {
 app.get("/health", (_req, res) => {
   res.json({ status: "ok", version: MCP_VERSION });
 });
-app.get("/health/details", authenticateRequest, (_req, res) => {
-  res.json({
-    status: "ok",
-    version: MCP_VERSION,
-    transport: "streamable-http",
-    sessions: sessions.size,
-    sessionCap: MAX_SESSIONS,
-    uptime: Math.floor(process.uptime()),
-    memory: Math.round(process.memoryUsage().rss / 1024 / 1024),
-    env: NODE_ENV
-  });
+app.get(
+  "/health/details",
+  authenticateRequest,
+  (_req, res) => {
+    res.json({
+      status: "ok",
+      version: MCP_VERSION,
+      transport: "streamable-http",
+      sessions: sessions.size,
+      sessionCap: MAX_SESSIONS,
+      uptime: Math.floor(process.uptime()),
+      memory: Math.round(process.memoryUsage().rss / 1024 / 1024),
+      env: NODE_ENV
+    });
+  }
+);
+app.get("/v1/openapi.json", async (_req, res) => {
+  try {
+    const doc = await buildOpenApiDocument();
+    res.setHeader("Cache-Control", "public, max-age=3600");
+    res.json(doc);
+  } catch (err) {
+    res.status(500).json({ error: "openapi_unavailable", message: sanitizeError(err) });
+  }
 });
-app.post("/mcp", (req, res, next) => {
-  const body = req.body;
-  if (body?.jsonrpc !== "2.0") return next();
-  if (body.method === "tools/list") {
-    const hasBearer = req.headers.authorization?.startsWith("Bearer ");
-    if (hasBearer) {
-      next();
-      return;
+app.get("/v1/tools", authenticateRequest, (req, res) => {
+  const scopes = req.auth.scopes;
+  const tools = TOOL_CATALOG.filter((t) => !t.localOnly && !t.internal).map(
+    (t) => {
+      const scope = TOOL_SCOPES[t.name];
+      return {
+        name: t.name,
+        description: t.description,
+        module: t.module,
+        scope,
+        available: scope ? hasScope(scopes, scope) : false
+      };
     }
-    buildDiscoveryCatalog().then((tools) => {
-      res.json({ jsonrpc: "2.0", id: body.id ?? null, result: { tools } });
-    }).catch(() => {
-      res.json({
-        jsonrpc: "2.0",
-        id: body.id ?? null,
-        result: {
-          tools: TOOL_CATALOG.map((t) => ({
-            name: t.name,
-            description: t.description,
-            inputSchema: { type: "object", properties: {} }
-          }))
+  );
+  res.json({ tools, count: tools.length });
+});
+app.post(
+  "/v1/tools/:name",
+  authenticateRequest,
+  authenticatedMcpJsonParser,
+  async (req, res) => {
+    const auth = req.auth;
+    const name = String(req.params.name);
+    if (!restToolNames().has(name)) {
+      res.status(404).json({
+        error: {
+          error_type: "not_found",
+          message: `No REST tool named '${name}'.`
         }
       });
-    });
-    return;
+      return;
+    }
+    const rl = checkRateLimit("read", `rest:${auth.userId}`);
+    if (!rl.allowed) {
+      res.setHeader("Retry-After", String(rl.retryAfter));
+      res.status(429).json({
+        error: { error_type: "rate_limited", message: "Too many requests." }
+      });
+      return;
+    }
+    const args = req.body && typeof req.body === "object" ? req.body : {};
+    try {
+      const result = await requestContext.run(
+        {
+          userId: auth.userId,
+          scopes: auth.scopes,
+          token: auth.token,
+          creditsUsed: 0,
+          assetsGenerated: 0
+        },
+        () => invokeToolRest(name, args)
+      );
+      const status = httpStatusForResult(result);
+      if (result.isError) {
+        res.status(status).json({ error: extractRestError(result), isError: true });
+      } else {
+        res.status(status).json(result);
+      }
+    } catch (err) {
+      res.status(500).json({
+        error: { error_type: "server_error", message: sanitizeError(err) }
+      });
+    }
   }
-  if (req.auth) {
-    next();
-    return;
+);
+app.post(
+  "/mcp",
+  (req, res, next) => {
+    const body = req.body;
+    if (body?.jsonrpc !== "2.0") return next();
+    if (body.method === "tools/list") {
+      const hasBearer = req.headers.authorization?.startsWith("Bearer ");
+      if (hasBearer) {
+        next();
+        return;
+      }
+      buildDiscoveryCatalog().then((tools) => {
+        res.json({ jsonrpc: "2.0", id: body.id ?? null, result: { tools } });
+      }).catch(() => {
+        res.json({
+          jsonrpc: "2.0",
+          id: body.id ?? null,
+          result: {
+            tools: TOOL_CATALOG.map((t) => ({
+              name: t.name,
+              description: t.description,
+              inputSchema: { type: "object", properties: {} }
+            }))
+          }
+        });
+      });
+      return;
+    }
+    if (req.auth) {
+      next();
+      return;
+    }
+    authenticateRequest(req, res, next);
   }
-  authenticateRequest(req, res, next);
-});
+);
 app.post("/mcp", async (req, res) => {
   const auth = req.auth;
   const existingSessionId = req.headers["mcp-session-id"];
@@ -15850,7 +16298,7 @@ app.post("/mcp", async (req, res) => {
       });
       return;
     }
-    const server = new McpServer2({
+    const server = new McpServer3({
       name: "socialneuron",
       version: MCP_VERSION
     });
@@ -15889,7 +16337,10 @@ app.post("/mcp", async (req, res) => {
     const rawMessage = err instanceof Error ? err.message : "Internal server error";
     console.error(`[MCP HTTP] POST /mcp error: ${rawMessage}`);
     if (!res.headersSent) {
-      res.status(500).json({ jsonrpc: "2.0", error: { code: -32603, message: sanitizeError(err) } });
+      res.status(500).json({
+        jsonrpc: "2.0",
+        error: { code: -32603, message: sanitizeError(err) }
+      });
     }
   }
 });
@@ -15918,38 +16369,49 @@ app.get("/mcp", authenticateRequest, async (req, res) => {
     () => entry.transport.handleRequest(req, res)
   );
 });
-app.delete("/mcp", authenticateRequest, async (req, res) => {
-  const sessionId = req.headers["mcp-session-id"];
-  if (!sessionId || !sessions.has(sessionId)) {
-    res.status(400).json({ error: "Invalid or missing session ID" });
-    return;
-  }
-  const entry = sessions.get(sessionId);
-  if (entry.userId !== req.auth.userId) {
-    res.status(403).json({ error: "Session belongs to another user" });
-    return;
+app.delete(
+  "/mcp",
+  authenticateRequest,
+  async (req, res) => {
+    const sessionId = req.headers["mcp-session-id"];
+    if (!sessionId || !sessions.has(sessionId)) {
+      res.status(400).json({ error: "Invalid or missing session ID" });
+      return;
+    }
+    const entry = sessions.get(sessionId);
+    if (entry.userId !== req.auth.userId) {
+      res.status(403).json({ error: "Session belongs to another user" });
+      return;
+    }
+    await entry.transport.close();
+    await entry.server.close();
+    sessions.delete(sessionId);
+    res.status(200).json({ status: "session_closed" });
   }
-  await entry.transport.close();
-  await entry.server.close();
-  sessions.delete(sessionId);
-  res.status(200).json({ status: "session_closed" });
-});
-app.use((err, _req, res, _next) => {
-  console.error("[MCP HTTP] Unhandled Express error:", err.stack || err.message || err);
-  if (res.headersSent) return;
-  const e = err;
-  const status = e.status ?? e.statusCode;
-  if (status === 413 || e.type === "entity.too.large") {
-    res.status(413).json({
-      error: "payload_too_large",
-      error_description: "Request body exceeds the allowed JSON limit."
-    });
-    return;
+);
+app.use(
+  (err, _req, res, _next) => {
+    console.error(
+      "[MCP HTTP] Unhandled Express error:",
+      err.stack || err.message || err
+    );
+    if (res.headersSent) return;
+    const e = err;
+    const status = e.status ?? e.statusCode;
+    if (status === 413 || e.type === "entity.too.large") {
+      res.status(413).json({
+        error: "payload_too_large",
+        error_description: "Request body exceeds the allowed JSON limit."
+      });
+      return;
+    }
+    res.status(500).json({ error: "internal_error", error_description: sanitizeError(err) });
   }
-  res.status(500).json({ error: "internal_error", error_description: sanitizeError(err) });
-});
+);
 var httpServer = app.listen(PORT, "0.0.0.0", () => {
-  console.log(`[MCP HTTP] Social Neuron MCP Server listening on 0.0.0.0:${PORT}`);
+  console.log(
+    `[MCP HTTP] Social Neuron MCP Server listening on 0.0.0.0:${PORT}`
+  );
   console.log(`[MCP HTTP] Health: http://localhost:${PORT}/health`);
   console.log(`[MCP HTTP] MCP endpoint: ${MCP_SERVER_URL}`);
   console.log(`[MCP HTTP] Environment: ${NODE_ENV}`);