@sendinel/mcp-server 1.0.141 → 1.0.143

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

@@ -50,6 +50,8 @@ export interface ApprovalResult {
     summary: string;
     expires_at: string;
     approve_via: string;
+    decided_via?: 'sandbox';
+    decided_by?: null;
     /** One-tap approval page; works on a phone and needs no project switching (#3661). */
     approve_url: string;
     preview_text: string;

package/build/lib/action-approvals.js

@@ -137,7 +137,7 @@ export function approvalExcerpt(html, max = 200) {
 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 count = typeof d.recipient_count === 'number' ? `${d.recipient_count.toLocaleString('en-US')} recipient${d.recipient_count === 1 ? '' : 's'}` : d.recipient_count === null ? 'unknown recipients' : 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}"` : '';
@@ -323,11 +323,13 @@ export async function requestApproval(action, params, apiKeyId, channelContext,
         }
         catch { /* Missing display data omits the project line. */ }
     const approveUrl = approvalPageUrl(data.id);
-    const previewText = buildApprovalPreview({ action, params: frozenParams, summary, projectName }).plain_summary;
+    const previewText = buildApprovalPreview({ action, params: frozenParams, summary, projectName, ...(display && 'recipient_count' in display ? { recipientCount: display.recipient_count } : {}) }).plain_summary;
     if (sandboxApproved) {
         return { requires_approval: true, approval_id: data.id, tier, action, summary, expires_at: expiresAt,
-            approve_via: 'sandbox', approve_url: approveUrl, preview_text: previewText, decision_status: 'approved',
-            message: 'Sandbox project: approved automatically\nCall this tool again with the same arguments plus approval_id to run it.' };
+            approve_via: 'sandbox', decided_via: 'sandbox', decided_by: null, approve_url: approveUrl, preview_text: previewText, decision_status: 'approved',
+            message: action === 'send_broadcast'
+                ? 'Sandbox project: approved automatically (no person decided it). Call send_broadcast again with only approval_id to send.'
+                : 'Sandbox project: approved automatically\nCall this tool again with the same arguments plus approval_id to run it.' };
     }
     const chatGuidance = tier === 'gated' && await humanApprovalEligible(action, getProjectId(), actor, true)
         ? `\nAsk the user in plain chat: "${previewText.split('\n')[0].trim()}". Only after they say yes, call confirm_approval with approval_id, action, echo (the first line of preview_text) and user_reply (their exact words), then call the original tool again with approval_id.`

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

@@ -0,0 +1,30 @@
+/** Display only: never narrow or otherwise change the frozen enrollment payload. */
+export declare function sandboxAudience(projectId: string, contactIds: string[]): Promise<{
+    recipient_count: number;
+    audience_matched_count?: undefined;
+    sandbox?: undefined;
+} | {
+    recipient_count: number;
+    audience_matched_count: number;
+    sandbox: {
+        active: true;
+        allowed_domains: string[] | null;
+        filtered_out: number;
+        count_unknown?: undefined;
+    };
+} | {
+    recipient_count: null;
+    audience_matched_count: number;
+    sandbox: {
+        active: boolean | null;
+        allowed_domains: string[] | null;
+        filtered_out: null;
+        count_unknown: boolean;
+    };
+}>;
+export declare function broadcastApprovalNext(approval: {
+    approve_via?: string;
+    decision_status?: string;
+}, sandbox?: {
+    allowed_domains: string[] | null;
+}): string;

package/build/lib/sandbox-audience.js

