@sendinel/mcp-server 1.0.216 → 1.0.218

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

@@ -36,8 +36,9 @@ export declare function assertChannelCanExecute(action: string, params: Record<s
 /** 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.
+ * Display-only facts for the approval summary (segment name, count, subject, excerpt).
+ * merge_variable_summary is frozen in __approval_snapshot.display; the other facts
+ * do not 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. */

package/build/lib/action-approvals.js

@@ -252,8 +252,10 @@ export function buildApprovalSummary(action, params, display = {}) {
         remove_suppression: (p) => `Remove ${p.email} from the suppression list — mail to this address will resume`,
     };
     const fn = summaries[action];
-    if (fn)
-        return fn(params);
+    if (fn) {
+        const line = params.__approval_snapshot?.display?.merge_variable_summary;
+        return fn(params) + (line ? `\n${line}` : '');
+    }
     const payload = JSON.stringify(normalizeApprovalParams(params));
     return `Execute ${action} with: ${payload.length > 400 ? `${payload.slice(0, 399)}…` : payload}`;
 }
@@ -356,6 +358,9 @@ export async function requestApproval(action, params, apiKeyId, channelContext,
     const cleanParams = withoutApprovalSnapshot(params);
     const snapshot = { ...await captureSnapshot(action, cleanParams), ...(effective.applied ? { approval_class: effective.class, approval_channel_rule: effective.channelRule } : {}),
         ...(display && 'recipient_count' in display ? { display_recipient_count: display.recipient_count } : {}) };
+    if (typeof display?.merge_variable_summary === 'string') {
+        snapshot.display = { ...snapshot.display, merge_variable_summary: display.merge_variable_summary };
+    }
     const payload = cleanParams.payload;
     if (action === 'send_broadcast' && Array.isArray(payload?.contact_ids) && Array.isArray(snapshot.contact_ids) &&
         !approvalParamsEqual({ ids: [...payload.contact_ids].sort() }, { ids: snapshot.contact_ids })) {

package/build/lib/content-sources.d.ts

@@ -1,4 +1,4 @@
-import { type ContentIssue } from '@sendinel/domain';
+import { type MergeVariableWarning, type ContentIssue } from '@sendinel/domain';
 /** Data keys seen on an event in the project's history, or null when the lookup failed. */
 export declare function eventKeysFromHistory(projectId: string, eventName: string): Promise<string[] | null>;
 /**
@@ -32,7 +32,9 @@ export type CampaignContentFinding = ContentIssue & {
  * every email of the given campaigns (#3853). Placeholder text and sending-domain links are
  * blocking; merge-tag findings are warnings. A failed lookup is reported as a warning, never as a pass.
  */
-export declare function checkCampaignContent(projectId: string, campaigns: ContentCampaign[], steps: ContentStep[]): Promise<{
+export declare function checkCampaignContent(projectId: string, campaigns: ContentCampaign[], steps: ContentStep[], options?: {
+    mergeVariables?: boolean;
+}): Promise<{
     blocking: CampaignContentFinding[];
     warnings: CampaignContentFinding[];
     lookup_errors: string[];
@@ -59,4 +61,22 @@ export declare function summarizeContentWarnings(warnings: Array<{
     email?: number;
     warning: string;
 }>): string;
+export type CampaignMergeVariableWarning = MergeVariableWarning & {
+    step_order: number;
+    checked_at: string;
+    warning: string;
+};
+/** Uses the shared domain rules; unavailable sources stay unknown and never stop activation. */
+export declare function checkCampaignMergeVariables(projectId: string, campaign: {
+    trigger_event_name: string | null;
+}, steps: Array<{
+    step_order: number;
+    subject?: string | null;
+    body_html?: string | null;
+    body_text?: string | null;
+}>): Promise<CampaignMergeVariableWarning[]>;
+/** One extra line on the approval, including explicit uncertainty for unknown sources. */
+export declare function summarizeMergeVariableWarnings(warnings: CampaignMergeVariableWarning[]): string | undefined;
+/** Best-effort note. Compare-and-swap preserves concurrent metadata edits; never gate activation. */
+export declare function persistMergeVariableWarnings(projectId: string, campaignId: string, warnings: CampaignMergeVariableWarning[]): Promise<void>;
 export {};

package/build/lib/content-sources.js

@@ -1,4 +1,4 @@
-import { BLOCKING_CONTENT_ISSUE_KINDS, findContentIssues, sendingHostOf } from '@sendinel/domain';
+import { BLOCKING_CONTENT_ISSUE_KINDS, findContentIssues, sendingHostOf, findUnprovidedMergeTags } from '@sendinel/domain';
 import { db } from '../db.js';
 /** Data keys seen on an event in the project's history, or null when the lookup failed. */
 export async function eventKeysFromHistory(projectId, eventName) {
@@ -50,7 +50,7 @@ export async function contactPropertyKeys(projectId) {
  * every email of the given campaigns (#3853). Placeholder text and sending-domain links are
  * blocking; merge-tag findings are warnings. A failed lookup is reported as a warning, never as a pass.
  */
-export async function checkCampaignContent(projectId, campaigns, steps) {
+export async function checkCampaignContent(projectId, campaigns, steps, options = {}) {
     const lookupErrors = [];
     const sendingHostsBySite = new Map();
     const allHosts = new Set();
@@ -63,11 +63,11 @@ export async function checkCampaignContent(projectId, campaigns, steps) {
         for (const host of hosts)
             allHosts.add(host);
     }
-    const contactProps = await contactPropertyKeys(projectId);
-    if (contactProps === null)
+    const contactProps = options.mergeVariables === false ? null : await contactPropertyKeys(projectId);
+    if (options.mergeVariables !== false && contactProps === null)
         lookupErrors.push('Could not read your contacts, so merge tags that use contact properties were not confirmed.');
     const eventKeys = new Map();
-    for (const eventName of new Set(campaigns.map((c) => c.trigger_event_name).filter((e) => Boolean(e)))) {
+    for (const eventName of new Set((options.mergeVariables === false ? [] : campaigns).map((c) => c.trigger_event_name).filter((e) => Boolean(e)))) {
         const keys = await eventKeysFromHistory(projectId, eventName);
         eventKeys.set(eventName, keys);
         if (keys === null)
@@ -82,7 +82,7 @@ export async function checkCampaignContent(projectId, campaigns, steps) {
             : [...events, ...contactProps.keys.map((key) => `custom.${key}`)];
         const hosts = (campaign.site_id ? sendingHostsBySite.get(campaign.site_id) : undefined) ?? [...allHosts];
         for (const step of steps.filter((s) => s.campaign_id === campaign.id)) {
-            for (const issue of findContentIssues(step, { sendingHosts: hosts, sourcedKeys })) {
+            for (const issue of findContentIssues(step, { sendingHosts: hosts, sourcedKeys: options.mergeVariables === false ? undefined : sourcedKeys })) {
                 const finding = { ...issue, campaign: campaign.name, email: step.step_order + 1 };
                 (BLOCKING_CONTENT_ISSUE_KINDS.has(issue.kind) ? blocking : warnings).push(finding);
             }
@@ -109,3 +109,60 @@ export function summarizeContentWarnings(warnings) {
     const first = warnings.slice(0, 3).map((w) => (w.campaign ? `${w.campaign}, email ${w.email}: ${w.warning}` : w.warning));
     return `${warnings.length} warning${warnings.length === 1 ? '' : 's'}. ${first.join(' | ')}${warnings.length > 3 ? ` | and ${warnings.length - 3} more` : ''}`;
 }
+/** Uses the shared domain rules; unavailable sources stay unknown and never stop activation. */
+export async function checkCampaignMergeVariables(projectId, campaign, steps) {
+    const safe = async (load) => {
+        try {
+            return await load();
+        }
+        catch {
+            return null;
+        }
+    };
+    const contacts = await safe(() => contactPropertyKeys(projectId));
+    const events = campaign.trigger_event_name
+        ? await safe(() => eventKeysFromHistory(projectId, campaign.trigger_event_name)) : [];
+    const knowledge = {
+        eventKeys: events === null ? null : new Set(events),
+        contactPropertyKeys: contacts === null ? null : { keys: new Set(contacts.keys), complete: contacts.complete },
+    };
+    const checked_at = new Date().toISOString();
+    return steps.flatMap(step => findUnprovidedMergeTags({ subject: step.subject, html: step.body_html, text: step.body_text }, knowledge).map(finding => ({ ...finding, step_order: step.step_order, checked_at,
+        warning: finding.kind === 'unknown_event'
+            ? `Can't tell whether ${finding.tag} can be filled: event history is empty or couldn't be checked.`
+            : finding.kind === 'unknown_contacts'
+                ? `Couldn't check whether ${finding.tag} can be filled: the contact scan failed or is incomplete.`
+                : `${finding.tag} may print blank: ${finding.kind === 'no_event_data' ? 'no observed trigger event data provides it' : 'no contact has this property'}.`,
+    })));
+}
+/** One extra line on the approval, including explicit uncertainty for unknown sources. */
+export function summarizeMergeVariableWarnings(warnings) {
+    if (!warnings.length)
+        return undefined;
+    return `${warnings.length} merge variables may print blank: ${warnings.map(w => `${w.tag} (email ${w.step_order + 1}${w.kind.startsWith('unknown_') ? ": can't tell / couldn't check" : ''})`).join(', ')}`;
+}
+/** Best-effort note. Compare-and-swap preserves concurrent metadata edits; never gate activation. */
+export async function persistMergeVariableWarnings(projectId, campaignId, warnings) {
+    try {
+        const source = db().schema('email');
+        for (let attempt = 0; attempt < 3; attempt++) {
+            const { data: current, error: readError } = await source.from('campaigns').select('metadata')
+                .eq('id', campaignId).eq('project_id', projectId).maybeSingle();
+            if (readError || !current)
+                break;
+            const metadata = current.metadata;
+            const next = { ...(metadata ?? {}), merge_variable_warnings: warnings
+                    .filter(w => w.kind === 'no_event_data' || w.kind === 'no_contact_has_it')
+                    .map(({ tag, step_order, kind, checked_at }) => ({ tag, step_order, kind, checked_at })) };
+            let update = source.from('campaigns').update({ metadata: next }).eq('id', campaignId).eq('project_id', projectId);
+            update = metadata == null ? update.is('metadata', null) : update.eq('metadata', JSON.stringify(metadata));
+            const { data, error } = await update.select('id');
+            if (error)
+                break;
+            if (data?.length)
+                return;
+        }
+    }
+    catch { /* A failed note write must not prevent activation. */ }
+    console.error('[merge-variable-warnings] Could not save campaign warning note.');
+}

package/build/lib/db-error.d.ts

@@ -63,10 +63,14 @@ export declare function formatZodError(error: z.ZodError | {
         [key: string]: any;
     }>;
 }): string;
-/** Machine-code classification for api_usage only. Never rewrite response codes.
+/** Machine-code classification shared by tool results and api_usage. Never rewrite legacy codes.
  * Keys are case-insensitive; every supported legacy spelling is listed explicitly.
  * Existing usage-only policy classes remain supported alongside the six tool classes. */
 export declare const API_USAGE_ERROR_CODE_MAP: Readonly<Record<string, string>>;
+/** One classifier for the additive response class and hosted usage tracking. */
+export declare function classifyMachineCode(code: string): string | null;
+/** Classify a failed body, preserving any explicitly supplied error_code. */
+export declare function toolErrorClass(body: Record<string, unknown>): unknown;
 type ToolResult = {
     content: Array<{
         type: string;

package/build/lib/db-error.js

@@ -99,7 +99,7 @@ export function formatZodError(error) {
     }
     return messages.join(' ');
 }
-/** Machine-code classification for api_usage only. Never rewrite response codes.
+/** Machine-code classification shared by tool results and api_usage. Never rewrite legacy codes.
  * Keys are case-insensitive; every supported legacy spelling is listed explicitly.
  * Existing usage-only policy classes remain supported alongside the six tool classes. */
 export const API_USAGE_ERROR_CODE_MAP = {
@@ -111,6 +111,7 @@ export const API_USAGE_ERROR_CODE_MAP = {
     'bad_request': 'validation_failed',
     'campaigns_required': 'validation_failed',
     'content_required': 'validation_failed',
+    'content_not_ready': 'validation_failed',
     'empty_audience': 'validation_failed',
     'empty_body': 'validation_failed',
     'empty_cohort': 'validation_failed',
@@ -146,6 +147,7 @@ export const API_USAGE_ERROR_CODE_MAP = {
     'validation_failed': 'validation_failed',
     'approval_not_cancellable': 'conflict',
     'approval_not_pending': 'conflict',
+    'already_sent_to_audience': 'conflict',
     'human_decision_required': 'forbidden',
     '23505': 'conflict',
     'conflict': 'conflict',
@@ -209,10 +211,32 @@ export const API_USAGE_ERROR_CODE_MAP = {
     'step_create_failed': 'internal_error',
     'step_lookup_failed': 'internal_error',
     'survey_link_not_ready': 'internal_error',
+    'project_connector_unavailable': 'internal_error',
     'sandbox_blocked': 'sandbox_blocked',
     'send_allowlist_refused': 'send_allowlist_refused',
     'rate_limited': 'rate_limited',
 };
+/** One classifier for the additive response class and hosted usage tracking. */
+export function classifyMachineCode(code) {
+    const lower = code.toLowerCase().trim();
+    if (Object.hasOwn(API_USAGE_ERROR_CODE_MAP, lower))
+        return API_USAGE_ERROR_CODE_MAP[lower];
+    if (lower.endsWith('_not_found'))
+        return 'not_found';
+    if (lower.endsWith('_conflict'))
+        return 'conflict';
+    if (lower.endsWith('_limit_reached') || lower.endsWith('_limit'))
+        return 'plan_limit';
+    return null;
+}
+/** Classify a failed body, preserving any explicitly supplied error_code. */
+export function toolErrorClass(body) {
+    if ('error_code' in body)
+        return body.error_code;
+    if (typeof body.code !== 'string')
+        return 'internal_error';
+    return classifyMachineCode(body.code);
+}
 /** Add a stable class to refusals without dropping existing fields or success data. */
 export function codedToolResult(result) {
     let failed = result.isError === true;
@@ -242,18 +266,21 @@ export function codedToolResult(result) {
             return block;
         failed = true;
         // An existing code is a frozen client surface, even when it is unfamiliar.
-        if ('code' in body)
-            return block;
+        if ('code' in body) {
+            if ('error_code' in body)
+                return block;
+            return { ...block, text: JSON.stringify({ ...body, error_code: toolErrorClass(body) }, null, block.text.includes('\n') ? 2 : undefined) };
+        }
         const nestedCode = body.error && typeof body.error === 'object' ? body.error.code : undefined;
         const nestedClass = typeof nestedCode === 'string' ? nestedCode.toLowerCase() : undefined;
         const code = textCode ?? (TOOL_ERROR_CODES.includes(nestedClass) ? nestedClass
             : (body.status === 404 ? 'not_found'
                 : body.status === 409 ? 'conflict' : body.status === 422 ? 'validation_failed'
                     : body.status === 401 || body.status === 403 ? 'forbidden' : 'internal_error'));
-        return { ...block, text: JSON.stringify({ ...body, code }, null, block.text.includes('\n') ? 2 : undefined) };
+        return { ...block, text: JSON.stringify({ ...body, code, error_code: toolErrorClass({ ...body, code }) }, null, block.text.includes('\n') ? 2 : undefined) };
     });
     if (failed && !content.some(block => block.type === 'text')) {
-        content.push({ type: 'text', text: JSON.stringify(mapDbError(undefined)) });
+        content.push({ type: 'text', text: JSON.stringify({ ...mapDbError(undefined), error_code: toolErrorClass(mapDbError(undefined)) }) });
     }
     return failed ? { ...result, isError: true, content } : result;
 }
@@ -266,7 +293,7 @@ export function withToolErrors(handler) {
         catch (error) {
             if (error instanceof McpError && error.code === ErrorCode.UrlElicitationRequired)
                 throw error;
-            return dbErrorResult(error);
+            return codedToolResult(dbErrorResult(error));
         }
     };
 }

package/build/tools/campaign-sets.js

@@ -11,7 +11,7 @@ import { generateEmailFromBrief } from '../lib/email-generation.js';
 import { fireWebhookEvent } from '../lib/webhook-events.js';
 import { logAudit } from '../audit.js';
 import { applyCampaignTargetingFields, campaignTriggerKind } from './campaigns.js';
-import { checkCampaignContent, contentNotReadyResponse, contentWarningView, summarizeContentWarnings } from '../lib/content-sources.js';
+import { checkCampaignMergeVariables, persistMergeVariableWarnings, summarizeMergeVariableWarnings, checkCampaignContent, contentNotReadyResponse, contentWarningView, summarizeContentWarnings } from '../lib/content-sources.js';
 import { captureBroadcastAudience } from '../lib/approval-snapshot.js';
 import { dbToolError } from '../lib/db-error.js';
 /**
@@ -291,9 +291,11 @@ export function registerCampaignSetTools(server) {
         const projectId = getProjectId();
         const { approval_id } = args;
         async function applyCampaigns(set, ids, approval_id, decidedBy) {
+            const mergeVariableWarnings = [];
             const activated = [];
             const failed = [];
             for (const c of set.campaigns) {
+                const warnings = await checkCampaignMergeVariables(projectId, c, set.steps.filter(s => s.campaign_id === c.id));
                 const { error } = await db()
                     .from('campaigns')
                     .update({ status: 'active', updated_at: new Date().toISOString() })
@@ -305,12 +307,15 @@ export function registerCampaignSetTools(server) {
                     continue;
                 }
                 activated.push(c.id);
+                await persistMergeVariableWarnings(projectId, c.id, warnings);
+                mergeVariableWarnings.push(...warnings.map(w => ({ ...w, campaign_id: c.id })));
                 fireWebhookEvent('campaign.activated', { campaign_id: c.id, campaign_name: c.name, status: 'active' }).catch(() => { });
             }
             await logAudit({ action: 'campaign.set_activated', resourceType: 'campaign_set', resourceId: approval_id, details: { approval_id, decided_by: decidedBy ?? null, activated, failed, source: 'mcp' } }).catch(() => { });
             return j({
                 activated,
                 failed,
+                merge_variable_warnings: mergeVariableWarnings,
                 ...(set.campaigns.some(c => c.type === 'broadcast') ? {
                     campaigns: previewOf(set.campaigns.filter(c => activated.includes(c.id)).map(c => ({ ...c, status: 'active' })), set.steps),
                     broadcast_activation: BROADCAST_ACTIVATION,
@@ -348,7 +353,7 @@ export function registerCampaignSetTools(server) {
                 return j({ error: 'this campaign has no trigger, so it would never fire', code: 'validation_failed' });
             }
             // Same content gate as the request, so a bad email can't ride through on an old approval.
-            const readiness = await checkCampaignContent(projectId, current.campaigns, current.steps);
+            const readiness = await checkCampaignContent(projectId, current.campaigns, current.steps, { mergeVariables: false });
             if (readiness.blocking.length)
                 return j(contentNotReadyResponse(readiness.blocking));
             const check = await checkApproval(approval_id, { consume: true, action: 'activate_campaigns', params: stored });
@@ -396,10 +401,12 @@ export function registerCampaignSetTools(server) {
             });
         }
         // Placeholder text and links to the sending domain never go out (#3853). Merge tags with no data source are warnings.
-        const readiness = await checkCampaignContent(projectId, set.campaigns, set.steps);
+        const readiness = await checkCampaignContent(projectId, set.campaigns, set.steps, { mergeVariables: false });
         if (readiness.blocking.length)
             return j(contentNotReadyResponse(readiness.blocking));
         const contentWarnings = contentWarningView(readiness.warnings, readiness.lookup_errors);
+        const mergeVariableWarnings = (await Promise.all(set.campaigns.map(async (c) => (await checkCampaignMergeVariables(projectId, c, set.steps.filter(s => s.campaign_id === c.id)))
+            .map(w => ({ ...w, campaign_id: c.id }))))).flat();
         const approvalParams = { campaign_ids: [...ids].sort(), content_hash: campaignSetContentHash(set.campaigns, set.steps) };
         const channelContext = currentChannelContext();
         const decision = await assertChannelCanExecute('activate_campaigns', approvalParams, channelContext);
@@ -409,6 +416,7 @@ export function registerCampaignSetTools(server) {
             return applyCampaigns(set, ids);
         const names = set.campaigns.map((c) => c.name);
         const approval = await requestApproval('activate_campaigns', approvalParams, undefined, channelContext, {
+            merge_variable_summary: summarizeMergeVariableWarnings(mergeVariableWarnings),
             campaign_count: set.campaigns.length,
             email_count: set.steps.length,
             campaign_names: names.slice(0, 10).join(', ') + (names.length > 10 ? `, and ${names.length - 10} more` : ''),
@@ -417,6 +425,7 @@ export function registerCampaignSetTools(server) {
         return j({
             ...approval,
             campaigns: previewOf(set.campaigns, set.steps),
+            merge_variable_warnings: mergeVariableWarnings,
             ...(contentWarnings.length ? { content_warnings: contentWarnings } : {}),
             next: approvalNext('activate_campaigns', approval),
         });

package/build/tools/campaigns.js

@@ -32,7 +32,7 @@ import { getScheduleWindowBounds, groupScheduleByCampaign, parseFutureDate } fro
 import { sendEmailForSite } from '../lib/email-provider.js';
 import { resolveSurveyShortLink } from '../lib/survey-link-resolver.js';
 import { logAudit } from '../audit.js';
-import { checkCampaignContent, contactPropertyKeys, eventKeysFromHistory, contentNotReadyResponse, contentWarningView, summarizeContentWarnings } from '../lib/content-sources.js';
+import { checkCampaignMergeVariables, persistMergeVariableWarnings, summarizeMergeVariableWarnings, checkCampaignContent, contactPropertyKeys, eventKeysFromHistory, contentNotReadyResponse, contentWarningView, summarizeContentWarnings } from '../lib/content-sources.js';
 import { recordBrandAssetUsage } from '../lib/brand-asset-usage.js';
 import { BLOCK_GENERATION_SCHEMA, blocksToHtml, blocksToText, normalizeComposerBlocks } from '../lib/composer-blocks.js';
 import { callSendinelV1 } from '../lib/v1-client.js';
@@ -1189,6 +1189,7 @@ export function registerCampaignTools(server) {
             approval_id: z.string().uuid().optional().describe('Required when activating. Get this by calling once without it, then have a human approve.'),
         },
     }, async ({ campaign_id, status, approval_id }) => {
+        let mergeVariableWarnings = [];
         // Human approval required for activation
         if (status === 'active') {
             // An imported email whose wait wasn't in the source has no delay; it would never send (#3689).
@@ -1227,10 +1228,11 @@ export function registerCampaignTools(server) {
                     .eq('campaign_id', campaign_id);
                 if (contentErr)
                     return j({ error: `Could not check the campaign's emails: ${dbToolError(contentErr).error}`, code: 'STEP_LOOKUP_FAILED' });
-                const readiness = await checkCampaignContent(getProjectId(), [campRow], contentSteps ?? []);
+                const readiness = await checkCampaignContent(getProjectId(), [campRow], contentSteps ?? [], { mergeVariables: false });
                 if (readiness.blocking.length)
                     return j(contentNotReadyResponse(readiness.blocking));
                 contentWarnings = contentWarningView(readiness.warnings, readiness.lookup_errors);
+                mergeVariableWarnings = await checkCampaignMergeVariables(getProjectId(), campRow, contentSteps ?? []);
             }
             const approvalParams = { campaign_id, status };
             if (!approval_id) {
@@ -1246,12 +1248,13 @@ export function registerCampaignTools(server) {
                         .eq('project_id', getProjectId())
                         .maybeSingle();
                     const approval = await requestApproval('update_campaign_status', approvalParams, undefined, channelContext, {
+                        merge_variable_summary: summarizeMergeVariableWarnings(mergeVariableWarnings),
                         campaign_name: camp?.name ?? null,
                         enrolled: typeof camp?.total_enrolled === 'number' ? camp.total_enrolled : null,
                         trigger: camp?.trigger_event_name ?? (camp?.trigger_tag ? `tag ${camp.trigger_tag}` : null),
                         ...(contentWarnings.length ? { content_warnings: summarizeContentWarnings(contentWarnings) } : {}),
                     });
-                    return j(contentWarnings.length ? { ...approval, content_warnings: contentWarnings } : approval);
+                    return j({ ...approval, merge_variable_warnings: mergeVariableWarnings, ...(contentWarnings.length ? { content_warnings: contentWarnings } : {}) });
                 }
             }
             else {
@@ -1269,6 +1272,11 @@ export function registerCampaignTools(server) {
             .single();
         if (error)
             return { content: [{ type: 'text', text: `Error: ${dbToolError(error).error}` }] };
+        if (status === 'active') {
+            await persistMergeVariableWarnings(getProjectId(), campaign_id, mergeVariableWarnings);
+            await logAudit({ action: 'campaign.status_changed', resourceType: 'campaign', resourceId: campaign_id,
+                details: { status, merge_variable_warnings: mergeVariableWarnings } }).catch(() => { });
+        }
         // Fire webhook for status changes
         const eventMap = { active: 'campaign.activated', completed: 'campaign.completed', paused: 'campaign.paused' };
         if (eventMap[status]) {
@@ -1278,7 +1286,7 @@ export function registerCampaignTools(server) {
                 status,
             }).catch(() => { });
         }
-        return { content: [{ type: 'text', text: JSON.stringify(campaignMetricsView(data), null, 2) }] };
+        return { content: [{ type: 'text', text: JSON.stringify({ ...campaignMetricsView(data), ...(status === 'active' ? { merge_variable_warnings: mergeVariableWarnings } : {}) }, null, 2) }] };
     });
     server.registerTool('enroll_contact', {
         title: 'Enroll Contact',
@@ -3411,6 +3419,7 @@ Return ONLY valid JSON with this exact shape:
         if (reentry.period_key !== undefined)
             targeting.period_key = reentry.period_key;
         const canActivateOnTrigger = campaignType === 'triggered' && (hasEventOrTag || targeting.trigger_type === 'date_field' || targeting.trigger_type === 'contact_event');
+        let mergeVariableWarnings = activate && !approval_id ? await checkCampaignMergeVariables(getProjectId(), { trigger_event_name: typeof targeting.trigger_event_name === 'string' ? targeting.trigger_event_name : null }, steps.map((step, step_order) => ({ ...step, step_order }))) : [];
         // Human-in-the-loop gate for activation
         if (activate && confirmed) {
             const approvalParams = { site_id, name, type, steps, segment_id, sends_per_hour, activate, send_class, unsub_footer_template, reentry_mode, period_key, ...triggerInput };
@@ -3421,8 +3430,8 @@ Return ONLY valid JSON with this exact shape:
             if (decision.tier !== 'autonomous') {
                 if (!approval_id) {
                     // No approval token — request one
-                    const approval = await requestApproval('create_campaign_with_content', approvalParams, undefined, channelContext);
-                    return j(approval);
+                    const approval = await requestApproval('create_campaign_with_content', approvalParams, undefined, channelContext, { merge_variable_summary: summarizeMergeVariableWarnings(mergeVariableWarnings) });
+                    return j({ ...approval, merge_variable_warnings: mergeVariableWarnings });
                 }
                 // Have a token — verify it's approved
                 const status = await checkApproval(approval_id, { consume: true, action: 'create_campaign_with_content', params: approvalParams });
@@ -3459,6 +3468,7 @@ Return ONLY valid JSON with this exact shape:
         if (!confirmed) {
             return j({
                 confirmation_required: true,
+                ...(activate ? { merge_variable_warnings: mergeVariableWarnings } : {}),
                 campaign: { name, type: campaignType, site: site.name, send_class: sendClass, unsub_footer_template: footerTemplate, ...targeting },
                 steps: steps.map((s, i) => ({
                     step: i + 1,
@@ -3559,6 +3569,8 @@ Return ONLY valid JSON with this exact shape:
         // 4. Activate if requested
         const willActivate = Boolean(activate && ((segment_id && enrolled > 0) || canActivateOnTrigger));
         if (willActivate) {
+            mergeVariableWarnings = await checkCampaignMergeVariables(getProjectId(), { trigger_event_name: typeof targeting.trigger_event_name === 'string' ? targeting.trigger_event_name : null }, stepInserts);
+            await persistMergeVariableWarnings(getProjectId(), campaign.id, mergeVariableWarnings);
             await db()
                 .from('campaigns')
                 .update({ status: 'active' })
@@ -3586,6 +3598,7 @@ Return ONLY valid JSON with this exact shape:
             steps_created: steps.length,
             contacts_enrolled: enrolled,
             status: willActivate ? 'active' : 'draft',
+            ...(willActivate ? { merge_variable_warnings: mergeVariableWarnings } : {}),
             message: `Campaign "${name}" created with ${steps.length} step(s). ${enrolled > 0 ? `${enrolled} contacts enrolled.` : 'No contacts enrolled.'} ${willActivate ? 'Campaign is now active — emails will begin sending on the next cron cycle.' : 'Campaign saved as draft.'}`,
         });
     });
@@ -4089,6 +4102,7 @@ Return ONLY valid JSON with this exact shape:
         const unresolvedCount = dlqUnresolvedCount ?? 0;
         return j({
             ...campaignMetricsView(campaign),
+            merge_variable_warnings: campaign.metadata?.merge_variable_warnings ?? [],
             reentry_mode: campaign.period_key ? "per_event_period" : "once_ever",
             requires_approval_description: ACTIVATION_APPROVAL_DESCRIPTION,
             ...await campaignTriggerOutput(campaign),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sendinel/mcp-server",
-  "version": "1.0.216",
+  "version": "1.0.218",
   "description": "AI-controlled email operations control plane for campaigns, contacts, segments, analytics, and multi-provider sending via MCP.",
   "mcpName": "ai.sendinel/mcp-server",
   "type": "module",