@sendinel/mcp-server 1.0.15 → 1.0.17

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 308 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 311 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 308 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` | 36 | Full campaign lifecycle: create, edit, approve, launch, enroll, schedule, sequence templates |
+| `campaigns` | 39 | 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/server.js

@@ -95,7 +95,7 @@ const WRITE_TOOLS = new Set([
     'create_segment', 'update_segment', 'delete_segment', 'create_segment_nl',
     'create_list', 'update_list', 'delete_list', 'add_list_members', 'remove_list_members', 'add_list_members_by_filter',
     'launch_campaign', 'merge_subscribers', 'create_campaign_with_content',
-    'send_test_email', 'send_transactional', 'subscribe_webhook', 'update_webhook_subscription',
+    'send_test_email', 'send_transactional', 'send_awaiting_reply', 'subscribe_webhook', 'update_webhook_subscription',
     'create_ab_test', 'promote_ab_winner', 'optimize_subject_lines',
     'unsubscribe_subscriber', 'add_suppression', 'remove_suppression',
     'trigger_automation', 'enroll_automation', 'create_escalation_ladder', 'enroll_in_escalation_ladder',

package/build/tools/campaigns.js

@@ -1,7 +1,13 @@
 import { z } from 'zod';
 import Anthropic from '@anthropic-ai/sdk';
-import { NAME_FALLBACKS, renderTemplateString as renderTemplateVars, resolveBrandTokens } from '@sendinel/domain';
-import { adminDb, db } from '../db.js';
+import { NAME_FALLBACKS, renderTemplateString as renderTemplateVars, resolveBrandTokens, } from '@sendinel/domain';
+// Subpath import, not the barrel above -- reply-actions.ts uses node:crypto,
+// and MCP-server-side that's fine (this never runs in an Edge Function), but
+// keeping it off the shared barrel avoids re-creating the Edge-Function
+// bundling problem this subpath was introduced to fix. See the comment in
+// packages/domain/src/index.ts.
+import { ensureReplyActionSecretConfigured, mintReplyAction, } from '@sendinel/domain/reply-actions';
+import { adminDb, db, requestContext } from '../db.js';
 import { getProjectId } from '../project.js';
 import { checkPlanLimit } from '../plan-limits.js';
 import { buildVoicePrompt, buildEmailSystemPrompt, deriveTemplateVariables, validateTemplate } from '../lib/voice.js';
@@ -1920,6 +1926,307 @@ Do not include body_html in your response; Sendinel renders body_html from block
             resend_id: sendResult.provider === 'resend' ? sendResult.messageId : null,
         });
     });
+    function parseReplyWindow(input) {
+        const match = /^(\d{1,2})d$/.exec(input.trim());
+        if (!match)
+            return null;
+        const days = Number(match[1]);
+        if (days < 1 || days > 30)
+            return null;
+        return { days, expiresAt: new Date(Date.now() + days * 24 * 60 * 60 * 1000).toISOString() };
+    }
+    function parseAwaitReplyStatuses(status) {
+        const allowed = ['pending', 'consumed', 'expired', 'invalid'];
+        if (!status)
+            return ['pending'];
+        const requested = status.split(',').map((item) => item.trim()).filter(Boolean);
+        const valid = requested.filter((item) => allowed.includes(item));
+        return valid.length ? valid : ['pending'];
+    }
+    server.registerTool('send_awaiting_reply', {
+        title: 'Send Awaiting Reply',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
+        description: 'Send a transactional email and track whether the recipient replies within a deadline. Mints a single-use Reply-To address with an expiry window, tags it with a correlation ID, and logs reply actions. Customer replies are captured as data only.',
+        inputSchema: {
+            to: z.string().email().describe('Recipient email address'),
+            site_id: z.string().uuid().describe('Site UUID (determines from address and provider)'),
+            subject: z.string().optional().describe('Email subject line. Required unless template_id is supplied and the template has a subject_hint.'),
+            html: z.string().optional().describe('HTML body'),
+            text: z.string().optional().describe('Plain text body'),
+            expect_reply_within: z.string().describe("Reply window, e.g. '7d'. 1-30 days."),
+            correlation_id: z.string().min(1).max(255).describe('Opaque id from the calling app (e.g. a Tractic ticket id). Used by get_reply_status/list_awaiting_replies.'),
+            idempotency_key: z.string().optional().describe('Unique key to prevent duplicate sends'),
+            template_id: z.string().uuid().optional().describe('campaign_templates row to render and send. Mutually exclusive with html.'),
+            template_vars: z.record(z.string(), z.string()).optional().describe('Variable values for template_id rendering. Wins over brand tokens on key collision.'),
+        },
+    }, async ({ to, site_id, subject, html, text, expect_reply_within, correlation_id, idempotency_key, template_id, template_vars }) => {
+        const projectId = getProjectId();
+        if (template_id && html)
+            return txt("Error: Provide either 'template_id' or 'html', not both");
+        if (!template_id && !html && !text)
+            return txt('At least one of html or text is required');
+        if (!template_id && !subject?.trim())
+            return txt('Error: subject is required');
+        const window = parseReplyWindow(expect_reply_within);
+        if (!window)
+            return txt("Error: Invalid expect_reply_within. Expected format like '7d' (1-30 days).");
+        try {
+            ensureReplyActionSecretConfigured();
+        }
+        catch (err) {
+            return txt(`Error: ${err instanceof Error ? err.message : 'Reply action secret is not configured'}`);
+        }
+        // Suppression check
+        const { data: suppression } = await db()
+            .from('suppressions')
+            .select('id, reason')
+            .eq('project_id', projectId)
+            .eq('email', to.toLowerCase())
+            .limit(1)
+            .maybeSingle();
+        if (suppression)
+            return txt(`Error: Recipient suppressed — ${suppression.reason}`);
+        // Idempotency check
+        if (idempotency_key) {
+            const { data: existing } = await db()
+                .from('email_log')
+                .select('id, provider_message_id, status')
+                .eq('project_id', projectId)
+                .eq('idempotency_key', idempotency_key)
+                .maybeSingle();
+            if (existing) {
+                return j({
+                    error: 'Duplicate send',
+                    id: existing.id,
+                    provider_message_id: existing.provider_message_id,
+                    resend_id: existing.provider_message_id,
+                });
+            }
+        }
+        // Site verification
+        const { data: site } = await db()
+            .from('sites')
+            .select('from_email, from_name, name, brand_voice')
+            .eq('id', site_id)
+            .eq('project_id', projectId)
+            .maybeSingle();
+        if (!site)
+            return txt('Error: Site not found');
+        let resolvedSubject = subject;
+        let resolvedHtml = html;
+        let resolvedText = text;
+        if (template_id) {
+            const { data: template, error: templateError } = await db()
+                .from('campaign_templates')
+                .select('id, subject_hint, body_html, body_text, format')
+                .eq('id', template_id)
+                .eq('project_id', projectId)
+                .maybeSingle();
+            if (templateError)
+                return txt(`Error: ${templateError.message}`);
+            if (!template)
+                return txt('Error: Template not found');
+            const { data: project } = await adminDb().from('projects').select('brand_settings').eq('id', projectId).maybeSingle();
+            const projectBrand = (project?.brand_settings ?? null);
+            const siteBrand = (site.brand_voice ?? null);
+            const mergedBrand = projectBrand || siteBrand ? { ...(projectBrand ?? {}), ...(siteBrand ?? {}) } : null;
+            const brandVars = resolveBrandTokens(mergedBrand, site.name || undefined);
+            const vars = template_vars ?? {};
+            const renderVars = { ...brandVars, ...vars };
+            const subjectFallingBack = !subject?.trim();
+            const requiredVars = deriveTemplateVariables({
+                body_html: template.format === 'text' ? null : (template.body_html ?? ''),
+                body_text: template.format === 'text' ? (template.body_text ?? '') : null,
+                subject_hint: subjectFallingBack ? (template.subject_hint ?? '') : null,
+            });
+            const satisfied = new Set([
+                ...Object.keys(vars),
+                'brand_name', 'brand_logo_url', 'brand_bg_color', 'brand_text_color', 'brand_accent_color',
+                ...Object.keys(NAME_FALLBACKS),
+            ]);
+            const missing = requiredVars.filter((name) => !satisfied.has(name));
+            if (missing.length) {
+                return txt(`Error: Missing required template variable(s): ${missing.join(', ')}`);
+            }
+            if (template.format === 'text') {
+                resolvedText = renderTemplateVars(template.body_text ?? '', renderVars);
+                resolvedHtml = undefined;
+            }
+            else {
+                resolvedHtml = renderTemplateVars(template.body_html ?? '', renderVars);
+                resolvedText = text ?? stripHtml(resolvedHtml);
+            }
+            resolvedSubject = subject?.trim() || renderTemplateVars(template.subject_hint ?? '', renderVars);
+        }
+        if (!resolvedSubject?.trim())
+            return txt('Error: subject is required');
+        const { data: projectContext, error: projectContextError } = await adminDb()
+            .from('projects')
+            .select('org_id, owner_user_id')
+            .eq('id', projectId)
+            .maybeSingle();
+        const actorUserId = requestContext()?.actorId ?? projectContext?.owner_user_id ?? null;
+        if (projectContextError || !projectContext?.org_id || !actorUserId) {
+            return txt('Error: Reply action cannot be minted for this project');
+        }
+        // Insert email_log (status queued) BEFORE minting and sending so reply token has source_email_log_id
+        const { data: logRow, error: logError } = await db().from('email_log').insert({
+            project_id: projectId,
+            site_id,
+            contact_id: null,
+            to_email: to,
+            from_email: site.from_email,
+            subject: resolvedSubject,
+            status: 'queued',
+            category: 'transactional',
+            idempotency_key: idempotency_key ?? null,
+            body_html: resolvedHtml ?? null,
+        }).select('id').single();
+        if (logError && idempotency_key && logError.code === '23505') {
+            const { data: existing } = await db()
+                .from('email_log')
+                .select('id, provider_message_id, status')
+                .eq('project_id', projectId)
+                .eq('idempotency_key', idempotency_key)
+                .maybeSingle();
+            if (existing) {
+                return j({
+                    error: 'Duplicate send',
+                    id: existing.id,
+                    provider_message_id: existing.provider_message_id,
+                    resend_id: existing.provider_message_id,
+                });
+            }
+        }
+        if (logError || !logRow?.id) {
+            return txt(`Error: ${logError?.message ?? 'Failed to create email log row'}`);
+        }
+        let minted;
+        try {
+            minted = await mintReplyAction({
+                db: adminDb(),
+                orgId: projectContext.org_id,
+                projectId,
+                userId: actorUserId,
+                actionType: 'await_reply',
+                resourceId: logRow.id,
+                sourceEmailLogId: logRow.id,
+                correlationId: correlation_id,
+                expiresAt: window.expiresAt,
+            });
+        }
+        catch (err) {
+            await db().from('email_log').update({ status: 'failed' }).eq('id', logRow.id);
+            const errMsg = err instanceof Error ? err.message : String(err);
+            if (errMsg.includes('23505') || errMsg.includes('uidx_reply_actions_pending_correlation') || errMsg.includes('already pending')) {
+                return txt('An awaiting-reply send for this correlation_id is already pending.');
+            }
+            return txt(`Error: Failed to mint reply action — ${errMsg}`);
+        }
+        const payload = {
+            from: `${site.from_name} <${site.from_email}>`,
+            to,
+            subject: resolvedSubject,
+            html: resolvedHtml,
+            text: resolvedText,
+            replyTo: minted.replyToAddress,
+        };
+        let sendResult;
+        try {
+            sendResult = await sendEmailForSite(projectId, site_id, payload);
+        }
+        catch (error) {
+            await db().from('email_log').update({ status: 'failed' }).eq('id', logRow.id);
+            return txt(`Error: Send failed — ${error instanceof Error ? error.message : 'unknown provider error'}`);
+        }
+        await db().from('email_log').update({
+            status: 'sent',
+            sent_at: new Date().toISOString(),
+            provider_message_id: sendResult.messageId ?? null,
+        }).eq('id', logRow.id);
+        return j({
+            sent: true,
+            id: logRow.id,
+            reply_action_id: minted.id,
+            correlation_id,
+            expires_at: window.expiresAt,
+            to,
+            provider: sendResult.provider,
+            provider_message_id: sendResult.messageId,
+            resend_id: sendResult.provider === 'resend' ? sendResult.messageId : null,
+        });
+    });
+    server.registerTool('get_reply_status', {
+        title: 'Get Reply Status',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+        description: 'Get the reply status of an awaiting-reply message by its correlation ID.',
+        inputSchema: {
+            correlation_id: z.string().min(1).max(255).describe('Opaque correlation ID from the calling app'),
+        },
+    }, async ({ correlation_id }) => {
+        const { data, error } = await adminDb()
+            .from('reply_actions')
+            .select('id, status, correlation_id, source_email_log_id, reply_text, consumed_from_address, reply_received_at, expires_at, expiry_work_item_id')
+            .eq('project_id', getProjectId())
+            .eq('action_type', 'await_reply')
+            .eq('correlation_id', correlation_id)
+            .order('created_at', { ascending: false })
+            .limit(1)
+            .maybeSingle();
+        if (error)
+            return txt(`Error: ${error.message}`);
+        if (!data)
+            return j({ found: false, correlation_id });
+        const outcome = data.status === 'pending' ? 'awaiting'
+            : data.status === 'consumed' ? 'replied'
+                : data.status === 'expired' ? 'no_reply_by_deadline'
+                    : 'unknown';
+        return j({ found: true, correlation_id, outcome, ...data });
+    });
+    server.registerTool('list_awaiting_replies', {
+        title: 'List Awaiting Replies',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+        description: 'List awaiting-reply messages for the project, filtered by status.',
+        inputSchema: {
+            status: z.string().optional().describe('Comma-separated: pending,consumed,expired. Defaults to pending.'),
+            limit: z.number().int().min(1).max(100).optional().default(25),
+        },
+    }, async ({ status, limit = 25 }) => {
+        const statuses = parseAwaitReplyStatuses(status);
+        const { data, error } = await adminDb()
+            .from('reply_actions')
+            .select('id, status, correlation_id, source_email_log_id, reply_text, consumed_from_address, reply_received_at, expires_at, expiry_work_item_id, created_at')
+            .eq('project_id', getProjectId())
+            .eq('action_type', 'await_reply')
+            .in('status', statuses)
+            .order('created_at', { ascending: false })
+            .limit(limit);
+        if (error)
+            return txt(`Error: ${error.message}`);
+        const items = (data ?? []).map((row) => ({
+            ...row,
+            outcome: row.status === 'pending' ? 'awaiting'
+                : row.status === 'consumed' ? 'replied'
+                    : row.status === 'expired' ? 'no_reply_by_deadline'
+                        : 'unknown',
+        }));
+        return j({ items, count: items.length });
+    });
     server.registerTool('validate_template', {
         title: 'Validate Template',
         annotations: {

package/package.json

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