@sendinel/mcp-server 1.0.36 → 1.0.38

package/build/lib/action-approvals.js

@@ -152,10 +152,26 @@ function broadcastSummary(d) {
     const excerpt = d.body_excerpt ? ` — "${d.body_excerpt}"` : '';
     return `Send "${d.subject}" to ${audience}${count ? ` (${count})` : ''}${when}${excerpt}`;
 }
+/**
+ * launch_campaign approvals carry the written emails in params.generated (#3669), so the summary
+ * can name what goes out. Null for an older approval that has only the briefs.
+ */
+function launchSummary(p, d) {
+    const generated = (p.generated ?? {});
+    const steps = Array.isArray(generated.steps) ? generated.steps : [];
+    if (!steps.length)
+        return null;
+    const subjects = steps.map((step, i) => `${i + 1}. "${approvalExcerpt(step?.subject, 120)}"`).join(' ');
+    const count = Array.isArray(generated.contact_ids) ? generated.contact_ids.length : null;
+    const people = count === null ? 'real contacts' : `${count.toLocaleString('en-US')} contact${count === 1 ? '' : 's'}`;
+    const audience = d.segment_name ? ` in segment "${d.segment_name}"` : (d.audience_label ? ` matching ${d.audience_label}` : '');
+    const excerpt = approvalExcerpt(steps[0]?.body_html);
+    return `Launch campaign "${p.name || 'unknown'}": ${steps.length} email${steps.length === 1 ? '' : 's'} to ${people}${audience} — ${subjects}${excerpt ? ` — first email: "${excerpt}"` : ''}`;
+}
 /** Build a human-readable summary of the action for the approval screen */
 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`,
+        launch_campaign: (p) => launchSummary(p, display) ?? `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'}`,
         install_connector_view: (p) => `Reinstall the customer-side contact view for project ${p.project_id ?? 'current'}`,
         set_connector_mapping: () => `Rewrite the BYOD connector field mapping`,

package/build/tools/campaigns.js

@@ -1525,7 +1525,7 @@ Adapt your tone accordingly:
             idempotentHint: false,
             openWorldHint: true,
         },
