@sendinel/mcp-server 1.0.31 → 1.0.33

package/README.md

@@ -12,7 +12,7 @@ AI-controlled email operations control plane for campaigns, contacts, segments,
 
 ## Tool groups
 
-Sendinel currently exposes 34 tool groups and 315 tools (gateway mode adds 3 meta-tools). These counts are checked against the tool registry in CI, so this table matches what ships.
+Sendinel currently exposes 34 tool groups and 318 tools (gateway mode adds 3 meta-tools). These counts are checked against the tool registry in CI, so this table matches what ships.
 
 | Group | Count | Purpose |
 |-------|-------|---------|
@@ -23,7 +23,7 @@ Sendinel currently exposes 34 tool groups and 315 tools (gateway mode adds 3 met
 | `approvals` | 2 | Poll and list risk-tiered action approvals |
 | `automations` | 7 | Automation triggers, previews, and response-gated escalation ladders |
 | `brand_kit` | 5 | Brand Core text import, media library upload/URL ingest, asset-context reads |
-| `campaigns` | 39 | Full campaign lifecycle: create, edit, approve, launch, enroll, schedule, sequence templates |
+| `campaigns` | 42 | Full campaign lifecycle: create, edit, approve, launch, enroll, schedule, sequence templates |
 | `cloud-import` | 6 | Cloud storage import |
 | `compound` | 4 | Higher-level campaign/template/site setup and delivery diagnosis workflows |
 | `connector` | 6 | BYOD connector status, table discovery, schema/view setup, mapping, resync |

package/build/index.js

@@ -7,14 +7,14 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import express from 'express';
-import { registerAllTools } from './server.js';
+import { registerAllTools, SENDINEL_SERVER_INSTRUCTIONS } from './server.js';
 import { registerAllPrompts } from './prompts.js';
 import { runWithClient } from './db.js';
 import { initProjectClient, resolveProjectClientStrict, TenantResolutionError } from './byod-client.js';
 import { authenticateBearer, McpAuthenticationError, validateKey } from './auth.js';
 const transport = process.env.MCP_TRANSPORT ?? 'stdio';
 async function runStdio() {
-    const server = new McpServer({ name: 'sendinel', version: '0.1.0' });
+    const server = new McpServer({ name: 'sendinel', version: '0.1.0' }, { instructions: SENDINEL_SERVER_INSTRUCTIONS });
     // For stdio, validate SENDINEL_API_KEY and fail closed if it is absent.
     const apiKey = process.env.SENDINEL_API_KEY;
     let toolGroups;
@@ -94,7 +94,7 @@ async function runHttp() {
             throw err;
         }
         await runWithClient(projectClient, async () => {
-            const server = new McpServer({ name: 'sendinel', version: '0.1.0' });
+            const server = new McpServer({ name: 'sendinel', version: '0.1.0' }, { instructions: SENDINEL_SERVER_INSTRUCTIONS });
             registerAllTools(server, {
                 scopes: info.scopes,
                 toolGroups: info.toolGroups,

package/build/lib/action-approvals.d.ts

@@ -25,8 +25,15 @@ export interface ExecutionDecision {
 export declare function assertChannelCanExecute(action: string, params: Record<string, unknown> | undefined, context: ChannelExecutionContext): ExecutionDecision;
 /** Convenience: pull channel/verified out of the request-scoped context, defaulting to today's only live caller (mcp_api_key). */
 export declare function currentChannelContext(): ChannelExecutionContext;
+/**
+ * Display-only facts for the approval summary (segment name, count, subject, excerpt). Never
+ * stored in params, so it can't change the params an approval is checked against.
+ */
+export type ApprovalDisplay = Record<string, string | number | null | undefined>;
+/** Tag-stripped, whitespace-collapsed, length-capped text. HTML is untrusted input. */
+export declare function approvalExcerpt(html: unknown, max?: number): string;
 /** Build a human-readable summary of the action for the approval screen */
-export declare function buildApprovalSummary(action: string, params: Record<string, unknown>): string;
+export declare function buildApprovalSummary(action: string, params: Record<string, unknown>, display?: ApprovalDisplay): string;
 export interface ApprovalResult {
     requires_approval: true;
     approval_id: string;
@@ -43,7 +50,7 @@ export interface ApprovalResult {
  * Request human approval for an action. Creates a pending approval token
  * and returns instructions for the agent to wait.
  */
-export declare function requestApproval(action: string, params: Record<string, unknown>, apiKeyId?: string, channelContext?: ChannelExecutionContext): Promise<ApprovalResult>;
+export declare function requestApproval(action: string, params: Record<string, unknown>, apiKeyId?: string, channelContext?: ChannelExecutionContext, display?: ApprovalDisplay): Promise<ApprovalResult>;
 /**
  * Check if an approval token has been approved.
  * Returns the approval if approved, null if still pending, throws if rejected/expired.

package/build/lib/action-approvals.js

@@ -16,6 +16,8 @@ const GATED_ACTIONS = new Set([
     'resync_connector', // forces a full resync
     'publish_dmarc_record', // writes a DNS record into a customer-owned Cloudflare zone
     'broadcast_to_segment', // creates + activates a real broadcast
+    'send_broadcast', // one-call broadcast; executes a frozen, approved payload (#3669)
+    'activate_campaigns', // turns on a set of campaigns behind one approval (#3669)
     'rotate_custom_webhook_secret', // immediately invalidates an inbound signing secret
     'create_campaign_with_content', // can activate + send in one call
     'enroll_segment', // bulk enrollment
@@ -49,6 +51,10 @@ export function getApprovalTier(action, params) {
             return 'autonomous';
         return 'protected';
     }
+    // send_broadcast exists for agents and always needs a person's approval, even in autonomous
+    // mode: it must never approve itself (#3669, AI-worker boundary in CLAUDE.md).
+    if (action === 'send_broadcast' || action === 'activate_campaigns')
+        return 'gated';
     // Autonomous mode: user explicitly opted out of approval gates for gated actions
     // (request-scoped under HTTP — env is only trustworthy for single-project stdio)
     const mode = requestContext()?.approvalMode ?? process.env.SENDINEL_APPROVAL_MODE ?? 'standard';
@@ -123,8 +129,28 @@ export function currentChannelContext() {
         verified: ctx?.channelVerified ?? true,
     };
 }
+/** Tag-stripped, whitespace-collapsed, length-capped text. HTML is untrusted input. */
+export function approvalExcerpt(html, max = 200) {
+    const text = String(html ?? '')
+        .replace(/<style[\s\S]*?<\/style>/gi, ' ')
+        .replace(/<script[\s\S]*?<\/script>/gi, ' ')
+        .replace(/<[^>]+>/g, ' ')
+        .replace(/&nbsp;/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+    return text.length > max ? `${text.slice(0, max - 1)}…` : text;
+}
+function broadcastSummary(d) {
+    if (!d.subject)
+        return null;
+    const count = typeof d.recipient_count === 'number' ? `${d.recipient_count.toLocaleString('en-US')} recipient${d.recipient_count === 1 ? '' : 's'}` : null;
+    const audience = d.segment_name ? `segment "${d.segment_name}"` : (d.audience_label ? String(d.audience_label) : 'the chosen audience');
+    const when = d.send_at ? ` at ${d.send_at}` : '';
+    const excerpt = d.body_excerpt ? ` — "${d.body_excerpt}"` : '';
+    return `Send "${d.subject}" to ${audience}${count ? ` (${count})` : ''}${when}${excerpt}`;
+}
 /** Build a human-readable summary of the action for the approval screen */
-export function buildApprovalSummary(action, params) {
+export function buildApprovalSummary(action, params, display = {}) {
     const summaries = {
         launch_campaign: (p) => `Launch campaign "${p.name || p.campaign_name || 'unknown'}" — will send emails to real contacts`,
         install_connector_schema: (p) => `Install connector schema for project ${p.project_id ?? 'current'}`,
@@ -132,7 +158,26 @@ export function buildApprovalSummary(action, params) {
         set_connector_mapping: () => `Rewrite the BYOD connector field mapping`,
         resync_connector: () => `Force a full BYOD connector resync`,
         publish_dmarc_record: (p) => `Publish DMARC record for ${p.domain} - writes DNS in a customer-owned Cloudflare zone`,
-        broadcast_to_segment: (p) => `Broadcast "${p.name || p.subject || 'untitled'}" to segment ${p.segment_id} — will send emails to real contacts`,
+        broadcast_to_segment: (p) => broadcastSummary(display) ?? `Broadcast "${p.name || p.subject || 'untitled'}" to segment ${p.segment_id} — will send emails to real contacts`,
+        send_broadcast: (p) => {
+            const payload = (p.payload ?? {});
+            return broadcastSummary({
+                subject: payload.subject,
+                recipient_count: Array.isArray(payload.contact_ids) ? payload.contact_ids.length : undefined,
+                body_excerpt: approvalExcerpt(payload.body_html),
+                send_at: payload.send_at ?? undefined,
+                ...display,
+            }) ?? `Send a broadcast — will send emails to real contacts`;
+        },
+        activate_campaigns: (p) => {
+            const count = typeof display.campaign_count === 'number' ? display.campaign_count : p.campaign_ids?.length ?? 0;
+            const emails = typeof display.email_count === 'number' ? ` (${display.email_count} email${display.email_count === 1 ? '' : 's'})` : '';
+            const names = display.campaign_names ? `: ${display.campaign_names}` : '';
+            return `Activate ${count} campaign${count === 1 ? '' : 's'}${emails}${names} — each emails contacts when its trigger fires`;
+        },
+        update_campaign_status: (p) => (p.status === 'active'
+            ? `Activate campaign "${display.campaign_name ?? p.campaign_id}"${typeof display.enrolled === 'number' ? ` — sends email to ${display.enrolled.toLocaleString('en-US')} enrolled contact${display.enrolled === 1 ? '' : 's'}` : ' — will send emails to real contacts'}${display.trigger ? ` and to new contacts on "${display.trigger}"` : ''}`
+            : `Change campaign "${display.campaign_name ?? p.campaign_id}" to ${p.status}`),
         rotate_custom_webhook_secret: (p) => `Rotate custom webhook ${p.connection_id} signing secret — immediately invalidates the previous secret with no grace period`,
         create_campaign_with_content: (p) => `Create + activate campaign "${p.name}" with ${p.steps?.length ?? 0} email(s) and enroll contacts`,
         enroll_segment: (p) => `Enroll all contacts from site into campaign ${p.campaign_id}`,
@@ -178,9 +223,9 @@ function approvalParamsEqual(expected, actual) {
  * Request human approval for an action. Creates a pending approval token
  * and returns instructions for the agent to wait.
  */
-export async function requestApproval(action, params, apiKeyId, channelContext) {
+export async function requestApproval(action, params, apiKeyId, channelContext, display) {
     const tier = getApprovalTier(action, params);
-    const summary = buildApprovalSummary(action, params);
+    const summary = buildApprovalSummary(action, params, display);
     const expiresAt = new Date(Date.now() + 30 * 60 * 1000).toISOString();
     const { channel, verified } = channelContext ?? currentChannelContext();
     const { data, error } = await db()

package/build/lib/email-generation.d.ts

@@ -0,0 +1,11 @@
+import type Anthropic from '@anthropic-ai/sdk';
+import { type ComposerBlock } from './composer-blocks.js';
+export declare function parseAudienceRules(anthropic: Anthropic, description: string): Promise<Record<string, unknown>>;
+export type GeneratedEmail = {
+    subject: string;
+    preview_text: string | null;
+    body_html: string;
+    body_text: string;
+    blocks: ComposerBlock[];
+};
+export declare function generateEmailFromBrief(anthropic: Anthropic, projectId: string, siteId: string, brief: string): Promise<GeneratedEmail>;

package/build/lib/email-generation.js

@@ -0,0 +1,92 @@
+import { db } from '../db.js';
+import { getAnthropicModelId } from '../anthropic-model.js';
+import { buildEmailSystemPrompt, buildVoicePrompt } from './voice.js';
+import { BLOCK_GENERATION_SCHEMA, blocksToHtml, blocksToText, normalizeComposerBlocks } from './composer-blocks.js';
+/**
+ * Shared AI helpers for the MCP send tools (#3669): turn a plain-language audience into segment
+ * rules, and turn a brief into a finished email (Brand Brain voice, Composer blocks rendered to
+ * HTML). Same prompts as launch_campaign. A failure throws: no placeholder email is ever produced.
+ */
+function parseJsonResponse(raw) {
+    return JSON.parse(raw.replace(/```json?\n?|```/g, '').trim());
+}
+function responseText(resp) {
+    const block = resp.content.find((b) => b.type === 'text');
+    return block && 'text' in block ? block.text : '';
+}
+export async function parseAudienceRules(anthropic, description) {
+    const resp = await anthropic.messages.create({
+        model: getAnthropicModelId(),
+        max_tokens: 512,
+        system: 'You translate natural language audience descriptions into a JSON filter rules object. Return ONLY valid JSON. Available keys: lifecycle_stage (lead|trial|customer|churned|win-back), payment (object with plan, mrr_cents, ltv_cents, subscription_status, trial_ends_at, churned_at, paid_at), min_score, max_score, source, subscribed_after, subscribed_before, has_opened, has_clicked, tag, custom_property, exclude_suppressed. Example: {"payment":{"plan":"pro","trial_ends_at":{"within_days":7}},"lifecycle_stage":"trial"}. Today is ' + new Date().toISOString().slice(0, 10) + '.',
+        messages: [{ role: 'user', content: description }],
+    });
+    try {
+        const rules = parseJsonResponse(responseText(resp) || '{}');
+        if (!rules || typeof rules !== 'object' || Array.isArray(rules))
+            throw new Error('not an object');
+        return rules;
+    }
+    catch {
+        throw new Error(`Could not understand the audience "${description}". Try a saved segment instead.`);
+    }
+}
+export async function generateEmailFromBrief(anthropic, projectId, siteId, brief) {
+    const [{ data: site, error: siteError }, { data: project, error: projectError }] = await Promise.all([
+        db().from('sites').select('name, sending_domain, from_name, from_email, brand_voice').eq('id', siteId).eq('project_id', projectId).maybeSingle(),
+        db().from('projects').select('brand_settings').eq('id', projectId).maybeSingle(),
+    ]);
+    if (siteError)
+        throw siteError;
+    if (projectError)
+        throw projectError;
+    const brandCtx = site ? `Brand: ${site.name}, Domain: ${site.sending_domain}, From: ${site.from_name}` : '';
+    const voicePrompt = buildVoicePrompt(site?.brand_voice, project?.brand_settings ?? null);
+    const systemPrompt = `${buildEmailSystemPrompt(brandCtx, voicePrompt, project?.brand_settings ?? null)}
+
+Generate structured Composer blocks first. Return ONLY valid JSON with:
+{
+  "execution_trace": object,
+  "conclusion": {
+    "subject": string,
+    "preview_text": string,
+    "blocks": ComposerBlock[],
+    "body_text": string,
+    "cta_text": string,
+    "reasoning_log": string,
+    "brand_voice_compliance": "PASS" | string
+  }
+}
+
+ComposerBlock[] must conform to this JSON Schema:
+${JSON.stringify(BLOCK_GENERATION_SCHEMA)}
+
+Do not include body_html in your response; Sendinel renders body_html from blocks.`;
+    const resp = await anthropic.messages.create({
+        model: getAnthropicModelId(),
+        max_tokens: 3000,
+        system: systemPrompt,
+        messages: [{ role: 'user', content: brief }],
+    });
+    let conclusion;
+    try {
+        const parsed = parseJsonResponse(responseText(resp) || '{}');
+        conclusion = parsed.conclusion ?? parsed;
+    }
+    catch {
+        throw new Error('The email draft came back in an unreadable format. Try again or pass html instead of brief.');
+    }
+    const blocks = normalizeComposerBlocks(conclusion?.blocks);
+    const subject = typeof conclusion?.subject === 'string' ? conclusion.subject.trim() : '';
+    if (!blocks.length || !subject) {
+        throw new Error('The email draft was empty. Try again or pass html instead of brief.');
+    }
+    const previewText = typeof conclusion.preview_text === 'string' ? conclusion.preview_text : null;
+    return {
+        subject,
+        preview_text: previewText,
+        body_html: blocksToHtml(blocks, { preheader: previewText }),
+        body_text: typeof conclusion.body_text === 'string' && conclusion.body_text.trim() ? conclusion.body_text : blocksToText(blocks),
+        blocks,
+    };
+}

package/build/lib/send-audience.d.ts

@@ -0,0 +1,24 @@
+import { type SegmentRules } from '@sendinel/domain';
+/**
+ * Who a broadcast can actually reach (#3669). One place for the MCP send tools so the count an
+ * approver sees is the count that gets enrolled:
+ *   - the shared segment base query (test, deleted, globally unsubscribed, cooled excluded),
+ *     paged and chunked (#3674), with suppressions removed;
+ *   - only people signed up to the sending site (the send step claims nobody else, #3668);
+ *   - the project's consent gate when it is on (#3667).
+ * Every read throws on failure: an unknown audience must never read as "nobody" or "everyone".
+ */
+export type SendClass = 'broadcast' | 'product';
+/** Contact ids matching segment rules (same semantics as the segments tools and the dashboard). */
+export declare function resolveSegmentContactIds(projectId: string, rules: SegmentRules): Promise<string[]>;
+export type SendAudience = {
+    /** People the send will enroll. */
+    contactIds: string[];
+    /** People matching the segment before the sender and consent checks. */
+    matched: number;
+    /** Matched but not signed up to the sending site. */
+    notOnSender: number;
+    /** Held back by the consent gate, by reason. Empty when the gate is off. */
+    heldBack: Record<string, number>;
+};
+export declare function resolveSendAudience(projectId: string, siteId: string, rules: SegmentRules, sendClass?: SendClass): Promise<SendAudience>;

package/build/lib/send-audience.js

@@ -0,0 +1,79 @@
+import { applySegmentRules, buildSegmentBaseQuery, chunkIds, evaluateSegmentRules, normalizeSegmentRulesToTree, readAllRows, } from '@sendinel/domain';
+import { db } from '../db.js';
+async function loadFieldTypes(projectId) {
+    const { data, error } = await db()
+        .from('custom_field_definitions')
+        .select('key, type, options')
+        .eq('project_id', projectId);
+    if (error)
+        throw error;
+    const fields = {};
+    for (const row of data ?? []) {
+        if (typeof row.key !== 'string' || typeof row.type !== 'string')
+            continue;
+        fields[row.key] = { type: row.type, options: Array.isArray(row.options) ? row.options : null };
+    }
+    return fields;
+}
+/** Contact ids matching segment rules (same semantics as the segments tools and the dashboard). */
+export async function resolveSegmentContactIds(projectId, rules) {
+    const tree = normalizeSegmentRulesToTree(rules);
+    const fieldTypes = rules.custom_property ? await loadFieldTypes(projectId) : {};
+    const q = buildSegmentBaseQuery(db(), projectId);
+    const { query: filtered, siteContactIds } = await applySegmentRules(q, rules, db(), projectId, fieldTypes);
+    if (siteContactIds && siteContactIds.length === 0)
+        return [];
+    const data = await readAllRows(filtered);
+    const contacts = data.filter((contact) => evaluateSegmentRules(contact, tree, fieldTypes));
+    if (tree.exclude_suppressed === false || contacts.length === 0)
+        return contacts.map((c) => String(c.id));
+    const suppressed = await readAllRows(db().from('suppressions').select('id, email').eq('project_id', projectId));
+    const suppressedEmails = new Set(suppressed.map((row) => String(row.email).toLowerCase()));
+    return contacts
+        .filter((c) => !suppressedEmails.has(String(c.email).toLowerCase()))
+        .map((c) => String(c.id));
+}
+export async function resolveSendAudience(projectId, siteId, rules, sendClass = 'broadcast') {
+    const matchedIds = await resolveSegmentContactIds(projectId, rules);
+    const onSender = new Set();
+    for (const chunk of chunkIds(matchedIds)) {
+        const rows = await readAllRows(db().from('site_subscriptions').select('contact_id').eq('site_id', siteId).eq('subscribed', true).in('contact_id', chunk), 'contact_id');
+        for (const row of rows)
+            onSender.add(String(row.contact_id));
+    }
+    const senderIds = matchedIds.filter((id) => onSender.has(id));
+    const { data: project, error: projectError } = await db()
+        .from('projects')
+        .select('marketing_consent_mode')
+        .eq('id', projectId)
+        .maybeSingle();
+    if (projectError)
+        throw projectError;
+    const heldBack = {};
+    let contactIds = senderIds;
+    if (project?.marketing_consent_mode === 'enforce' && senderIds.length > 0) {
+        const reasons = new Map();
+        for (const chunk of chunkIds(senderIds, 1000)) {
+            const { data, error } = await db().rpc('consent_reasons_for_contacts', {
+                p_project_id: projectId,
+                p_contact_ids: chunk,
+                p_send_class: sendClass,
+            });
+            if (error)
+                throw error;
+            for (const row of (data ?? [])) {
+                reasons.set(String(row.contact_id), row.reason);
+            }
+        }
+        contactIds = [];
+        for (const id of senderIds) {
+            // A contact the lookup did not return is held back, never assumed to have agreed.
+            const reason = reasons.has(id) ? reasons.get(id) : 'no_consent_basis';
+            if (reason == null)
+                contactIds.push(id);
+            else
+                heldBack[reason] = (heldBack[reason] ?? 0) + 1;
+        }
+    }
+    return { contactIds, matched: matchedIds.length, notOnSender: matchedIds.length - senderIds.length, heldBack };
+}

package/build/server.d.ts

@@ -15,5 +15,10 @@ export declare const GATEWAY_TOOL_NAMES: string[];
  * through the same proxy path as real MCP registration.
  */
 export declare function getRegisteredToolGroups(options?: ToolRegistrationOptions): ToolGroupMap;
+/**
+ * Server-level guidance every MCP client receives (#3669). Kept short: clients prepend it to the
+ * model's context on every connection.
+ */
+export declare const SENDINEL_SERVER_INSTRUCTIONS: string;
 export declare function registerAllTools(server: McpServer, options?: ToolRegistrationOptions): void;
 export {};

package/build/server.js

@@ -1,6 +1,7 @@
 import { runWithToolContext } from './db.js';
 import { registerAnalyticsTools } from './tools/analytics.js';
 import { registerCampaignTools } from './tools/campaigns.js';
+import { registerCampaignSetTools } from './tools/campaign-sets.js';
 import { registerContactTools } from './tools/contacts.js';
 import { registerDraftTools } from './tools/drafts.js';
 import { registerGdprTools } from './tools/gdpr.js';
@@ -36,7 +37,8 @@ import { registerConnectorTools } from './tools/connector.js';
 import { registerCloudImportTools } from './tools/cloud-import.js';
 const GROUP_REGISTRY = {
     analytics: registerAnalyticsTools,
-    campaigns: registerCampaignTools,
+    // Campaign sets (#3669) live in their own module but belong to the campaigns group.
+    campaigns: (server) => { registerCampaignTools(server); registerCampaignSetTools(server); },
     contacts: registerContactTools,
     segments: registerSegmentTools,
     lists: registerListTools,
@@ -83,7 +85,7 @@ const WRITE_TOOLS = new Set([
     'add_campaign_branch', 'remove_campaign_branch', 'set_campaign_goal', 'remove_campaign_goal',
     'review_campaign_portfolio',
     'list_campaign_steps', 'update_campaign_step', 'delete_campaign_step',
-    'enroll_contact', 'enroll_segment', 'broadcast_to_segment', 'get_enrollment_status', 'clone_campaign', 'clone_sequence_template', 'generate_email',
+    'enroll_contact', 'enroll_segment', 'broadcast_to_segment', 'send_broadcast', 'create_campaign_set', 'activate_campaigns', 'get_enrollment_status', 'clone_campaign', 'clone_sequence_template', 'generate_email',
     'create_social_campaign', 'schedule_social_post',
     'create_social_post', 'update_social_post', 'delete_social_post',
     'create_draft', 'approve_draft', 'reject_draft',
@@ -300,6 +302,16 @@ function createScopeProxy(server, scopes, toolGroup) {
         },
     });
 }
+/**
+ * Server-level guidance every MCP client receives (#3669). Kept short: clients prepend it to the
+ * model's context on every connection.
+ */
+export const SENDINEL_SERVER_INSTRUCTIONS = [
+    'Sendinel runs email for this workspace: contacts, segments, campaigns, templates and sending.',
+    'To send a one-off email, use send_broadcast: call it with an audience and a brief (or html + subject), show the person the subject, recipient count and approve_url it returns, then call it again with only approval_id once they have approved.',
+    'Anything that emails real people needs a person to approve it. Never say an email was sent until the tool that sends it has succeeded.',
+    'In gateway mode, find tools with search_tools (plain words work, for example "send email" or "last campaign"), check arguments with describe_tool, then call invoke_tool.',
+].join(' ');
 export function registerAllTools(server, options) {
     const rawScopes = options?.scopes ?? [];
     if (rawScopes.includes('gateway')) {

package/build/tools/campaign-sets.d.ts

@@ -0,0 +1,24 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+type CampaignSetRow = {
+    id: string;
+    name: string;
+    status: string;
+    trigger_event_name: string | null;
+    trigger_tag: string | null;
+    send_class: string | null;
+    site_id: string;
+};
+type StepRow = {
+    campaign_id: string;
+    step_order: number;
+    variant_label: string | null;
+    subject: string;
+    body_html: string | null;
+    body_text: string | null;
+    delay_days: number | null;
+    delay_hours: number | null;
+};
+/** Fingerprint of everything an approver saw: triggers and every email's exact content. */
+export declare function campaignSetContentHash(campaigns: CampaignSetRow[], steps: StepRow[]): string;
+export declare function registerCampaignSetTools(server: McpServer): void;
+export {};