@@ -0,0 +1,48 @@
+import { chunkIds, isSandboxDomain, matchSandboxDomains, readAllRows } from '@sendinel/domain';
+import { adminDb, db } from '../db.js';
+/** Display only: never narrow or otherwise change the frozen enrollment payload. */
+export async function sandboxAudience(projectId, contactIds) {
+    let active = null;
+    let allowedDomains = null;
+    try {
+        const { data, error } = await adminDb().schema('email').from('projects')
+            .select('sandbox_mode, sandbox_allowed_domains').eq('id', projectId).maybeSingle();
+        if (error || !data || typeof data.sandbox_mode !== 'boolean')
+            throw new Error('Sandbox policy unavailable');
+        active = data.sandbox_mode;
+        if (!active)
+            return { recipient_count: contactIds.length };
+        if (!Array.isArray(data.sandbox_allowed_domains) || !data.sandbox_allowed_domains.every(isSandboxDomain)) {
+            throw new Error('Sandbox domains unavailable');
+        }
+        allowedDomains = data.sandbox_allowed_domains;
+        const emails = new Map();
+        for (const chunk of chunkIds(contactIds)) {
+            const rows = await readAllRows(db().schema('email').from('subscribers').select('id, email').eq('project_id', projectId).in('id', chunk));
+            for (const row of rows) {
+                if (typeof row.email !== 'string')
+                    throw new Error('Contact email unavailable');
+                emails.set(row.id, row.email);
+            }
+        }
+        if (contactIds.some(id => !emails.has(id)))
+            throw new Error('Contact lookup incomplete');
+        const count = contactIds.filter(id => !matchSandboxDomains(allowedDomains, { to: emails.get(id) })).length;
+        return { recipient_count: count, audience_matched_count: contactIds.length,
+            sandbox: { active, allowed_domains: allowedDomains, filtered_out: contactIds.length - count } };
+    }
+    catch {
+        return { recipient_count: null, audience_matched_count: contactIds.length,
+            sandbox: { active, allowed_domains: allowedDomains, filtered_out: null, count_unknown: true } };
+    }
+}
+export function broadcastApprovalNext(approval, sandbox) {
+    if (approval.approve_via === 'sandbox' && approval.decision_status === 'approved') {
+        const domains = sandbox?.allowed_domains;
+        return 'Sandbox project: this was approved automatically (no person decided it). Call send_broadcast again with only approval_id to send. ' +
+            (domains ? domains.length ? `Only recipients on ${domains.join(', ')} can be delivered, subject to send-time policy checks.` : 'No sandbox domains are allowed; no recipients can be delivered.'
+                : 'Sandbox domains could not be loaded; the deliverable recipient count is unknown.') +
+            ' Do not say it was sent before that call succeeds.';
+    }
+    return 'Show the user the subject, recipient count and approve_url. After a person approves, call send_broadcast with only approval_id. Do not say it was sent before that call succeeds.';
+}

package/build/tools/ab-testing.js

@@ -13,7 +13,7 @@ export function registerAbTestingTools(server) {
             idempotentHint: false,
             openWorldHint: false,
         },