-        description: 'Full campaign lifecycle in one call: create segment (from NL or existing), create campaign, generate emails from briefs, enroll contacts, activate. Requires human approval via the dashboard before confirmed execution.',
+        description: 'Full campaign lifecycle: create segment (from NL or existing), create campaign, generate emails from briefs, enroll contacts, activate. Call with confirmed=true to write the emails and get an approval_id; a person approves those exact emails; call again with the same arguments plus approval_id to launch them. Nothing is created or sent before approval.',
         inputSchema: {
             name: z.string().min(1).describe('Campaign name'),
             site_id: z.string().uuid(),
@@ -1544,12 +1544,10 @@ Adapt your tone accordingly:
     }, async ({ name, site_id, type, segment_description, segment_id, emails, sends_per_hour, confirmed, approval_id }) => {
         if (!segment_description && !segment_id)
             return txt('Provide segment_description or segment_id.');
-        const apiKey = process.env.ANTHROPIC_API_KEY;
-        if (!apiKey)
-            return txt('Error: ANTHROPIC_API_KEY not configured');
-        const anthropic = new Anthropic({ apiKey });
         const projectId = getProjectId();
-        const approvalParams = {
+        // What the caller asked for. An approval is checked against these, so the approved call must
+        // repeat them unchanged.
+        const requestParams = {
             name,
             site_id,
             type: type ?? 'sequence',
@@ -1558,22 +1556,125 @@ Adapt your tone accordingly:
             emails,
             sends_per_hour,
         };
+        function readLaunchPlan(value) {
+            if (!value || typeof value !== 'object' || Array.isArray(value))
+                return null;
+            const plan = value;
+            if (!plan.rules || typeof plan.rules !== 'object' || Array.isArray(plan.rules))
+                return null;
+            if (!Array.isArray(plan.contact_ids) || !Array.isArray(plan.steps) || plan.steps.length === 0)
+                return null;
+            const steps = [];
+            for (const raw of plan.steps) {
+                if (!raw || typeof raw.subject !== 'string' || !raw.subject.trim() || typeof raw.body_html !== 'string' || !raw.body_html.trim())
+                    return null;
+                steps.push({
+                    subject: raw.subject,
+                    body_html: raw.body_html,
+                    body_text: typeof raw.body_text === 'string' ? raw.body_text : null,
+                    blocks: Array.isArray(raw.blocks) ? raw.blocks : null,
+                    delay_days: typeof raw.delay_days === 'number' ? raw.delay_days : 0,
+                    delay_hours: typeof raw.delay_hours === 'number' ? raw.delay_hours : 0,
+                });
+            }
+            return {
+                rules: plan.rules,
+                segment_name: typeof plan.segment_name === 'string' ? plan.segment_name : `${name} — segment`,
+                contact_ids: plan.contact_ids.map(String),
+                steps,
+            };
+        }
+        // Creates the segment (when the audience was described in words), the campaign and its steps,
+        // enrolls the given people and activates. Uses only the plan: no model call happens here.
+        async function launchFromPlan(plan) {
+            let segId = segment_id;
+            if (segment_description) {
+                const { data: seg, error: segErr } = await db()
+                    .from('segments')
+                    .insert({ project_id: projectId, name: plan.segment_name, description: segment_description, rules: plan.rules })
+                    .select('id')
+                    .single();
+                if (segErr)
+                    return txt(`Error creating segment: ${segErr.message}`);
+                segId = seg.id;
+            }
+            const campLimit = await checkPlanLimit('active_campaigns');
+            if (!campLimit.allowed)
+                return txt(`Active campaign limit reached (${campLimit.current}/${campLimit.limit}).`);
+            const { data: campaign, error: campErr } = await db()
+                .from('campaigns')
+                .insert({ project_id: projectId, site_id, name, type: type ?? 'sequence', segment_id: segId, sends_per_hour: sends_per_hour ?? null, requires_approval: false })
+                .select('id')
+                .single();
+            if (campErr)
+                return txt(`Error creating campaign: ${campErr.message}`);
+            const steps = [];
+            for (let i = 0; i < plan.steps.length; i++) {
+                const planned = plan.steps[i];
+                const { data: step, error: stepErr } = await db()
+                    .from('campaign_steps')
+                    .insert({
+                    campaign_id: campaign.id, step_order: i,
+                    subject: planned.subject, body_html: planned.body_html, body_text: planned.body_text,
+                    blocks: planned.blocks,
+                    delay_days: planned.delay_days, delay_hours: planned.delay_hours,
+                })
+                    .select('id, step_order, subject')
+                    .single();
+                if (stepErr)
+                    return txt(`Error adding step ${i}: ${stepErr.message}`);
+                steps.push(step);
+            }
+            const enrollRows = plan.contact_ids.map((id) => ({ campaign_id: campaign.id, contact_id: id, next_send_at: new Date().toISOString() }));
+            if (enrollRows.length) {
+                await db().from('campaign_enrollments').upsert(enrollRows, { onConflict: 'campaign_id,contact_id', ignoreDuplicates: true });
+            }
+            await db().from('campaigns').update({ status: 'active', total_enrolled: enrollRows.length, updated_at: new Date().toISOString() }).eq('id', campaign.id);
+            return j({
+                campaign_id: campaign.id, campaign_name: name, status: 'active',
+                segment: { id: segId, name: plan.segment_name, contacts: plan.contact_ids.length },
+                enrolled: enrollRows.length,
+                steps: steps.map(s => ({ step: s.step_order, subject: s.subject })),
+                message: `Campaign "${name}" is live! ${enrollRows.length} contacts enrolled across ${steps.length} email(s).`,
+            });
+        }
+        const channelContext = currentChannelContext();
+        let needsApproval = false;
         if (confirmed) {
-            const channelContext = currentChannelContext();
-            const decision = assertChannelCanExecute('launch_campaign', approvalParams, channelContext);
+            const decision = assertChannelCanExecute('launch_campaign', requestParams, channelContext);
             if (!decision.allowed)
                 return txt(decision.reason ?? 'This channel cannot request this action.');
-            if (decision.tier !== 'autonomous') {
-                if (!approval_id) {
-                    const approval = await requestApproval('launch_campaign', approvalParams, undefined, channelContext);
-                    return j(approval);
-                }
-                const check = await checkApproval(approval_id, { consume: true, action: 'launch_campaign', params: approvalParams });
-                if (!check.approved) {
-                    return txt(`Approval ${approval_id} is ${check.status}. ${check.status === 'pending' ? 'Waiting for human approval via dashboard.' : 'Request a new approval.'}`);
-                }
+            needsApproval = decision.tier !== 'autonomous';
+        }
+        // Approved call: launch exactly what the person approved.
+        if (confirmed && needsApproval && approval_id) {
+            const { data: row, error: rowErr } = await db()
+                .from('action_approvals')
+                .select('params')
+                .eq('id', approval_id)
+                .eq('project_id', projectId)
+                .eq('action', 'launch_campaign')
+                .maybeSingle();
+            if (rowErr)
+                return txt(`Error reading approval ${approval_id}: ${rowErr.message}`);
+            if (!row)
+                return txt(`Approval ${approval_id} is not_found. Request a new approval.`);
+            const stored = (row.params ?? {});
+            const plan = readLaunchPlan(stored.generated);
+            // Checked before the approval is used up: an approval made before the emails were shown
+            // for approval covers only the briefs, so it is refused and left as it is.
+            if (!plan)
+                return txt(`Approval ${approval_id} does not include the written emails, so it cannot launch anything. Request a new approval.`);
+            const check = await checkApproval(approval_id, { consume: true, action: 'launch_campaign', params: { ...requestParams, generated: stored.generated } });
+            if (!check.approved) {
+                return txt(`Approval ${approval_id} is ${check.status}. ${check.status === 'pending' ? 'Waiting for human approval via dashboard.' : 'Request a new approval.'}`);
             }
+            return launchFromPlan(plan);
         }
+        const apiKey = process.env.ANTHROPIC_API_KEY;
+        if (!apiKey)
+            return txt('Error: ANTHROPIC_API_KEY not configured');
+        const anthropic = new Anthropic({ apiKey });
         function applyPaymentRules(query, payment) {
             if (!payment)
                 return query;
@@ -1654,9 +1755,10 @@ Adapt your tone accordingly:
             }
             return ids;
         };
-        let segId = segment_id;
+        const segId = segment_id;
         let segmentName;
         let contactCount = 0;
+        let contactIds = [];
         let parsedRules;
         if (segment_description) {
             const parseResp = await anthropic.messages.create({
@@ -1673,8 +1775,8 @@ Adapt your tone accordingly:
             catch {
                 return txt(`Error: Failed to parse segment from "${segment_description}"`);
             }
-            const ids = await getContactIds(parsedRules);
-            contactCount = ids.length;
+            contactIds = await getContactIds(parsedRules);
+            contactCount = contactIds.length;
             segmentName = `${name} — segment`;
         }
         else {
@@ -1688,8 +1790,8 @@ Adapt your tone accordingly:
                 return txt('Error: segment not found');
             segmentName = seg.name;
             parsedRules = seg.rules;
-            const ids = await getContactIds(parsedRules);
-            contactCount = ids.length;
+            contactIds = await getContactIds(parsedRules);
+            contactCount = contactIds.length;
         }
         if (!confirmed) {
             const subjectPreviews = [];
@@ -1718,27 +1820,10 @@ Adapt your tone accordingly:
         }
         if (contactCount === 0)
             return txt('No contacts match the segment. Adjust targeting criteria.');
-        // Create segment if from NL description
-        if (segment_description) {
-            const { data: seg, error: segErr } = await db()
-                .from('segments')
-                .insert({ project_id: projectId, name: segmentName, description: segment_description, rules: parsedRules })
-                .select('id')
-                .single();
-            if (segErr)
-                return txt(`Error creating segment: ${segErr.message}`);
-            segId = seg.id;
-        }
+        // Checked before anything is written or an approval is requested.
         const campLimit = await checkPlanLimit('active_campaigns');
         if (!campLimit.allowed)
             return txt(`Active campaign limit reached (${campLimit.current}/${campLimit.limit}).`);
-        const { data: campaign, error: campErr } = await db()
-            .from('campaigns')
-            .insert({ project_id: projectId, site_id, name, type: type ?? 'sequence', segment_id: segId, sends_per_hour: sends_per_hour ?? null, requires_approval: false })
-            .select('id')
-            .single();
-        if (campErr)
-            return txt(`Error creating campaign: ${campErr.message}`);
         const [{ data: site }, { data: project }] = await Promise.all([
             db()
                 .from('sites')
@@ -1752,6 +1837,8 @@ Adapt your tone accordingly:
                 .eq('id', projectId)
                 .maybeSingle(),
         ]);
+        if (!site)
+            return txt('Error: site not found');
         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)}
@@ -1774,7 +1861,9 @@ 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 steps = [];
+        // Write every email first. If one cannot be written, stop: nothing is created and no
+        // approval is requested, so a brief can never go out in place of an email.
+        const plannedSteps = [];
         for (let i = 0; i < emails.length; i++) {
             const email = emails[i];
             const genResp = await anthropic.messages.create({
@@ -1785,52 +1874,61 @@ Do not include body_html in your response; Sendinel renders body_html from block
             });
             const gtb = genResp.content.find((b) => b.type === 'text');
             const rawEmail = gtb && 'text' in gtb ? gtb.text : '{}';
-            let emailContent;
+            let written = null;
             try {
                 const parsed = JSON.parse(rawEmail.replace(/```json?\n?|```/g, '').trim());
                 const conclusion = parsed.conclusion ?? parsed;
                 const blocks = normalizeComposerBlocks(conclusion.blocks);
-                emailContent = blocks.length
+                written = blocks.length
                     ? {
                         subject: conclusion.subject,
                         body_html: blocksToHtml(blocks, { preheader: typeof conclusion.preview_text === 'string' ? conclusion.preview_text : null }),
                         body_text: typeof conclusion.body_text === 'string' && conclusion.body_text.trim() ? conclusion.body_text : blocksToText(blocks),
                         blocks,
                     }
-                    : parsed;
+                    : { subject: conclusion.subject, body_html: conclusion.body_html, body_text: conclusion.body_text, blocks: null };
             }
             catch {
-                emailContent = { subject: `Step ${i + 1}`, body_html: '<p>' + email.brief + '</p>', body_text: email.brief };
+                written = null;
             }
-            const { data: step, error: stepErr } = await db()
-                .from('campaign_steps')
-                .insert({
-                campaign_id: campaign.id, step_order: i,
-                subject: String(emailContent.subject ?? `Step ${i + 1}`), body_html: emailContent.body_html, body_text: emailContent.body_text,
-                blocks: Array.isArray(emailContent.blocks) ? emailContent.blocks : null,
-                delay_days: email.delay_days ?? 0, delay_hours: email.delay_hours ?? 0,
-            })
-                .select('id, step_order, subject')
-                .single();
-            if (stepErr)
-                return txt(`Error adding step ${i}: ${stepErr.message}`);
-            steps.push(step);
+            if (!written || typeof written.subject !== 'string' || !written.subject.trim() || typeof written.body_html !== 'string' || !written.body_html.trim()) {
+                return txt(`Error: email ${i + 1} of ${emails.length} could not be written from its brief. Nothing was created and no approval was requested. Try again, or reword that brief.`);
+            }
+            plannedSteps.push({
+                subject: written.subject.trim(),
+                body_html: written.body_html,
+                body_text: typeof written.body_text === 'string' && written.body_text.trim() ? written.body_text : null,
+                blocks: written.blocks,
+                delay_days: email.delay_days ?? 0,
+                delay_hours: email.delay_hours ?? 0,
+            });
         }
-        // Enroll contacts
-        const enrollIds = await getContactIds(parsedRules);
-        const enrollRows = enrollIds.map((id) => ({ campaign_id: campaign.id, contact_id: id, next_send_at: new Date().toISOString() }));
-        if (enrollRows.length) {
-            await db().from('campaign_enrollments').upsert(enrollRows, { onConflict: 'campaign_id,contact_id', ignoreDuplicates: true });
+        const plan = {
+            rules: parsedRules,
+            segment_name: segmentName ?? `${name} — segment`,
+            // Frozen here: the people a person approves are the people enrolled.
+            contact_ids: contactIds,
+            steps: plannedSteps,
+        };
+        if (needsApproval) {
+            const approval = await requestApproval('launch_campaign', { ...requestParams, generated: plan }, undefined, channelContext, {
+                segment_name: segment_id ? plan.segment_name : null,
+                audience_label: segment_description ? `"${segment_description}"` : null,
+            });
+            return j({
+                ...approval,
+                campaign_name: name,
+                recipient_count: plan.contact_ids.length,
+                segment: segment_description
+                    ? { description: segment_description, parsed_rules: plan.rules, matching_contacts: plan.contact_ids.length }
+                    : { id: segId, name: plan.segment_name, matching_contacts: plan.contact_ids.length },
+                emails: plan.steps.map((step, i) => ({
+                    step: i, subject: step.subject, body_html: step.body_html, body_text: step.body_text, delay_days: step.delay_days, delay_hours: step.delay_hours,
+                })),
+                next: 'Show the user each subject, the recipient count and approve_url. After a person approves, call launch_campaign again with the same arguments plus approval_id. These exact emails are sent; nothing is rewritten. Do not say it launched before that call succeeds.',
+            });
         }
-        // Activate + update enrolled count
-        await db().from('campaigns').update({ status: 'active', total_enrolled: enrollIds.length, updated_at: new Date().toISOString() }).eq('id', campaign.id);
-        return j({
-            campaign_id: campaign.id, campaign_name: name, status: 'active',
-            segment: { id: segId, name: segmentName, contacts: contactCount },
-            enrolled: enrollIds.length,
-            steps: steps.map(s => ({ step: s.step_order, subject: s.subject })),
-            message: `Campaign "${name}" is live! ${enrollIds.length} contacts enrolled across ${steps.length} email(s).`,
-        });
+        return launchFromPlan(plan);
     });
     server.registerTool('preview_email', {
         title: 'Preview Email',

package/build/tools/delivery-ops.js

@@ -703,14 +703,15 @@ export function registerDeliveryOpsTools(server) {
             idempotentHint: true,
             openWorldHint: false,
         },
-        description: 'Export contacts, email log, campaign, or suppression data as JSON.',
+        description: 'Export contacts, email log, campaign, or suppression data as JSON, newest first. Returns up to `limit` rows per call plus `total` (all matching rows). When `truncated` is true, call again with `offset` set to `next_offset` until it is false to get every row.',
         inputSchema: {
             resource: z.enum(['contacts', 'email_log', 'campaigns', 'suppressions']),
             site_id: z.string().uuid().optional(),
             since: z.string().datetime().optional(),
             limit: z.number().int().min(1).max(5000).default(1000).optional(),
+            offset: z.number().int().min(0).default(0).optional().describe('Rows to skip. Use the next_offset from the previous call to continue.'),
         },
-    }, async ({ resource, site_id, since, limit = 1000 }) => {
+    }, async ({ resource, site_id, since, limit = 1000, offset = 0 }) => {
         const projectId = getProjectId();
         const tableMap = {
             contacts: 'subscribers',
@@ -718,16 +719,40 @@ export function registerDeliveryOpsTools(server) {
             campaigns: 'campaigns',
             suppressions: 'suppressions',
         };
-        let query = db().from(tableMap[resource]).select('*').eq('project_id', projectId).limit(limit);
-        if (site_id && (resource === 'email_log' || resource === 'campaigns'))
-            query = query.eq('site_id', site_id);
-        if (since)
-            query = query.gte('created_at', since);
-        query = query.order('created_at', { ascending: false });
-        const { data, error } = await query;
-        if (error)
-            return j({ error: error.message });
-        return j({ resource, count: data?.length ?? 0, data: data ?? [], truncated: (data?.length ?? 0) === limit });
+        // #3715: one request returns at most 1,000 rows however large `limit` is, with no error.
+        // Read `limit` rows in pages, and report the real total so the caller can tell when it has
+        // everything. id breaks ties so pages do not overlap.
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const filtered = (query) => {
+            let q = query.eq('project_id', projectId);
+            if (site_id && (resource === 'email_log' || resource === 'campaigns'))
+                q = q.eq('site_id', site_id);
+            if (since)
+                q = q.gte('created_at', since);
+            return q;
+        };
+        const PAGE = 1000;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const rows = [];
+        while (rows.length < limit) {
+            const size = Math.min(PAGE, limit - rows.length);
+            const from = offset + rows.length;
+            const { data, error } = await filtered(db().from(tableMap[resource]).select('*'))
+                .order('created_at', { ascending: false })
+                .order('id', { ascending: true })
+                .range(from, from + size - 1);
+            if (error)
+                return j({ error: error.message });
+            rows.push(...(data ?? []));
+            if ((data?.length ?? 0) < size)
+                break;
+        }
+        const { count, error: countError } = await filtered(db().from(tableMap[resource]).select('id', { count: 'exact', head: true }));
+        // An unknown total is reported as null, never as a number.
+        const total = countError || typeof count !== 'number' ? null : count;
+        const nextOffset = offset + rows.length;
+        const truncated = total === null ? rows.length === limit : nextOffset < total;
+        return j({ resource, count: rows.length, total, offset, next_offset: truncated ? nextOffset : null, truncated, data: rows });
     });
     server.registerTool('list_domains', {
         title: 'List Domains',

package/package.json

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