ranla-mcp 0.7.0 → 0.8.3

package/dist/index.js

@@ -262,7 +262,7 @@ import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprot
 import { SuperSendTX } from "@supersend/ranla";
 
 // package.json
-var version = "0.7.0";
+var version = "0.8.3";
 
 // src/annotations.ts
 var READ = { readOnlyHint: true, destructiveHint: false, openWorldHint: false };
@@ -297,25 +297,25 @@ var FIXED_TOOL_HINTS = {
   publish_template: WRITE,
   send_test_webhook_event: { ...WRITE, ...OUT },
   get_deliverability: READ,
-  arc_list_threads: { ...READ, title: "List Ranla threads" },
-  arc_get_thread: { ...READ, title: "Read a Ranla thread" },
-  arc_ensure_thread: { ...WRITE, title: "Open a Ranla thread", idempotentHint: true },
+  ranla_list_threads: { ...READ, title: "List Ranla threads" },
+  ranla_get_thread: { ...READ, title: "Read a Ranla thread" },
+  ranla_open_thread: { ...WRITE, title: "Open a Ranla thread", idempotentHint: true },
   /**
    * Ranla researches the web, and a turn can delete or overwrite workspace
    * records. What reaches people or spends stops at an approval.
    */
-  arc_message: { ...DELETE, ...OUT, title: "Message Ranla" },
+  ranla_message: { ...DELETE, ...OUT, title: "Message Ranla" },
   /** Commands include deletes (`campaign delete`, `contact delete`); what reaches people or spends stops at an approval. */
-  arc_ranla: { ...DELETE, ...OUT, title: "Run a Ranla command" },
-  arc_list_approvals: { ...READ, title: "List pending approvals" },
+  ranla_command: { ...DELETE, ...OUT, title: "Run a Ranla command" },
+  ranla_list_approvals: { ...READ, title: "List pending approvals" },
   /** Approving can send email to real people or publish, which can't be undone. */
-  arc_approve: { ...DELETE, ...OUT, title: "Approve a Ranla step" },
+  ranla_approve: { ...DELETE, ...OUT, title: "Approve a Ranla step" },
   /** Rejecting discards the proposal. */
-  arc_reject: { ...DELETE, title: "Reject a Ranla step" }
+  ranla_reject: { ...DELETE, title: "Reject a Ranla step" }
 };
 var UPPER = /* @__PURE__ */ new Set(["ai", "aeo", "api", "dns", "id", "seo", "url"]);
 function titleFromToolName(name) {
-  const words = name.replace(/^arc_/, "").split("_").filter(Boolean);
+  const words = name.replace(/^(?:ranla|arc)_/, "").split("_").filter(Boolean);
   return words.map((word, index) => {
     if (UPPER.has(word)) return word.toUpperCase();
     return index === 0 ? word.charAt(0).toUpperCase() + word.slice(1) : word;
@@ -374,8 +374,8 @@ function openObjectSchema(description) {
   };
 }
 var RANLA_AGENT_NAME = "Ranla";
-var RANLA_COMMAND_TOOL_NAME = "arc_ranla";
-var RANLA_COMMAND_INTRO = `Run one of ${RANLA_AGENT_NAME}'s commands in this account. command is "<noun> <verb>", such as "campaign list" or "page propose", and input holds its fields. "help <noun>" lists a noun's commands with every field. A command that needs sign-off does nothing yet: it comes back with pendingApproval, and arc_approve with its messageId applies it. For strategy, or anything that needs ${RANLA_AGENT_NAME}'s judgement or research, use arc_message.`;
+var RANLA_COMMAND_TOOL_NAME = "ranla_command";
+var RANLA_COMMAND_INTRO = `Run one of ${RANLA_AGENT_NAME}'s commands in this account. command is "<noun> <verb>", such as "campaign list" or "page propose", and input holds its fields. "help <noun>" lists a noun's commands with every field. A command that needs sign-off does nothing yet: it comes back with pendingApproval, and ranla_approve with its messageId applies it. For strategy, or anything that needs ${RANLA_AGENT_NAME}'s judgement or research, use ranla_message.`;
 function ranlaCommandTool(index) {
   return {
     name: RANLA_COMMAND_TOOL_NAME,
@@ -388,7 +388,7 @@ ${index}` : RANLA_COMMAND_INTRO,
       properties: {
         command: { type: "string", description: '"<noun> <verb>", or "help <noun>".' },
         input: { type: "object", description: "The command's fields.", additionalProperties: true },
-        threadId: { type: "string", description: "Ranla thread to record it in (from arc_ensure_thread). Optional." }
+        threadId: { type: "string", description: "Ranla thread to record it in (from ranla_open_thread). Optional." }
       },
       required: ["command"]
     },
@@ -397,8 +397,8 @@ ${index}` : RANLA_COMMAND_INTRO,
 }
 var META_TOOLS = [
   {
-    name: "arc_list_threads",
-    description: "List Ranla chat threads for this account, most recent first: id, title, desk, last activity and a one-line preview. Pass nextBefore as before for older threads. Read one with arc_get_thread.",
+    name: "ranla_list_threads",
+    description: "List Ranla chat threads for this account, most recent first: id, title, desk, last activity and a one-line preview. Pass nextBefore as before for older threads. Read one with ranla_get_thread.",
     inputSchema: {
       type: "object",
       properties: {
@@ -412,12 +412,12 @@ var META_TOOLS = [
     kind: "meta"
   },
   {
-    name: "arc_get_thread",
-    description: "Read a Ranla thread: its messages (role, text, tools used, artifacts by id, approvals waiting on arc_approve), newest page first. Pass earlierBefore as before for older messages.",
+    name: "ranla_get_thread",
+    description: "Read a Ranla thread: its messages (role, text, tools used, artifacts by id, approvals waiting on ranla_approve), newest page first. Pass earlierBefore as before for older messages.",
     inputSchema: {
       type: "object",
       properties: {
-        threadId: { type: "string", description: "From arc_list_threads or arc_ensure_thread." },
+        threadId: { type: "string", description: "From ranla_list_threads or ranla_open_thread." },
         before: {
           type: "string",
           description: "ISO timestamp from earlierBefore: the page of messages older than it."
@@ -428,7 +428,7 @@ var META_TOOLS = [
     kind: "meta"
   },
   {
-    name: "arc_ensure_thread",
+    name: "ranla_open_thread",
     description: "Find or create a durable Ranla thread for MCP (default title \u201CMCP\u201D). Returns { threadId, title }.",
     inputSchema: {
       type: "object",
@@ -440,43 +440,49 @@ var META_TOOLS = [
     kind: "meta"
   },
   {
-    name: "arc_message",
-    description: "Send a message to Ranla and wait for the turn. Use for strategy and anything that changes the account. Returns text, artifacts (drafts, plans, and documents it made or opened, by id), and pendingApproval when a step needs approval. Long research turns are followed to the end; one still going after 15 minutes comes back with running: true, and arc_get_thread reads the answer later.",
+    name: "ranla_message",
+    description: "Send a message to Ranla and wait for the turn. Use for strategy and anything that changes the account. Returns text, artifacts (drafts, plans, and documents it made or opened, by id), and pendingApproval when a step needs approval. Long research turns are followed to the end; one still going after 15 minutes comes back with running: true, and ranla_get_thread reads the answer later.",
     inputSchema: {
       type: "object",
       properties: {
         text: { type: "string", description: `Message for ${RANLA_AGENT_NAME}` },
-        threadId: { type: "string", description: "Ranla thread id (from arc_ensure_thread)" }
+        threadId: { type: "string", description: "Ranla thread id (from ranla_open_thread)" }
       },
       required: ["text"]
     },
     kind: "meta"
   },
   {
-    name: "arc_list_approvals",
+    name: "ranla_list_approvals",
     description: "List pending Ranla approvals across threads.",
     inputSchema: openObjectSchema(),
     kind: "meta"
   },
   {
-    name: "arc_approve",
+    name: "ranla_approve",
     description: "Approve a pending Ranla approval and resume the run.",
     inputSchema: {
       type: "object",
       properties: {
-        messageId: { type: "string" }
+        messageId: {
+          type: "string",
+          description: "The pending approval's messageId, from ranla_list_approvals or a pendingApproval result"
+        }
       },
       required: ["messageId"]
     },
     kind: "meta"
   },
   {
-    name: "arc_reject",
+    name: "ranla_reject",
     description: "Reject a pending Ranla approval and resume the run.",
     inputSchema: {
       type: "object",
       properties: {
-        messageId: { type: "string" }
+        messageId: {
+          type: "string",
+          description: "The pending approval's messageId, from ranla_list_approvals or a pendingApproval result"
+        }
       },
       required: ["messageId"]
     },
@@ -509,10 +515,24 @@ async function arcFetch(origin, apiKey, path, init = {}) {
   const body = await response.json().catch(() => ({}));
   return { ok: response.ok, status: response.status, body };
 }
-var ARC_TOOL_PREFIX = "arc_";
+var RANLA_TOOL_PREFIX = "ranla_";
+var LEGACY_TOOL_PREFIX = "arc_";
 var CATALOG_TIMEOUT_MS = 4e3;
+var LEGACY_TOOL_NAMES = {
+  arc_message: "ranla_message",
+  arc_ranla: "ranla_command",
+  arc_list_threads: "ranla_list_threads",
+  arc_get_thread: "ranla_get_thread",
+  arc_ensure_thread: "ranla_open_thread",
+  arc_list_approvals: "ranla_list_approvals",
+  arc_approve: "ranla_approve",
+  arc_reject: "ranla_reject"
+};
+function currentToolName(name) {
+  return LEGACY_TOOL_NAMES[name] ?? name;
+}
 function isArcMcpToolName(name) {
-  return name.startsWith(ARC_TOOL_PREFIX);
+  return name.startsWith(RANLA_TOOL_PREFIX) || name.startsWith(LEGACY_TOOL_PREFIX);
 }
 async function fetchCommandIndex(apiKey, baseUrl) {
   try {
@@ -536,7 +556,7 @@ var ARC_MESSAGE_POLL_MS = 2e3;
 var ARC_THREAD_POLL_MS = 5e3;
 var ARC_MESSAGE_REQUEST_TIMEOUT_MS = 11e4;
 var LOST_REQUEST_STATUSES = /* @__PURE__ */ new Set([408, 429, 502, 503, 504, 520, 521, 522, 523, 524]);
-var STILL_RUNNING_NOTE = "Ranla is still working on this. Read the answer with arc_get_thread in a minute or two.";
+var STILL_RUNNING_NOTE = "Ranla is still working on this. Read the answer with ranla_get_thread in a minute or two.";
 var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 function turnFromThread(threadId, messages, extra) {
   const lastFounder = messages.map((message) => message.role).lastIndexOf("user");
@@ -570,8 +590,8 @@ async function followThread(origin, apiKey, threadId, deadline, extra) {
     const response = await arcFetch(origin, apiKey, `/api/growth/threads/${encodeURIComponent(threadId)}`).catch(
       () => null
     );
-    const thread = response?.ok ? response.body.thread : void 0;
-    if (thread && thread.running !== true) {
+    const thread2 = response?.ok ? response.body.thread : void 0;
+    if (thread2 && thread2.running !== true) {
       const messages = Array.isArray(response.body.messages) ? response.body.messages : [];
       return turnFromThread(threadId, messages, extra);
     }
@@ -581,7 +601,7 @@ async function followThread(origin, apiKey, threadId, deadline, extra) {
     await sleep(ARC_THREAD_POLL_MS);
   }
 }
-async function sendArcMessage(origin, apiKey, threadId, text) {
+async function sendArcMessage(origin, apiKey, threadId, text, options = {}) {
   const path = `/api/growth/threads/${encodeURIComponent(threadId)}/messages`;
   const idempotencyKey = randomUUID();
   const deadline = Date.now() + ARC_MESSAGE_MAX_WAIT_MS;
@@ -596,7 +616,7 @@ async function sendArcMessage(origin, apiKey, threadId, text) {
     const response = await arcFetch(origin, apiKey, path, {
       method: "POST",
       headers: { "Idempotency-Key": idempotencyKey },
-      body: JSON.stringify({ text, sync: true }),
+      body: JSON.stringify({ text, sync: true, ...options.askOnly ? { context: { askOnly: true } } : {} }),
       signal: AbortSignal.timeout(ARC_MESSAGE_REQUEST_TIMEOUT_MS)
     }).catch(() => null);
     if (!response || LOST_REQUEST_STATUSES.has(response.status)) {
@@ -631,27 +651,32 @@ function optString(args, key) {
   const value = String(args[key]).trim();
   return value || void 0;
 }
-async function callArcMcpTool(apiKey, name, args, baseUrl) {
+async function runRanlaCommand(apiKey, command, input, baseUrl, threadId) {
+  const origin = resolveArcAppOrigin({ baseUrl, apiKey });
+  const response = await arcFetch(origin, apiKey, "/api/growth/commands", {
+    method: "POST",
+    body: JSON.stringify({ command, input, ...threadId ? { threadId } : {} })
+  });
+  if (!response.ok) {
+    throw new Error(
+      typeof response.body.error === "string" ? response.body.error : `Ranla command failed (${response.status})`
+    );
+  }
+  return response.body;
+}
+async function callArcMcpTool(apiKey, name, args, baseUrl, options = {}) {
   if (!isArcMcpToolName(name)) return null;
+  name = currentToolName(name);
   const origin = resolveArcAppOrigin({ baseUrl, apiKey });
   if (name === RANLA_COMMAND_TOOL_NAME) {
     const command = optString(args, "command");
     if (!command) throw new Error("Missing required argument: command");
     const input = args.input && typeof args.input === "object" && !Array.isArray(args.input) ? args.input : {};
-    const threadId = optString(args, "threadId");
-    const response = await arcFetch(origin, apiKey, "/api/growth/commands", {
-      method: "POST",
-      body: JSON.stringify({ command, input, ...threadId ? { threadId } : {} })
-    });
-    if (!response.ok) {
-      throw new Error(
-        typeof response.body.error === "string" ? response.body.error : `Ranla command failed (${response.status})`
-      );
-    }
-    return response.body;
+    return runRanlaCommand(apiKey, command, input, baseUrl, optString(args, "threadId"));
   }
   if (!META_TOOLS.some((tool) => tool.name === name)) {
-    const growthTool = name.slice(ARC_TOOL_PREFIX.length);
+    if (!name.startsWith(LEGACY_TOOL_PREFIX)) throw new Error(`Unknown tool: ${name}`);
+    const growthTool = name.slice(LEGACY_TOOL_PREFIX.length);
     const response = await arcFetch(origin, apiKey, `/api/growth/tools/${encodeURIComponent(growthTool)}`, {
       method: "POST",
       body: JSON.stringify({ input: args })
@@ -664,7 +689,7 @@ async function callArcMcpTool(apiKey, name, args, baseUrl) {
     return response.body.result ?? response.body;
   }
   switch (name) {
-    case "arc_list_threads": {
+    case "ranla_list_threads": {
       const query = new URLSearchParams();
       const limit = optString(args, "limit");
       const before = optString(args, "before");
@@ -679,7 +704,7 @@ async function callArcMcpTool(apiKey, name, args, baseUrl) {
       }
       return response.body;
     }
-    case "arc_get_thread": {
+    case "ranla_get_thread": {
       const threadId = optString(args, "threadId");
       if (!threadId) throw new Error("Missing required argument: threadId");
       const before = optString(args, "before");
@@ -695,7 +720,7 @@ async function callArcMcpTool(apiKey, name, args, baseUrl) {
       }
       return response.body;
     }
-    case "arc_ensure_thread": {
+    case "ranla_open_thread": {
       const existingId = optString(args, "threadId");
       if (existingId) {
         const byId = await arcFetch(
@@ -704,9 +729,9 @@ async function callArcMcpTool(apiKey, name, args, baseUrl) {
           `/api/growth/threads/${encodeURIComponent(existingId)}`
         );
         if (byId.ok) {
-          const thread2 = byId.body.thread;
-          if (thread2?.id) {
-            return { threadId: thread2.id, title: thread2.title ?? null };
+          const thread3 = byId.body.thread;
+          if (thread3?.id) {
+            return { threadId: thread3.id, title: thread3.title ?? null };
           }
         }
       }
@@ -732,21 +757,21 @@ async function callArcMcpTool(apiKey, name, args, baseUrl) {
           typeof created.body.error === "string" ? created.body.error : `Create thread failed (${created.status})`
         );
       }
-      const thread = created.body.thread;
-      if (!thread?.id) throw new Error("Create thread returned no id");
-      return { threadId: thread.id, title: thread.title ?? title };
+      const thread2 = created.body.thread;
+      if (!thread2?.id) throw new Error("Create thread returned no id");
+      return { threadId: thread2.id, title: thread2.title ?? title };
     }
-    case "arc_message": {
+    case "ranla_message": {
       const text = optString(args, "text");
       if (!text) throw new Error("Missing required argument: text");
       let threadId = optString(args, "threadId");
       if (!threadId) {
-        const ensured = await callArcMcpTool(apiKey, "arc_ensure_thread", {}, baseUrl);
+        const ensured = await callArcMcpTool(apiKey, "ranla_open_thread", {}, baseUrl);
         threadId = ensured.threadId;
       }
-      return sendArcMessage(origin, apiKey, threadId, text);
+      return sendArcMessage(origin, apiKey, threadId, text, options);
     }
-    case "arc_list_approvals": {
+    case "ranla_list_approvals": {
       const response = await arcFetch(origin, apiKey, "/api/growth/approvals");
       if (!response.ok) {
         throw new Error(
@@ -755,11 +780,11 @@ async function callArcMcpTool(apiKey, name, args, baseUrl) {
       }
       return response.body;
     }
-    case "arc_approve":
-    case "arc_reject": {
+    case "ranla_approve":
+    case "ranla_reject": {
       const messageId = optString(args, "messageId");
       if (!messageId) throw new Error("Missing required argument: messageId");
-      const decision = name === "arc_approve" ? "approve" : "reject";
+      const decision = name === "ranla_approve" ? "approve" : "reject";
       const response = await arcFetch(
         origin,
         apiKey,
@@ -781,13 +806,725 @@ async function callArcMcpTool(apiKey, name, args, baseUrl) {
   }
 }
 
-// src/tools.ts
-function textResult(value, isError = false) {
+// src/chatgpt-tools.ts
+var days = (what, fallback) => ({
+  type: "number",
+  description: `${what} window in days. Default ${fallback}.`
+});
+function schema(properties = {}) {
+  return { type: "object", properties, additionalProperties: false };
+}
+var CHATGPT_COMMAND_TOOLS = [
+  {
+    name: "get_setup_status",
+    command: "setup status",
+    description: "What the workspace has connected and what is left: blockers, the next setup step, whether Ranla can draft and send, and whether the site's tracking is in.",
+    inputSchema: schema()
+  },
+  {
+    name: "get_growth_health",
+    command: "growth get",
+    description: 'The funnel for this workspace over a recent window: contacts added, how many activated, and how many paid. Use for "how is growth going".',
+    inputSchema: schema({ days: days("Trailing", "the app default") })
+  },
+  {
+    name: "get_revenue_health",
+    command: "revenue get",
+    description: "Revenue scoreboard: the conversions and revenue Ranla's channels produced (email, paid ads, other), by channel.",
+    inputSchema: schema({ days: days("Trailing", "the app default") })
+  },
+  {
+    name: "list_goals",
+    command: "goal list",
+    description: "The conversion goals this workspace measures: the event, its label, and whether it is active.",
+    inputSchema: schema()
+  },
+  {
+    name: "get_search_performance",
+    command: "seo performance",
+    description: "What Google Search Console reports for the site: clicks, impressions, click-through rate, average position, and the queries and pages that earned the most, including pages Ranla shipped. Defaults to the last 28 days.",
+    inputSchema: schema({
+      from: { type: "string", description: "Start day, YYYY-MM-DD, for a window other than the last 28 days." },
+      to: { type: "string", description: "End day, YYYY-MM-DD. Default: the latest day Google has reported." }
+    })
+  },
+  {
+    name: "list_search_opportunities",
+    command: "seo opportunities",
+    description: "Searches the site could win that Ranla found: the pages it proposes to write, and the ones it decided against with its reasons.",
+    inputSchema: schema({
+      include: {
+        type: "string",
+        enum: ["proposed", "refused", "both"],
+        description: "Which to return. Default both."
+      }
+    })
+  },
+  {
+    name: "get_ai_answer_status",
+    command: "aeo status",
+    description: "How AI answer engines (ChatGPT, Perplexity, Gemini, Claude, Google AI) see the product: the share of answers that name it, its position, sentiment, and the competitors named instead.",
+    inputSchema: schema({ days: { type: "number", description: "The window in days, 1-365. Default 28." } })
+  },
+  {
+    name: "list_ai_answer_questions",
+    command: "aeo-prompt list",
+    description: "The buyer questions tracked for AI answers, each with whether the engines name the product and which competitors they name instead, lowest visibility first.",
+    inputSchema: schema({
+      status: {
+        type: "string",
+        enum: ["active", "suggested", "paused", "all"],
+        description: "Which questions. Default active."
+      },
+      limit: { type: "number", description: "Max questions to return." }
+    })
+  },
+  {
+    name: "list_reddit_threads",
+    command: "reddit-thread list",
+    description: "Reddit threads Ranla found where the product's buyers ask for help, newest and most relevant first, with each thread's status (new, drafted, posted\u2026).",
+    inputSchema: schema({
+      lane: {
+        type: "string",
+        enum: ["fresh", "ranking", "any"],
+        description: "fresh: new threads (default). ranking: threads that rank on Google or show up in AI answers."
+      },
+      status: {
+        type: "string",
+        enum: ["new", "drafted", "approved", "posted", "dismissed", "any"],
+        description: "Default new."
+      },
+      subreddit: { type: "string", description: "Only this subreddit, without r/." }
+    })
+  },
+  {
+    name: "list_reddit_replies",
+    command: "reddit-draft list",
+    description: "Replies and posts Ranla drafted for Reddit, and the ones it posted, with their status.",
+    inputSchema: schema({
+      status: {
+        type: "string",
+        enum: ["draft", "approved", "scheduled", "posted", "rejected", "failed", "any"],
+        description: "Default any."
+      },
+      subreddit: { type: "string", description: "Only this subreddit, without r/." }
+    })
+  },
+  {
+    name: "list_ad_plans",
+    command: "ad-plan list",
+    description: "Search ad campaigns Ranla planned, newest first: waiting for the founder's yes, applied to the ad account, or set aside.",
+    inputSchema: schema({
+      status: {
+        type: "string",
+        enum: ["proposed", "approved", "applied", "failed", "rejected", "all"],
+        description: "proposed (default): waiting for a yes. applied: created in the ad account. all: every plan."
+      },
+      limit: { type: "integer", description: "Max plans to return. Default 20." }
+    })
+  },
+  {
+    name: "list_email_campaigns",
+    command: "campaign list",
+    description: "The workspace's email campaigns with their status, and whether one that is sending has stalled.",
+    inputSchema: schema({
+      status: {
+        type: "string",
+        enum: ["draft", "materializing", "scheduled", "sending", "paused", "sent", "cancelled", "failed"],
+        description: "Only campaigns in this status."
+      },
+      query: { type: "string", description: "Name contains this (case-insensitive)." }
+    })
+  },
+  {
+    name: "get_email_performance",
+    command: "campaign performance",
+    description: "Send results for one email campaign, or across recent ones: sent, delivered, opened, clicked, replies, conversions and revenue.",
+    inputSchema: schema({
+      campaignId: { type: "string", description: "One campaign, from list_email_campaigns. Omit for all campaigns." },
+      days: { type: "integer", description: "Trailing window in days. Default 30." }
+    })
+  }
+];
+var COMMAND_BY_TOOL = new Map(CHATGPT_COMMAND_TOOLS.map((tool) => [tool.name, tool.command]));
+function chatGptCommandFor(name) {
+  return COMMAND_BY_TOOL.get(name);
+}
+var CHATGPT_EXCLUDED_TOOLS = /* @__PURE__ */ new Set([
+  "ranla_message",
+  "ranla_open_thread",
+  "ranla_command",
+  "ranla_approve",
+  "ranla_reject",
+  "create_domain",
+  "apply_domain_dns",
+  "verify_domain"
+]);
+var CHATGPT_WORDING = [
+  ["Pass to ranla_approve or ranla_reject", "Approval id. The founder approves or rejects it in Ranla, at url"],
+  ["The step waiting on ranla_approve. It does nothing until approved.", "The step waiting for the founder's yes in Ranla. It does nothing until approved."],
+  ["Message id; for a pending approval, the messageId ranla_approve takes", "Message id"],
+  ["Pass to ranla_message and ranla_command", "Thread id"],
+  ["From ranla_list_threads or ranla_open_thread.", "From ranla_list_threads."],
+  ["approvals waiting on ranla_approve", "approvals waiting for the founder's yes"]
+];
+function forChatGpt(value) {
+  if (typeof value === "string") {
+    return CHATGPT_WORDING.reduce((text, [from, to]) => text.split(from).join(to), value);
+  }
+  if (Array.isArray(value)) return value.map((item) => forChatGpt(item));
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, forChatGpt(item)]));
+  }
+  return value;
+}
+var CHATGPT_SERVER_INSTRUCTIONS = [
+  "Ranla is an AI growth engineer for a software business: pages that rank on Google, mentions in AI answers, Reddit replies, ads, and the emails that turn sign-ups into customers, plus transactional email from the same workspace.",
+  "To answer a question about growth, search, AI answers, Reddit, ads or email, call the matching read tools (get_growth_health, get_search_performance, list_reddit_threads\u2026) and answer from what they return. Combine several when the question needs it. Every number you quote should come from a tool result.",
+  "These tools read. Ranla does the work in Ranla: when the answer is something to do, say what and tell the founder they can ask Ranla to do it there. What is already waiting for their yes is in ranla_list_approvals, each with the url to approve it in Ranla. Past conversations with Ranla are in ranla_list_threads and ranla_get_thread.",
+  "Use the mail tools (send_email, templates, webhooks, suppressions) only when the user asks about application mail such as receipts or sign-in codes."
+].join("\n\n");
+
+// src/output-schemas.ts
+var str = (description) => ({ type: "string", ...description ? { description } : {} });
+var nullableStr = (description) => ({
+  type: ["string", "null"],
+  ...description ? { description } : {}
+});
+var num = (description) => ({ type: "number", ...description ? { description } : {} });
+var bool = (description) => ({ type: "boolean", ...description ? { description } : {} });
+var nullableBool = (description) => ({
+  type: ["boolean", "null"],
+  ...description ? { description } : {}
+});
+var strList = (description) => ({
+  type: "array",
+  items: { type: "string" },
+  ...description ? { description } : {}
+});
+var listOf = (items, description) => ({
+  type: "array",
+  items,
+  ...description ? { description } : {}
+});
+var object = (properties, required = [], description) => ({
+  type: "object",
+  properties,
+  ...required.length > 0 ? { required } : {},
+  ...description ? { description } : {}
+});
+var openObject = (description) => ({ type: "object", additionalProperties: true, description });
+function output(properties, required, description) {
   return {
-    content: [{ type: "text", text: typeof value === "string" ? value : JSON.stringify(value, null, 2) }],
-    ...isError ? { isError: true } : {}
+    type: "object",
+    properties,
+    ...required.length > 0 ? { required } : {},
+    ...description ? { description } : {}
   };
 }
+function page(key, item, description) {
+  return output(
+    {
+      [key]: listOf(item, description),
+      has_more: bool("True when another page follows"),
+      next_cursor: nullableStr("Pass as cursor for the next page; null on the last page")
+    },
+    [key]
+  );
+}
+var sendResult = output(
+  {
+    id: str("Email id (msg_\u2026)"),
+    status: str("Delivery status, e.g. queued, scheduled, sent, cancelled")
+  },
+  ["id", "status"]
+);
+var email = object(
+  {
+    id: str("Email id (msg_\u2026)"),
+    from: str(),
+    to: strList(),
+    cc: strList(),
+    bcc: strList(),
+    reply_to: strList(),
+    subject: str(),
+    status: str(),
+    last_event: nullableStr("Latest delivery event"),
+    bounce_reason: nullableStr(),
+    tags: { description: "Tags set on the send" },
+    scheduled_at: nullableStr("ISO 8601"),
+    cancelled_at: nullableStr("ISO 8601"),
+    created_at: str("ISO 8601"),
+    sent_at: nullableStr("ISO 8601"),
+    delivered_at: nullableStr("ISO 8601"),
+    bounced_at: nullableStr("ISO 8601")
+  },
+  ["id"]
+);
+var receivedEmail = object(
+  {
+    id: str("Received email id"),
+    domain_id: str(),
+    domain_name: str(),
+    status: str(),
+    rcpt_to: str("Address it was delivered to"),
+    mail_from: nullableStr("Envelope sender"),
+    from: str(),
+    to: strList(),
+    cc: strList(),
+    subject: str(),
+    spam_status: nullableStr(),
+    bounced: bool(),
+    received_with_ssl: nullableBool(),
+    message_id: nullableStr(),
+    in_reply_to: nullableStr(),
+    references: strList(),
+    attachment_count: num(),
+    attachments: listOf(
+      object({
+        filename: str(),
+        content_type: str(),
+        size: num("Bytes"),
+        content_id: nullableStr(),
+        data: str("Base64 content, when included")
+      })
+    ),
+    text_body: nullableStr(),
+    html_body: nullableStr(),
+    auto_submitted: nullableStr(),
+    received_at: str("ISO 8601"),
+    created_at: str("ISO 8601")
+  },
+  ["id"]
+);
+var domain = object(
+  {
+    id: str("Domain id"),
+    name: str("Domain name"),
+    status: str("Verification status"),
+    created_at: str("ISO 8601"),
+    verified_at: nullableStr("ISO 8601"),
+    open_tracking: bool(),
+    click_tracking: bool(),
+    tls_mode: str(),
+    inbound_enabled: bool(),
+    inbound_status: str("disabled, pending, active, or error"),
+    inbound_error: nullableStr()
+  },
+  ["id", "name"]
+);
+var dnsRecord = object(
+  {
+    type: str("Record type: TXT, CNAME, MX\u2026"),
+    host: str(),
+    value: str(),
+    purpose: str("What the record is for, e.g. spf, dkim, dmarc"),
+    priority: num("MX preference")
+  },
+  ["type", "host", "value"]
+);
+var dnsAnalysis = openObject("DMARC and BIMI findings for the domain");
+var domainDnsFields = {
+  domain,
+  records: listOf(dnsRecord, "Sending DNS records to add at the DNS provider"),
+  analysis: dnsAnalysis,
+  inbound_records: listOf(dnsRecord, "Records for inbound receiving"),
+  inbound_note: str(),
+  tracking_dns: object(
+    {
+      required: bool("True when open or click tracking needs its own record"),
+      host: nullableStr(),
+      target: nullableStr(),
+      ok: nullableBool()
+    },
+    [],
+    "The tracking record, when tracking is on"
+  )
+};
+var webhook = object(
+  {
+    id: str("Webhook id"),
+    url: str(),
+    events: strList("Event types delivered"),
+    enabled: bool(),
+    created_at: str("ISO 8601"),
+    updated_at: str("ISO 8601")
+  },
+  ["id", "url"]
+);
+var suppression = object(
+  {
+    id: str("Suppression id"),
+    email: str(),
+    reason: nullableStr(),
+    source: str(),
+    created_at: str("ISO 8601"),
+    updated_at: str("ISO 8601")
+  },
+  ["id", "email"]
+);
+var template = object(
+  {
+    id: str("Template id"),
+    name: str(),
+    alias: nullableStr(),
+    status: str("draft or published"),
+    format: str("html or blocks"),
+    subject: str("Default subject; empty for a layout-only template"),
+    preheader: nullableStr(),
+    html: nullableStr(),
+    text: nullableStr(),
+    design: { type: ["object", "null"], description: "Block design, for blocks templates" },
+    variables: { type: ["array", "null"], items: { type: "string" } },
+    unsubscribe_enabled: bool(),
+    category: str("transactional, product, or newsletter"),
+    published_version_id: nullableStr(),
+    published_at: nullableStr("ISO 8601"),
+    created_at: str("ISO 8601"),
+    updated_at: str("ISO 8601"),
+    warnings: listOf(object({ code: str(), message: str(), detail: str() }), "Content problems found in the template")
+  },
+  ["id"]
+);
+var deliverabilityBucket = {
+  total_emails: num(),
+  attempted: num(),
+  sent: num(),
+  delivered: num(),
+  bounced: num(),
+  complained: num(),
+  failed: num(),
+  suppressed: num(),
+  scheduled: num(),
+  opened: num(),
+  clicked: num(),
+  bounce_rate: num(),
+  complaint_rate: num(),
+  delivery_rate: num(),
+  open_rate: num(),
+  click_rate: num()
+};
+var okResult = output({ ok: bool() }, ["ok"]);
+var MAIL_OUTPUT_SCHEMAS = {
+  send_email: sendResult,
+  list_emails: page("emails", email, "Sent emails, newest first"),
+  get_email: output({ email }, ["email"]),
+  cancel_email: sendResult,
+  list_received_emails: page("received_emails", receivedEmail, "Inbound emails, newest first"),
+  get_received_email: output({ received_email: receivedEmail }, ["received_email"]),
+  list_domains: page("domains", domain, "Sending domains"),
+  get_domain: output(domainDnsFields, ["domain", "records"]),
+  create_domain: output(
+    {
+      domain,
+      records: domainDnsFields.records,
+      inbound_records: domainDnsFields.inbound_records,
+      inbound_note: str(),
+      mail_server_dns_synced: bool("True when the domain was registered on the mail server"),
+      mail_server_dns_error: str("Why registering it failed, when it did")
+    },
+    ["domain", "records"]
+  ),
+  apply_domain_dns: output(
+    {
+      provider: str("cloudflare, godaddy, or vercel"),
+      domain: str(),
+      results: listOf(
+        object(
+          {
+            purpose: str(),
+            host: str(),
+            action: str("created, updated, unchanged, or merged"),
+            detail: str()
+          },
+          ["host", "action"]
+        ),
+        "What happened to each record"
+      ),
+      records: listOf(dnsRecord, "The records that were applied")
+    },
+    ["provider", "domain", "results"]
+  ),
+  verify_domain: output(
+    {
+      ...domainDnsFields,
+      verified: bool("True once DNS checks out. A domain whose DNS is not ready comes back as an error instead."),
+      checks: object({ ownership: bool(), spf: bool(), dkim: bool(), dmarc: bool(), return_path: bool() }),
+      auto: bool(),
+      inbound_configured: bool(),
+      inbound_pending: bool(),
+      inbound_error: nullableStr(),
+      mail_server_registered: bool(),
+      signing_ready: bool("True when the mail server can sign mail for the domain"),
+      mail_server_signing: object({
+        dkim_ok: bool(),
+        return_path_ok: bool(),
+        dkim_status: nullableStr(),
+        return_path_status: nullableStr()
+      })
+    },
+    ["domain", "verified"]
+  ),
+  list_webhooks: page("webhooks", webhook, "Webhook endpoints"),
+  create_webhook: output(
+    { webhook, secret: str("Signing secret for verifying deliveries. Shown only once.") },
+    ["webhook", "secret"]
+  ),
+  delete_webhook: okResult,
+  list_suppressions: page("data", suppression, "Suppressed addresses"),
+  add_suppression: output({ suppression }, ["suppression"]),
+  remove_suppression: okResult,
+  list_templates: page("data", template, "Email templates"),
+  get_template: output({ template }, ["template"]),
+  create_template: output({ template }, ["template"]),
+  publish_template: output({ template }, ["template"]),
+  send_test_webhook_event: output(
+    {
+      ok: bool(),
+      payload: { description: "The simulated event payload, as a webhook would receive it" },
+      delivered: bool("True when it was sent to webhook endpoints"),
+      deliveries: listOf(
+        object({
+          endpoint_id: str(),
+          url: str(),
+          success: bool(),
+          status: num("HTTP status the endpoint returned"),
+          error: str()
+        })
+      )
+    },
+    ["ok"]
+  ),
+  get_deliverability: output(
+    {
+      window: str("7d or 30d"),
+      window_start: str("ISO 8601"),
+      generated_at: str("ISO 8601"),
+      summary: object(deliverabilityBucket, [], "Counts and rates across all sends in the window"),
+      by_domain: listOf(
+        object(
+          {
+            domain: str(),
+            ...deliverabilityBucket,
+            mail_server_relay: object(
+              {
+                window_days: num(),
+                total_messages: num(),
+                sent: num(),
+                bounced: num(),
+                failed: num(),
+                delayed: num()
+              },
+              [],
+              "Relay counts from the mail server, for the busiest domains"
+            )
+          },
+          ["domain"]
+        ),
+        "The same, per sending domain"
+      ),
+      top_bounce_reasons: listOf(object({ reason: str(), count: num() })),
+      notes: strList("How to read the numbers")
+    },
+    ["window", "summary"]
+  )
+};
+var approvalCard = object(
+  {
+    messageId: str("Pass to ranla_approve or ranla_reject"),
+    summary: str("What it will do"),
+    detail: str()
+  },
+  ["messageId"]
+);
+var connectCard = object(
+  {
+    messageId: str(),
+    slot: str("The account to connect"),
+    summary: str(),
+    path: str("Where in the app to connect it"),
+    detail: str()
+  },
+  ["messageId"]
+);
+var turnFields = {
+  text: str("Ranla's reply"),
+  tools: listOf(
+    object({ toolName: str(), label: str("What the step did"), isError: bool() }),
+    "Steps Ranla took in the turn"
+  ),
+  artifacts: listOf(
+    object({ type: str("draft, plan, document\u2026"), id: str(), label: str() }, ["type", "id"]),
+    "What Ranla made or opened, by id"
+  ),
+  pendingApproval: { ...approvalCard, description: "The step waiting on ranla_approve. It does nothing until approved." },
+  pendingApprovals: listOf(approvalCard, "Every step waiting, when there is more than one"),
+  connectRequired: { ...connectCard, description: "An account the founder must connect in the app before Ranla can go on" },
+  connectsRequired: listOf(connectCard, "Every account to connect, when there is more than one"),
+  error: str("Set when the turn failed")
+};
+var thread = object(
+  {
+    id: str("Thread id"),
+    title: str(),
+    scope: nullableStr("Desk the thread belongs to"),
+    origin: str("Where the thread was started"),
+    lastMessageAt: nullableStr("ISO 8601")
+  },
+  ["id"]
+);
+var RANLA_OUTPUT_SCHEMAS = {
+  ranla_list_threads: output(
+    {
+      threads: listOf(
+        {
+          ...thread,
+          properties: {
+            ...thread.properties,
+            preview: str("First line of the latest message")
+          }
+        },
+        "Most recent first"
+      ),
+      nextBefore: nullableStr("Pass as before for older threads; null on the last page")
+    },
+    ["threads"]
+  ),
+  ranla_get_thread: output(
+    {
+      thread: {
+        ...thread,
+        properties: {
+          ...thread.properties,
+          running: bool("True while Ranla is still working on a turn")
+        }
+      },
+      messages: listOf(
+        object(
+          {
+            id: str("Message id; for a pending approval, the messageId ranla_approve takes"),
+            role: str("user, assistant, or tool"),
+            text: str(),
+            createdAt: nullableStr("ISO 8601"),
+            error: str(),
+            tools: listOf(object({ name: str(), label: str(), isError: bool() })),
+            artifact: object({ type: str(), id: str() }, ["type"]),
+            approval: object(
+              {
+                status: str("pending, approved, or rejected"),
+                summary: str(),
+                detail: nullableStr(),
+                kind: nullableStr(),
+                reviewUrl: str()
+              },
+              ["status"]
+            ),
+            connect: object({ slot: str(), summary: str(), detail: nullableStr(), url: nullableStr() })
+          },
+          ["id", "role"]
+        ),
+        "Oldest first within the page"
+      ),
+      earlierBefore: nullableStr("Pass as before for the page of older messages; null when there are none"),
+      earlierCount: num("Messages older than this page")
+    },
+    ["thread", "messages"]
+  ),
+  ranla_open_thread: output(
+    {
+      threadId: str("Pass to ranla_message and ranla_command"),
+      title: nullableStr()
+    },
+    ["threadId"]
+  ),
+  ranla_message: output(
+    {
+      threadId: str("The thread the turn ran in"),
+      ...turnFields,
+      runId: str("The turn's run, while it is followed"),
+      setAsideApprovals: listOf(
+        object({ messageId: str(), summary: str() }, ["messageId"]),
+        "Approvals that were waiting and were set aside by this message"
+      ),
+      running: bool("True when Ranla is still working after 15 minutes; read the answer with ranla_get_thread"),
+      note: str()
+    },
+    ["threadId"]
+  ),
+  ranla_list_approvals: output(
+    {
+      approvals: listOf(
+        object(
+          {
+            messageId: str("Pass to ranla_approve or ranla_reject"),
+            threadId: str(),
+            threadTitle: str(),
+            toolName: nullableStr(),
+            kind: nullableStr(),
+            summary: str("What it will do"),
+            detail: nullableStr(),
+            createdAt: str("ISO 8601"),
+            url: str("Where to review it in the app"),
+            area: str("paid or seo, for approvals reviewed in their own view"),
+            actionId: str(),
+            next: str()
+          },
+          ["messageId"]
+        ),
+        "Pending approvals across threads"
+      )
+    },
+    ["approvals"]
+  ),
+  ranla_approve: output(turnFields, [], "The turn the approval resumed"),
+  ranla_reject: output(turnFields, [], "The turn the rejection resumed"),
+  ranla_command: output(
+    {
+      result: openObject(
+        "What the command returned: content (any JSON, shaped by the command), plus steps and artifact when it has them"
+      ),
+      pendingApproval: object(
+        {
+          messageId: str("Pass to ranla_approve or ranla_reject"),
+          summary: str("What it will do"),
+          threadId: str(),
+          url: str("Where to review it in the app")
+        },
+        ["messageId"],
+        "Set when the command needs sign-off. It does nothing until ranla_approve."
+      ),
+      next: str("What to do with the pending approval"),
+      noun: str("For help <noun>: the noun"),
+      commands: openObject("For help <noun>: each verb's input schema")
+    },
+    [],
+    "A command's response. Each command returns its own result; one that needs sign-off also returns pendingApproval."
+  )
+};
+var CHATGPT_COMMAND_OUTPUT_SCHEMA = output(
+  {
+    content: openObject("What the command returned. Its fields depend on the command; read them before quoting a number.")
+  },
+  [],
+  "A Ranla command's result."
+);
+var MCP_OUTPUT_SCHEMAS = {
+  ...MAIL_OUTPUT_SCHEMAS,
+  ...RANLA_OUTPUT_SCHEMAS
+};
+function mcpOutputSchema(name) {
+  return MCP_OUTPUT_SCHEMAS[name];
+}
+
+// src/tools.ts
+function textResult(value, isError = false) {
+  const content = [
+    { type: "text", text: typeof value === "string" ? value : JSON.stringify(value, null, 2) }
+  ];
+  if (isError) return { content, isError: true };
+  const structuredContent = value && typeof value === "object" && !Array.isArray(value) ? value : { result: value };
+  return { content, structuredContent };
+}
 function optString2(args, key) {
   if (args[key] == null) return void 0;
   const value = String(args[key]).trim();
@@ -865,7 +1602,7 @@ async function callMcpTool(client, name, args, options = {}) {
   try {
     if (isArcMcpToolName(name)) {
       const apiKey = options.apiKey ?? resolveApiKey();
-      const result = await callArcMcpTool(apiKey, name, args, options.baseUrl);
+      const result = await callArcMcpTool(apiKey, name, args, options.baseUrl, { askOnly: options.askOnly });
       return textResult(result);
     }
     switch (name) {
@@ -942,13 +1679,13 @@ async function callMcpTool(client, name, args, options = {}) {
         return textResult(await client.receivedEmails.get(id));
       }
       case "get_domain": {
-        const domain = optString2(args, "domain");
-        if (!domain) return textResult("Missing required argument: domain", true);
-        return textResult(await client.domains.get(domain));
+        const domain2 = optString2(args, "domain");
+        if (!domain2) return textResult("Missing required argument: domain", true);
+        return textResult(await client.domains.get(domain2));
       }
       case "apply_domain_dns": {
-        const domain = String(args.domain ?? "").trim();
-        if (!domain) {
+        const domain2 = String(args.domain ?? "").trim();
+        if (!domain2) {
           return textResult("Missing required argument: domain", true);
         }
         const providerRaw = typeof args.provider === "string" ? args.provider.trim().toLowerCase() : "";
@@ -958,17 +1695,13 @@ async function callMcpTool(client, name, args, options = {}) {
             true
           );
         }
-        const credentials = args.credentials && typeof args.credentials === "object" ? args.credentials : void 0;
-        const result = await client.domains.apply(domain, {
-          provider: providerRaw,
-          ...credentials ? { credentials } : {}
-        });
+        const result = await client.domains.apply(domain2, { provider: providerRaw });
         return textResult(result);
       }
       case "verify_domain": {
-        const domain = optString2(args, "domain");
-        if (!domain) return textResult("Missing required argument: domain", true);
-        const result = await client.domains.verify(domain);
+        const domain2 = optString2(args, "domain");
+        if (!domain2) return textResult("Missing required argument: domain", true);
+        const result = await client.domains.verify(domain2);
         return textResult(result);
       }
       case "list_domains": {
@@ -1029,11 +1762,11 @@ async function callMcpTool(client, name, args, options = {}) {
         );
       }
       case "add_suppression": {
-        const email = optString2(args, "email");
-        if (!email) return textResult("Missing required argument: email", true);
+        const email2 = optString2(args, "email");
+        if (!email2) return textResult("Missing required argument: email", true);
         return textResult(
           await client.suppressions.create({
-            email,
+            email: email2,
             reason: optString2(args, "reason")
           })
         );
@@ -1137,8 +1870,8 @@ var MCP_TOOLS = [
         bcc: recipientProp("Bcc recipients"),
         reply_to: recipientProp("Reply-To"),
         subject: { type: "string", description: "Optional when using a published template" },
-        html: { type: "string" },
-        text: { type: "string" },
+        html: { type: "string", description: "HTML body. Send html, text or both, unless you use a template" },
+        text: { type: "string", description: "Plain-text body. Sent alongside html, or on its own" },
         template_id: { type: "string", description: "Published template id" },
         template_alias: { type: "string", description: "Published template alias" },
         variables: {
@@ -1259,15 +1992,15 @@ var MCP_TOOLS = [
   },
   {
     name: "apply_domain_dns",
-    description: "Create the sending domain's DNS records at your DNS provider (Cloudflare, GoDaddy, or Vercel), using the connection stored in the dashboard. GoDaddy also accepts one-time credentials on the request.",
+    description: "Create the sending domain's DNS records at your DNS provider (Cloudflare, GoDaddy, or Vercel), using the connection stored in the dashboard. Connect the provider in the dashboard first; registrar credentials are never passed through here.",
     inputSchema: {
       type: "object",
       properties: {
-        domain: { type: "string" },
-        provider: { type: "string", enum: ["cloudflare", "godaddy", "vercel"] },
-        credentials: {
-          type: "object",
-          description: "Optional inline registrar credentials (GoDaddy api key/secret)"
+        domain: { type: "string", description: "Domain id or name (example.com)" },
+        provider: {
+          type: "string",
+          enum: ["cloudflare", "godaddy", "vercel"],
+          description: "DNS provider that hosts the domain"
         }
       },
       required: ["domain", "provider"]
@@ -1279,7 +2012,7 @@ var MCP_TOOLS = [
     inputSchema: {
       type: "object",
       properties: {
-        domain: { type: "string" }
+        domain: { type: "string", description: "Domain id or name (example.com)" }
       },
       required: ["domain"]
     }
@@ -1336,8 +2069,8 @@ var MCP_TOOLS = [
     inputSchema: {
       type: "object",
       properties: {
-        email: { type: "string" },
-        reason: { type: "string" }
+        email: { type: "string", description: "Address to stop sending to" },
+        reason: { type: "string", description: 'Optional note on why, e.g. "asked to stop"' }
       },
       required: ["email"]
     }
@@ -1360,7 +2093,7 @@ var MCP_TOOLS = [
       type: "object",
       properties: {
         ...paginationProps,
-        status: { type: "string", enum: ["draft", "published"] }
+        status: { type: "string", enum: ["draft", "published"], description: "Only drafts or only published templates" }
       }
     }
   },
@@ -1381,12 +2114,16 @@ var MCP_TOOLS = [
     inputSchema: {
       type: "object",
       properties: {
-        name: { type: "string" },
-        subject: { type: "string" },
-        format: { type: "string", enum: ["html", "blocks"] },
-        html: { type: "string" },
-        text: { type: "string" },
-        alias: { type: "string" }
+        name: { type: "string", description: "Template name shown in the dashboard" },
+        subject: { type: "string", description: "Default subject line. Variables like {{name}} are allowed" },
+        format: {
+          type: "string",
+          enum: ["html", "blocks"],
+          description: "html for a raw HTML body, or blocks for the dashboard block editor"
+        },
+        html: { type: "string", description: "HTML body (html format). Variables like {{name}} are allowed" },
+        text: { type: "string", description: "Plain-text body" },
+        alias: { type: "string", description: "Stable name to send with (template_alias), e.g. password-reset" }
       },
       required: ["name"]
     }
@@ -1397,8 +2134,8 @@ var MCP_TOOLS = [
     inputSchema: {
       type: "object",
       properties: {
-        id: { type: "string" },
-        alias: { type: "string" },
+        id: { type: "string", description: "Template id" },
+        alias: { type: "string", description: "Template alias (alternative to id)" },
         label: { type: "string", description: "Optional name for this version in the template history" }
       }
     }
@@ -1430,7 +2167,7 @@ var MCP_TOOLS = [
     inputSchema: {
       type: "object",
       properties: {
-        window: { type: "string", enum: ["7d", "30d"] }
+        window: { type: "string", enum: ["7d", "30d"], description: "Look-back window. Default 30d" }
       }
     }
   }
@@ -1453,48 +2190,76 @@ function resolveApiKey() {
 // src/server.ts
 var MCP_SERVER_VERSION = version;
 var MCP_SERVER_INSTRUCTIONS = [
-  "Ranla is an AI growth agent for a software business: lifecycle email, audiences, campaigns, pages, ads, and replies, plus transactional email from the same workspace.",
-  'For growth work, or anything that needs judgement or research, send the request to Ranla with arc_message and show its reply. Use arc_ranla when the user names one specific step, such as "campaign list".',
-  "Anything that sends, spends, or publishes comes back as pendingApproval and does nothing yet. Show it to the user and call arc_approve or arc_reject only after they answer.",
+  "Ranla is an AI growth engineer for a software business: lifecycle email, audiences, campaigns, pages, ads, and replies, plus transactional email from the same workspace.",
+  'For growth work, or anything that needs judgement or research, send the request to Ranla with ranla_message and show its reply. Use ranla_command when the user names one specific step, such as "campaign list".',
+  "Anything that sends, spends, or publishes comes back as pendingApproval and does nothing yet. Show it to the user and call ranla_approve or ranla_reject only after they answer.",
   "Use the mail tools (send_email, domains, templates, webhooks, suppressions) only when the user asks about application mail such as receipts or sign-in codes."
 ].join("\n\n");
 var MCP_TOOL_SECURITY_SCHEMES = [{ type: "oauth2", scopes: ["full"] }];
+function listEntry(tool, outputSchema) {
+  const annotations = mcpToolAnnotations(tool);
+  return {
+    name: tool.name,
+    title: annotations.title,
+    description: tool.description,
+    inputSchema: tool.inputSchema,
+    ...outputSchema ? { outputSchema } : {},
+    annotations,
+    securitySchemes: MCP_TOOL_SECURITY_SCHEMES,
+    _meta: { securitySchemes: MCP_TOOL_SECURITY_SCHEMES }
+  };
+}
+async function listMcpTools(apiKey, baseUrl, profile = "full") {
+  const tools = [...MCP_TOOLS, ...await loadArcMcpTools(apiKey, baseUrl)];
+  if (profile === "full") return tools.map((tool) => listEntry(tool, mcpOutputSchema(tool.name)));
+  const kept = tools.filter((tool) => !CHATGPT_EXCLUDED_TOOLS.has(tool.name)).map((tool) => listEntry(tool, mcpOutputSchema(tool.name)));
+  const named = CHATGPT_COMMAND_TOOLS.map(
+    (tool) => listEntry({ ...tool, readOnly: true }, CHATGPT_COMMAND_OUTPUT_SCHEMA)
+  );
+  return forChatGpt([...named, ...kept]);
+}
 function withUpdateNotice(result, notice) {
   return { ...result, content: [...result.content, { type: "text", text: notice }] };
 }
+async function callChatGptCommandTool(apiKey, name, args, baseUrl) {
+  try {
+    const body = await runRanlaCommand(apiKey, chatGptCommandFor(name), args, baseUrl);
+    const result = body.result;
+    return textResult(result && typeof result === "object" && !Array.isArray(result) ? result : body);
+  } catch (error) {
+    return textResult(error instanceof Error ? error.message : String(error), true);
+  }
+}
 function createMcpServer(apiKey, baseUrl, options = {}) {
   const client = new SuperSendTX(apiKey, {
     ...baseUrl ? { baseUrl } : {},
     fetch: fetchWithUserAgent(mcpUserAgent())
   });
+  const profile = options.profile ?? "full";
   const knownUpdate = options.updateCheck?.result();
-  const instructions = knownUpdate ? `${MCP_SERVER_INSTRUCTIONS}
+  const baseInstructions = profile === "chatgpt" ? CHATGPT_SERVER_INSTRUCTIONS : MCP_SERVER_INSTRUCTIONS;
+  const instructions = knownUpdate ? `${baseInstructions}
 
-${formatMcpAgentUpdateNotice(knownUpdate)}` : MCP_SERVER_INSTRUCTIONS;
+${formatMcpAgentUpdateNotice(knownUpdate)}` : baseInstructions;
   const server = new Server(
     { name: mcpServerName(), version: MCP_SERVER_VERSION },
     { capabilities: { tools: {} }, instructions }
   );
   let updateNoticeSent = false;
   server.setRequestHandler(ListToolsRequestSchema, async () => ({
-    tools: [...MCP_TOOLS, ...await loadArcMcpTools(apiKey, baseUrl)].map((tool) => {
-      const annotations = mcpToolAnnotations(tool);
-      return {
-        name: tool.name,
-        title: annotations.title,
-        description: tool.description,
-        inputSchema: tool.inputSchema,
-        annotations,
-        securitySchemes: MCP_TOOL_SECURITY_SCHEMES,
-        _meta: { securitySchemes: MCP_TOOL_SECURITY_SCHEMES }
-      };
-    })
+    tools: await listMcpTools(apiKey, baseUrl, profile)
   }));
   server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const result = await callMcpTool(client, request.params.name, request.params.arguments ?? {}, {
-      apiKey,
-      baseUrl
-    });
+    const name = currentToolName(request.params.name);
+    const args = request.params.arguments ?? {};
+    let result;
+    if (profile === "chatgpt" && CHATGPT_EXCLUDED_TOOLS.has(name)) {
+      result = textResult(`${name} isn't available here. Ask Ranla with ranla_message instead.`, true);
+    } else if (profile === "chatgpt" && chatGptCommandFor(name)) {
+      result = await callChatGptCommandTool(apiKey, name, args, baseUrl);
+    } else {
+      result = await callMcpTool(client, name, args, { apiKey, baseUrl, askOnly: profile === "chatgpt" });
+    }
     const update = updateNoticeSent ? null : options.updateCheck?.result();
     if (!update) return result;
     updateNoticeSent = true;
@@ -1511,6 +2276,7 @@ async function runStdioServer() {
 
 // src/oauth-metadata.ts
 var MCP_HTTP_PATH = "/mcp";
+var CHATGPT_MCP_PATH = "/chatgpt";
 function appOriginForMcpOrigin(mcpOrigin) {
   try {
     const host = new URL(mcpOrigin).hostname.toLowerCase();
@@ -1520,8 +2286,8 @@ function appOriginForMcpOrigin(mcpOrigin) {
   }
   return (process.env.SUPERSENDTX_OAUTH_ISSUER?.trim() || process.env.SUPERSENDTX_APP_URL?.trim() || "https://app.ranla.ai").replace(/\/$/, "");
 }
-function buildProtectedResourceMetadata(origin) {
-  const resource = `${origin.replace(/\/$/, "")}${MCP_HTTP_PATH}`;
+function buildProtectedResourceMetadata(origin, path = MCP_HTTP_PATH) {
+  const resource = `${origin.replace(/\/$/, "")}${path}`;
   const appOrigin = appOriginForMcpOrigin(origin);
   return {
     resource,
@@ -1530,8 +2296,9 @@ function buildProtectedResourceMetadata(origin) {
     bearer_methods_supported: ["header"]
   };
 }
-function buildWwwAuthenticateChallenge(origin) {
-  const metadataUrl = `${origin.replace(/\/$/, "")}/.well-known/oauth-protected-resource`;
+function buildWwwAuthenticateChallenge(origin, path = MCP_HTTP_PATH) {
+  const suffix = path === MCP_HTTP_PATH ? "" : path;
+  const metadataUrl = `${origin.replace(/\/$/, "")}/.well-known/oauth-protected-resource${suffix}`;
   return `Bearer error="invalid_token", error_description="OAuth authentication required", resource_metadata="${metadataUrl}"`;
 }
 
@@ -1631,7 +2398,14 @@ async function handleHttpRequest(req, res, options = {}) {
     });
     return;
   }
-  if (url.pathname !== "/mcp" && url.pathname !== "/") {
+  if (url.pathname === `/.well-known/oauth-protected-resource${CHATGPT_MCP_PATH}`) {
+    sendJson(res, 200, buildProtectedResourceMetadata(origin, CHATGPT_MCP_PATH), {
+      "cache-control": "public, max-age=300, s-maxage=3600"
+    });
+    return;
+  }
+  const chatgpt = url.pathname === CHATGPT_MCP_PATH;
+  if (url.pathname !== "/mcp" && url.pathname !== "/" && !chatgpt) {
     sendJson(res, 404, { error: "Not found. MCP endpoint is POST/GET /mcp" });
     return;
   }
@@ -1645,11 +2419,11 @@ async function handleHttpRequest(req, res, options = {}) {
       res,
       401,
       { error: "Missing or invalid Authorization. Use Bearer stx_\u2026 / rnl_\u2026 or complete MCP OAuth." },
-      { "www-authenticate": buildWwwAuthenticateChallenge(origin) }
+      { "www-authenticate": buildWwwAuthenticateChallenge(origin, chatgpt ? CHATGPT_MCP_PATH : void 0) }
     );
     return;
   }
-  const server = createMcpServer(apiKey, options.baseUrl);
+  const server = createMcpServer(apiKey, options.baseUrl, { profile: chatgpt ? "chatgpt" : "full" });
   const transport = new StreamableHTTPServerTransport({
     sessionIdGenerator: void 0
   });