-        description: 'Create an A/B test for a campaign step. Requires at least 2 variant steps (add via add_campaign_step with variant_label). Returns the test config for review.',
+        description: 'Create an A/B test for a campaign step. Requires a non-blank subject and body on every variant, and at least 2 variant steps (add via add_campaign_step with variant_label). Returns the test config for review.',
         inputSchema: {
             campaign_id: z.string().uuid(),
             step_order: z.number().int().min(0).optional().default(0).describe('Which step to test (default: 0, the first email)'),
@@ -38,13 +38,20 @@ export function registerAbTestingTools(server) {
         // Check variant steps exist
         const { data: steps } = await db()
             .from('campaign_steps')
-            .select('id, variant_label, subject')
+            .select('id, variant_label, subject, body_html, body_text')
             .eq('campaign_id', campaign_id)
             .eq('step_order', step_order ?? 0);
         const variantLabels = (steps ?? []).map((s) => s.variant_label);
         if (variantLabels.length < 2) {
             return txt(`Error: Need at least 2 variant steps for step_order ${step_order ?? 0}. Found: [${variantLabels.join(', ')}]. Add more variants via add_campaign_step with variant_label parameter.`);
         }
+        const emptyVariants = (steps ?? []).filter((step) => !step.subject?.trim() || !(step.body_html?.trim() || step.body_text?.trim()));
+        if (emptyVariants.length) {
+            return j({
+                error: `Variant(s) [${emptyVariants.map((step) => step.variant_label).join(', ')}] for step_order ${step_order ?? 0} need a non-blank subject and body. Add content with add_campaign_step before creating the test.`,
+                code: 'validation_failed',
+            });
+        }
         // Check no existing test for this step
         const { data: existing } = await db()
             .from('ab_tests')

package/build/tools/approvals.js

@@ -48,7 +48,7 @@ export function registerApprovalTools(server, options) {
     }, async () => {
         const { data, error } = await db()
             .from('action_approvals')
-            .select('id, action, tier, channel, summary, status, requested_at, expires_at')
+            .select('id, action, tier, channel, summary, status, requested_at, expires_at, decided_via, decided_by')
             .eq('project_id', getProjectId())
             .eq('status', 'pending')
             .gt('expires_at', new Date().toISOString())
@@ -56,6 +56,6 @@ export function registerApprovalTools(server, options) {
             .limit(25);
         if (error)
             return toolError(dbToolError(error));
-        return j({ pending: data ?? [], count: data?.length ?? 0 });
+        return j({ pending: (data ?? []).map((row) => ({ ...row, ...(row.decided_via === 'sandbox' ? { decision_channel: 'sandbox' } : {}) })), count: data?.length ?? 0 });
     });
 }

package/build/tools/campaigns.js

@@ -18,6 +18,7 @@ import { checkPlanLimit } from '../plan-limits.js';
 import { buildVoicePrompt, buildEmailSystemPrompt, deriveTemplateVariables, validateTemplate } from '../lib/voice.js';
 import { fireWebhookEvent } from '../lib/webhook-events.js';
 import { approvalExcerpt, assertChannelCanExecute, currentChannelContext, requestApproval, checkApproval, withApproval } from '../lib/action-approvals.js';
+import { sandboxAudience, broadcastApprovalNext } from '../lib/sandbox-audience.js';
 import { resolveSegmentContactIds, resolveSendAudience } from '../lib/send-audience.js';
 import { generateEmailFromBrief, parseAudienceRules } from '../lib/email-generation.js';
 import { getAnthropicModelId } from '../anthropic-model.js';
@@ -137,6 +138,9 @@ export function buildCampaignTriggerDiagnostics(campaign, seenEvents) {
     if ((campaign.trigger_type === 'date_field' || campaign.trigger_type === 'contact_event') && (events.length || tags.length) && campaign.type === 'triggered') {
         diagnostics.push(`trigger_type is "${String(campaign.trigger_type)}" but event/tag triggers are also set; event intake will start it immediately, outside the ${String(campaign.trigger_type)} schedule`);
     }
+    if (campaign.type === 'triggered' && campaignTriggerKind(campaign) === 'manual' && !campaign.segment_id) {
+        diagnostics.push('campaign type is "triggered" but no trigger is set (it will never fire)');
+    }
     if (campaign.status !== 'active') {
         diagnostics.push(`it is ${String(campaign.status)}, so nothing starts until it is active`);
     }
@@ -855,7 +859,7 @@ export function registerCampaignTools(server) {
             .single();
         if (error)
             return { content: [{ type: 'text', text: `Error: ${error.message}` }] };
-        return { content: [{ type: 'text', text: JSON.stringify({ ...data, requires_approval_description: ACTIVATION_APPROVAL_DESCRIPTION }, null, 2) }] };
+        return { content: [{ type: 'text', text: JSON.stringify({ ...data, requires_approval_description: ACTIVATION_APPROVAL_DESCRIPTION, fires_on: buildCampaignFiresOn(data), trigger_diagnostics: buildCampaignTriggerDiagnostics(data) }, null, 2) }] };
     });
     const propertyConditions = z.array(z.union([
         z.object({ key: z.string(), op: z.enum(['eq', 'neq']), value: z.string() }).strict(),
@@ -869,7 +873,7 @@ export function registerCampaignTools(server) {
             idempotentHint: false,
             openWorldHint: false,
         },
-        description: 'Add an email step to a campaign. For A/B testing, add multiple steps with the same step_order but different variant_label values.',
+        description: 'Add an email step to a campaign. Requires a non-blank subject and body_html, body_text, or blocks that render to content. For A/B testing, add multiple steps with the same step_order but different variant_label values.',
         inputSchema: {
             campaign_id: z.string().uuid(),
             step_order: z.number().int().min(0).describe('Position in sequence (0 = first)'),
@@ -892,6 +896,16 @@ export function registerCampaignTools(server) {
             const properties = validateStepPropertyRules({ skip_if_property, send_only_if_property });
             if (!properties.ok)
                 return j({ error: properties.error, code: "INVALID_INPUT" });
+            const normalizedBlocks = blocks ? normalizeComposerBlocks(blocks) : undefined;
+            const htmlFromBlocks = normalizedBlocks?.length ? blocksToHtml(normalizedBlocks) : undefined;
+            if (!subject.trim())
+                return j({ error: 'A step needs a non-blank subject.', code: 'validation_failed' });
+            const hasBody = body_html?.trim() || body_text?.trim()
+                || htmlFromBlocks?.replace(/<[^>]*>/g, '').trim()
+                || normalizedBlocks?.some((block) => block.type === 'image' && block.url);
+            if (!hasBody) {
+                return j({ error: 'A step needs body_html or body_text (or blocks that render to content).', code: 'validation_failed' });
+            }
             const { data: campaign, error: campaignError } = await db()
                 .schema('email')
                 .from('campaigns')
@@ -911,8 +925,6 @@ export function registerCampaignTools(server) {
                 renderVars.survey_link = surveyLink;
             }
             const renderedSubject = survey_id ? renderTemplateVars(subject, renderVars) : subject;
-            const normalizedBlocks = blocks ? normalizeComposerBlocks(blocks) : undefined;
-            const htmlFromBlocks = normalizedBlocks?.length ? blocksToHtml(normalizedBlocks) : undefined;
             const renderedHtml = body_html !== undefined && survey_id ? renderTemplateVars(body_html, renderVars) : body_html ?? htmlFromBlocks;
             const renderedText = body_text !== undefined && survey_id ? renderTemplateVars(body_text, renderVars) : body_text;
             const { data, error } = await db()
@@ -975,12 +987,15 @@ export function registerCampaignTools(server) {
             // Placeholder text and links to the sending domain never go out (#3853).
             const { data: campRow, error: campErr } = await db()
                 .from('campaigns')
-                .select('id, name, site_id, trigger_event_name')
+                .select('id, name, site_id, type, trigger_type, trigger_event_name, trigger_tag, trigger_config, segment_id')
                 .eq('id', campaign_id)
                 .eq('project_id', getProjectId())
                 .maybeSingle();
             if (campErr)
                 return j({ error: `Could not check the campaign: ${campErr.message}`, code: 'CAMPAIGN_LOOKUP_FAILED' });
+            if (campRow?.type === 'triggered' && campaignTriggerKind(campRow) === 'manual' && !campRow.segment_id) {
+                return j({ error: 'This triggered campaign has no trigger. Set an event, tag, date, contact event, or segment before activating it.', code: 'validation_failed' });
+            }
             let contentWarnings = [];
             if (campRow) {
                 const { data: contentSteps, error: contentErr } = await db()
@@ -1564,6 +1579,7 @@ export function registerCampaignTools(server) {
         else {
             content = { subject: subject, body_html: html, body_text: body_text ?? approvalExcerpt(html, 100000), blocks: null };
         }
+        const delivery = await sandboxAudience(projectId, resolved.contactIds);
         const campaignName = name ?? `Broadcast - ${content.subject.slice(0, 120)}`;
         const payload = {
             site_id: site.id,
@@ -1589,18 +1605,18 @@ export function registerCampaignTools(server) {
             subject: content.subject,
             segment_name: segment_id ? segmentName : null,
             audience_label: segment_id ? null : `"${segmentName}"`,
-            recipient_count: resolved.contactIds.length,
+            recipient_count: delivery.recipient_count,
             body_excerpt: approvalExcerpt(content.body_html),
             send_at: sendAt,
         });
         return j({
             ...approval,
             rendered: { subject: content.subject, body_html: stripActiveEmailContent(content.body_html).html, body_text: content.body_text },
-            recipient_count: resolved.contactIds.length,
+            ...delivery,
             audience: { label: segmentName, segment_id: segment_id ?? null, ...heldBackLines(resolved) },
             site: { id: site.id, name: site.name, from_email: site.from_email },
             send_at: sendAt ?? 'right after approval',
-            next: 'Show the user the subject, recipient count and approve_url. After a person approves, call send_broadcast with only approval_id. Do not say it was sent before that call succeeds.',
+            next: broadcastApprovalNext(approval, delivery.sandbox),
         });
     });
     server.registerTool('clone_campaign', {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sendinel/mcp-server",
-  "version": "1.0.141",
+  "version": "1.0.143",
   "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",