@sendinel/mcp-server 1.0.3 → 1.0.5

package/build/tools/sms.js

@@ -218,6 +218,13 @@ async function logBlocked(projectId, orgId, siteId, contactId, phone, reasonCode
 }
 export function registerSmsTools(server) {
     server.registerTool('list_sms_log', {
+        title: 'List SMS Log',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
         description: 'List recent SMS sends with delivery status and cost.',
         inputSchema: {
             status: z.enum(['queued', 'sending', 'sent', 'delivered', 'failed', 'undelivered']).optional(),
@@ -238,6 +245,13 @@ export function registerSmsTools(server) {
         return j({ rows: data ?? [] });
     });
     server.registerTool('list_sms_inbound', {
+        title: 'List SMS Inbound',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
         description: 'List recent inbound SMS replies and their interpreted intent (stop/help/reply).',
         inputSchema: {
             interpreted_as: z.enum(['stop', 'help', 'start', 'reply', 'unknown']).optional(),
@@ -258,6 +272,13 @@ export function registerSmsTools(server) {
         return j({ rows: data ?? [] });
     });
     server.registerTool('get_sms_provider_status', {
+        title: 'Get SMS Provider Status',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
         description: "Return the connection status, brand info, and recent error rate for the tenant's SMS provider.",
         inputSchema: {},
     }, async () => {
@@ -278,6 +299,13 @@ export function registerSmsTools(server) {
         });
     });
     server.registerTool('set_contact_sms_consent', {
+        title: 'Set Contact SMS Consent',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
         description: 'Manually record an opt-in or opt-out for a contact (e.g., from a paper form or phone conversation).',
         inputSchema: {
             contact_id: z.string().uuid(),
@@ -340,6 +368,13 @@ export function registerSmsTools(server) {
         return j({ ok: true, contact_id, phone_e164: contact.phone_e164, status });
     });
     server.registerTool('preview_sms_cost', {
+        title: 'Preview SMS Cost',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
         description: 'Given a draft SMS body and a segment, return the segment count, encoding, and estimated total cost.',
         inputSchema: {
             body: z.string().min(1),
@@ -359,6 +394,13 @@ export function registerSmsTools(server) {
         });
     });
     server.registerTool('send_sms_campaign', {
+        title: 'Send SMS Campaign',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
         description: "Launch an SMS campaign or broadcast to a segment. Same shape as email campaigns but with channel='sms'.",
         inputSchema: {
             site_id: z.string().uuid(),
@@ -412,6 +454,13 @@ export function registerSmsTools(server) {
         });
     });
     server.registerTool('send_sms', {
+        title: 'Send SMS',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
         description: 'Send a single SMS through the active SMS provider to a contact or raw phone number. Validates consent and quiet hours before sending.',
         inputSchema: {
             body: z.string().min(1),

package/build/tools/social-posts.js

@@ -6,6 +6,7 @@ import { getAnthropicModelId } from '../anthropic-model.js';
 import { buildVoicePrompt } from '../lib/voice.js';
 import { buildSocialSystemPrompt, buildSocialUserPrompt, parseSocialResponse, selectArchetype, } from '../lib/social-engine/index.js';
 import { fireWebhookEvent } from '../lib/webhook-events.js';
+import { resolveSurveyShortLink } from '../lib/survey-link-resolver.js';
 const txt = (text) => ({ content: [{ type: 'text', text }] });
 const j = (data) => txt(JSON.stringify(data, null, 2));
 const PLATFORMS = [
@@ -53,6 +54,21 @@ function statusFromSchedule(scheduledAt, queueRequested) {
         return 'scheduled';
     return 'draft';
 }
+function linkedInCompanyCrosspostMetadata(enabled, pageId, platforms) {
+    if (!enabled)
+        return {};
+    const target = pageId?.trim();
+    if (!platforms.includes('linkedin'))
+        throw new Error('LinkedIn company cross-post requires linkedin in platforms.');
+    if (!target)
+        throw new Error('linkedin_company_page_id is required when LinkedIn company cross-post is enabled.');
+    return {
+        linkedin_company_crosspost: {
+            enabled: true,
+            target_linkedin_page_id: target.slice(0, 120),
+        },
+    };
+}
 function trackedUrl(input) {
     const url = new URL(input.destinationUrl);
     const source = input.platform === 'x' ? 'twitter' : input.platform;
@@ -86,6 +102,13 @@ async function requireProjectCampaign(campaignId) {
 }
 export function registerSocialPostTools(server) {
     server.registerTool('list_social_posts', {
+        title: 'List Social Posts',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
         description: 'List first-class social posts for the current project.',
         inputSchema: {
             status: z.enum(STATUSES).optional(),
@@ -111,6 +134,13 @@ export function registerSocialPostTools(server) {
         return j({ posts: data ?? [] });
     });
     server.registerTool('get_social_post', {
+        title: 'Get Social Post',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
         description: 'Get one social post by ID.',
         inputSchema: { post_id: z.string().uuid() },
     }, async ({ post_id }) => {
@@ -127,6 +157,13 @@ export function registerSocialPostTools(server) {
         return j(data);
     });
     server.registerTool('adapt_social_post', {
+        title: 'Adapt Social Post',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
         description: 'Adapt an existing email campaign into channel-specific social captions using the creator-archetype engine (deterministic archetype selection, multi-layer brand/voice prompts, A/B/C variants per platform, gen-time constraint enforcement) — without creating a post. Returns platform_captions (variant A per platform, back-compat) plus a full generation record with variants, media plans, and constraint warnings.',
         inputSchema: {
             email_campaign_id: z.string().uuid(),
@@ -218,6 +255,13 @@ export function registerSocialPostTools(server) {
         });
     });
     server.registerTool('create_social_post', {
+        title: 'Create Social Post',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
         description: 'Create a first-class social post, optionally linked to an email campaign and UTM-tracked social campaign.',
         inputSchema: {
             title: z.string().min(1),
@@ -228,12 +272,15 @@ export function registerSocialPostTools(server) {
             platform_captions: z.record(z.string(), z.string()).optional(),
             media_urls: z.array(z.string().url()).optional().default([]),
             destination_url: z.string().url().optional(),
+            survey_id: z.string().uuid().optional(),
             utm_campaign: z.string().optional(),
             scheduled_at: z.string().datetime().optional(),
             queue_requested: z.boolean().optional().default(false),
             timezone: z.string().optional().default('Pacific/Honolulu'),
+            linkedin_company_crosspost: z.boolean().optional().default(false),
+            linkedin_company_page_id: z.string().optional(),
         },
-    }, async ({ title, content, platforms, site_id, email_campaign_id, platform_captions, media_urls, destination_url, utm_campaign, scheduled_at, queue_requested, timezone }) => {
+    }, async ({ title, content, platforms, site_id, email_campaign_id, platform_captions, media_urls, destination_url, survey_id, utm_campaign, scheduled_at, queue_requested, timezone, linkedin_company_crosspost, linkedin_company_page_id }) => {
         const projectId = getProjectId();
         const orgId = await projectOrgId(projectId);
         if (!orgId)
@@ -254,10 +301,24 @@ export function registerSocialPostTools(server) {
         catch (err) {
             return txt(`Error: ${err instanceof Error ? err.message : 'Invalid schedule'}`);
         }
+        let metadata;
+        try {
+            metadata = linkedInCompanyCrosspostMetadata(linkedin_company_crosspost, linkedin_company_page_id, platforms);
+        }
+        catch (err) {
+            return txt(`Error: ${err instanceof Error ? err.message : 'Invalid LinkedIn cross-post settings'}`);
+        }
+        let resolvedDestinationUrl = destination_url;
+        if (survey_id) {
+            const surveyLink = await resolveSurveyShortLink(db(), projectId, survey_id);
+            if (!surveyLink)
+                return txt('Error: survey has no short link yet');
+            resolvedDestinationUrl = surveyLink;
+        }
         let socialCampaignId = null;
         let tracked = null;
-        if (destination_url) {
-            tracked = trackedUrl({ destinationUrl: destination_url, title, platform: platforms.includes('x') ? 'twitter' : platforms[0], utmCampaign: cleanText(utm_campaign) });
+        if (resolvedDestinationUrl) {
+            tracked = trackedUrl({ destinationUrl: resolvedDestinationUrl, title, platform: platforms.includes('x') ? 'twitter' : platforms[0], utmCampaign: cleanText(utm_campaign) });
             const { data: socialCampaign, error: campaignError } = await db()
                 .from('social_campaigns')
                 .insert({
@@ -265,7 +326,7 @@ export function registerSocialPostTools(server) {
                 site_id: site_id ?? null,
                 name: title,
                 platform: tracked.utm_source,
-                destination_url,
+                destination_url: resolvedDestinationUrl,
                 utm_source: tracked.utm_source,
                 utm_medium: tracked.utm_medium,
                 utm_campaign: tracked.utm_campaign,
@@ -292,9 +353,10 @@ export function registerSocialPostTools(server) {
             title,
             content,
             platform_captions: platform_captions ?? {},
+            metadata,
             media_urls: media_urls ?? [],
             platforms,
-            destination_url: destination_url ?? null,
+            destination_url: resolvedDestinationUrl ?? null,
             tracked_url: tracked?.tracked_url ?? null,
             scheduled_at: scheduledAt,
             timezone: timezone ?? 'Pacific/Honolulu',
@@ -312,6 +374,13 @@ export function registerSocialPostTools(server) {
         return j(data);
     });
     server.registerTool('update_social_post', {
+        title: 'Update Social Post',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
         description: 'Update a social post by ID. Supports copy, captions, schedule, status, and metrics fields.',
         inputSchema: {
             post_id: z.string().uuid(),
@@ -362,6 +431,13 @@ export function registerSocialPostTools(server) {
         return j(data);
     });
     server.registerTool('delete_social_post', {
+        title: 'Delete Social Post',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
         description: 'Archive a social post so it disappears from active planner and list views.',
         inputSchema: { post_id: z.string().uuid() },
     }, async ({ post_id }) => {

package/build/tools/surveys.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerSurveyTools(server: McpServer): void;

package/build/tools/surveys.js

@@ -0,0 +1,222 @@
+import { z } from 'zod';
+import { db } from '../db.js';
+import { getProjectId } from '../project.js';
+const txt = (text) => ({ content: [{ type: 'text', text }] });
+const j = (data) => txt(JSON.stringify(data, null, 2));
+const QUESTION_SCHEMA = z.object({
+    id: z.string().min(1).optional(),
+    text: z.string().min(1).optional(),
+    label: z.string().min(1).optional(),
+    type: z.enum(['single_choice', 'multi_choice', 'multiple_choice', 'text', 'rating', 'nps', 'csat']),
+    options: z.array(z.string()).optional(),
+    required: z.boolean().optional(),
+});
+function appBaseUrl() {
+    return (process.env.NEXT_PUBLIC_APP_URL ?? process.env.SENDINEL_APP_URL ?? process.env.APP_URL ?? 'https://sendinel.ai').replace(/\/$/, '');
+}
+function normalizeQuestions(questions) {
+    return questions.map((question, index) => {
+        const id = question.id?.trim() || `q${index + 1}`;
+        const label = question.label?.trim() || question.text?.trim() || '';
+        return {
+            ...question,
+            id,
+            label,
+            type: question.type === 'single_choice' ? 'multiple_choice' : question.type,
+        };
+    });
+}
+function tallyResponses(responses, questions) {
+    return questions.map((question) => {
+        const values = responses
+            .map((row) => row.answers?.[question.id])
+            .filter((value) => value !== undefined && value !== null && value !== '');
+        const numeric = values.map((value) => Number(value)).filter((value) => Number.isFinite(value));
+        const optionCounts = {};
+        for (const value of values) {
+            if (Array.isArray(value)) {
+                for (const item of value)
+                    optionCounts[String(item)] = (optionCounts[String(item)] ?? 0) + 1;
+            }
+            else {
+                optionCounts[String(value)] = (optionCounts[String(value)] ?? 0) + 1;
+            }
+        }
+        return {
+            question_id: question.id,
+            type: question.type,
+            response_count: values.length,
+            average: numeric.length ? numeric.reduce((sum, value) => sum + value, 0) / numeric.length : null,
+            option_counts: optionCounts,
+            text_responses: question.type === 'text' ? values.map(String) : undefined,
+        };
+    });
+}
+export function registerSurveyTools(server) {
+    server.registerTool('create_survey', {
+        title: 'Create Survey',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
+        description: 'Create a project-scoped survey with one or more questions. Returns the survey and public response short link when available.',
+        inputSchema: {
+            title: z.string().min(1),
+            questions: z.array(QUESTION_SCHEMA).min(1),
+            site_id: z.string().uuid().optional(),
+            status: z.enum(['draft', 'active', 'closed']).optional().default('draft'),
+        },
+    }, async ({ title, questions, site_id, status }) => {
+        const projectId = getProjectId();
+        const { data: project } = await db().from('projects').select('org_id, plan').eq('id', projectId).maybeSingle();
+        if (!project?.org_id)
+            return j({ error: 'Project not found', code: 'NOT_FOUND' });
+        const { data: survey, error } = await db()
+            .from('surveys')
+            .insert({ project_id: projectId, title, questions: normalizeQuestions(questions), status })
+            .select()
+            .single();
+        if (error)
+            return j({ error: error.message });
+        const responseUrl = `${appBaseUrl()}/api/surveys/respond?survey_id=${survey.id}`;
+        const { data: slugData, error: slugError } = await db().rpc('next_short_link_slug');
+        if (slugError || !slugData)
+            return j({ survey, response_url: responseUrl, short_link: null, warning: slugError?.message ?? 'short link slug unavailable' });
+        const { data: shortLink, error: linkError } = await db()
+            .from('short_links')
+            .insert({
+            slug: slugData,
+            org_id: project.org_id,
+            project_id: projectId,
+            destination_url: responseUrl,
+            source_type: 'survey',
+            source_id: survey.id,
+        })
+            .select()
+            .single();
+        if (!linkError && shortLink?.id) {
+            await db().from('surveys').update({ short_link_id: shortLink.id }).eq('id', survey.id).eq('project_id', projectId);
+        }
+        return j({
+            survey: { ...survey, short_link_id: shortLink?.id ?? null, site_id: site_id ?? null },
+            response_url: responseUrl,
+            short_link: shortLink ?? null,
+            short_url: shortLink?.slug ? `${appBaseUrl()}/s/${shortLink.slug}` : null,
+            ...(linkError ? { warning: linkError.message } : {}),
+        });
+    });
+    server.registerTool('list_surveys', {
+        title: 'List Surveys',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+        description: 'List surveys for the current project.',
+        inputSchema: {
+            status: z.enum(['draft', 'active', 'closed']).optional(),
+            limit: z.number().int().min(1).max(200).optional().default(50),
+        },
+    }, async ({ status, limit }) => {
+        const projectId = getProjectId();
+        let query = db().from('surveys').select('id, title, status, short_link_id, created_at, updated_at').eq('project_id', projectId).order('created_at', { ascending: false }).limit(limit);
+        if (status)
+            query = query.eq('status', status);
+        const { data, error } = await query;
+        if (error)
+            return j({ error: error.message });
+        return j({ surveys: data ?? [], count: data?.length ?? 0 });
+    });
+    server.registerTool('get_survey', {
+        title: 'Get Survey',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+        description: 'Get a project-scoped survey by id, including questions and short-link metadata.',
+        inputSchema: { survey_id: z.string().uuid() },
+    }, async ({ survey_id }) => {
+        const projectId = getProjectId();
+        const { data: survey, error } = await db().from('surveys').select('*').eq('id', survey_id).eq('project_id', projectId).maybeSingle();
+        if (error)
+            return j({ error: error.message });
+        if (!survey)
+            return j({ error: 'Survey not found', code: 'NOT_FOUND' });
+        const { data: shortLink } = survey.short_link_id
+            ? await db().from('short_links').select('id, slug, destination_url, click_count, last_clicked_at').eq('id', survey.short_link_id).eq('project_id', projectId).maybeSingle()
+            : { data: null };
+        return j({ survey, short_link: shortLink ?? null });
+    });
+    server.registerTool('get_survey_results', {
+        title: 'Get Survey Results',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+        description: 'Get aggregated response results for a project-scoped survey.',
+        inputSchema: { survey_id: z.string().uuid() },
+    }, async ({ survey_id }) => {
+        const projectId = getProjectId();
+        const { data: survey, error: surveyError } = await db().from('surveys').select('id, title, questions').eq('id', survey_id).eq('project_id', projectId).maybeSingle();
+        if (surveyError)
+            return j({ error: surveyError.message });
+        if (!survey)
+            return j({ error: 'Survey not found', code: 'NOT_FOUND' });
+        const { data: responses, error: responseError } = await db().from('survey_responses').select('id, answers, submitted_at').eq('survey_id', survey_id).eq('project_id', projectId).order('submitted_at', { ascending: false });
+        if (responseError)
+            return j({ error: responseError.message });
+        const questions = normalizeQuestions((survey.questions ?? []));
+        return j({
+            survey_id,
+            title: survey.title,
+            response_count: responses?.length ?? 0,
+            questions: tallyResponses((responses ?? []), questions),
+        });
+    });
+    server.registerTool('update_survey', {
+        title: 'Update Survey',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+        description: 'Update a project-scoped survey title, questions, or status.',
+        inputSchema: {
+            survey_id: z.string().uuid(),
+            title: z.string().min(1).optional(),
+            questions: z.array(QUESTION_SCHEMA).min(1).optional(),
+            status: z.enum(['draft', 'active', 'closed']).optional(),
+        },
+    }, async ({ survey_id, title, questions, status }) => {
+        const projectId = getProjectId();
+        const updates = {};
+        if (title !== undefined)
+            updates.title = title;
+        if (questions !== undefined)
+            updates.questions = normalizeQuestions(questions);
+        if (status !== undefined)
+            updates.status = status;
+        if (Object.keys(updates).length === 0)
+            return j({ error: 'No fields to update', code: 'INVALID_INPUT' });
+        const { data, error } = await db()
+            .from('surveys')
+            .update({ ...updates, updated_at: new Date().toISOString() })
+            .eq('id', survey_id)
+            .eq('project_id', projectId)
+            .select()
+            .maybeSingle();
+        if (error)
+            return j({ error: error.message });
+        if (!data)
+            return j({ error: 'Survey not found', code: 'NOT_FOUND' });
+        return j({ survey: data, ok: true });
+    });
+}

package/build/tools/templates.js

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { db } from '../db.js';
 import { getProjectId } from '../project.js';
+import { recordBrandAssetUsage } from '../lib/brand-asset-usage.js';
 const txt = (text) => ({ content: [{ type: 'text', text }] });
 const j = (data) => txt(JSON.stringify(data, null, 2));
 function stripHtml(value) {
@@ -59,6 +60,13 @@ function translateMergeTags(body) {
 }
 export function registerTemplateTools(server) {
     server.registerTool('list_templates', {
+        title: 'List Templates',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
         description: 'List email templates for the current project, including reusable system templates.',
         inputSchema: {
             limit: z.number().int().min(1).max(100).default(50).optional(),
@@ -83,6 +91,13 @@ export function registerTemplateTools(server) {
         return j({ templates: data ?? [], count: data?.length ?? 0 });
     });
     server.registerTool('translate_template', {
+        title: 'Translate Template',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
         description: 'Translate rendered source-platform HTML into a Sendinel campaign template. Optionally save it.',
         inputSchema: {
             provider: z.enum(['customerio', 'mailchimp', 'klaviyo', 'activecampaign', 'kit', 'resend']).default('customerio').optional(),
@@ -92,8 +107,9 @@ export function registerTemplateTools(server) {
             html: z.string().optional(),
             text: z.string().optional(),
             save: z.boolean().default(false).optional(),
+            brand_asset_ids: z.array(z.string().uuid()).optional().describe('Stable brand_media_assets ids explicitly referenced by this template.'),
         },
-    }, async ({ provider = 'customerio', source_template_id, name, subject, html, text, save = false }) => {
+    }, async ({ provider = 'customerio', source_template_id, name, subject, html, text, save = false, brand_asset_ids }) => {
         const projectId = getProjectId();
         const { data: project, error: projectError } = await db().from('projects').select('org_id').eq('id', projectId).single();
         if (projectError || !project?.org_id)
@@ -162,12 +178,29 @@ export function registerTemplateTools(server) {
                 return j({ error: saveError.message });
             savedTemplateId = saved?.id ?? null;
             if (savedTemplateId) {
+                await recordBrandAssetUsage({
+                    client: db(),
+                    projectId,
+                    source: 'campaign_template',
+                    resourceId: savedTemplateId,
+                    html: bodyHtml,
+                    assetIds: brand_asset_ids,
+                }).catch((err) => {
+                    console.warn('Failed to record brand asset usage for MCP translated template:', err);
+                });
                 await db().from('template_translations').update({ saved_template_id: savedTemplateId, status: 'saved' }).eq('id', row.id);
             }
         }
         return j({ ok: true, translation_id: row.id, saved_template_id: savedTemplateId, translated });
     });
     server.registerTool('get_template', {
+        title: 'Get Template',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
         description: 'Get a single email template by ID.',
         inputSchema: { id: z.string().uuid() },
     }, async ({ id }) => {
@@ -182,6 +215,13 @@ export function registerTemplateTools(server) {
         return j({ template: data });
     });
     server.registerTool('create_template', {
+        title: 'Create Template',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
         description: 'Create a new email template. Use create_template_from_brief to AI-generate the content.',
         inputSchema: {
             name: z.string().min(1),
@@ -191,8 +231,9 @@ export function registerTemplateTools(server) {
             category: z.string().optional(),
             description: z.string().optional(),
             tags: z.array(z.string()).optional(),
+            brand_asset_ids: z.array(z.string().uuid()).optional().describe('Stable brand_media_assets ids explicitly referenced by this template.'),
         },
-    }, async ({ name, brief, subject_hint, body_html, category, description, tags }) => {
+    }, async ({ name, brief, subject_hint, body_html, category, description, tags, brand_asset_ids }) => {
         const projectId = getProjectId();
         const { data, error } = await db().from('campaign_templates')
             .insert({
@@ -209,9 +250,26 @@ export function registerTemplateTools(server) {
             .single();
         if (error)
             return j({ error: error.message });
+        await recordBrandAssetUsage({
+            client: db(),
+            projectId,
+            source: 'campaign_template',
+            resourceId: data.id,
+            html: body_html,
+            assetIds: brand_asset_ids,
+        }).catch((err) => {
+            console.warn('Failed to record brand asset usage for MCP template:', err);
+        });
         return j({ template: data, ok: true });
     });
     server.registerTool('update_template', {
+        title: 'Update Template',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
         description: 'Update an existing email template.',
         inputSchema: {
             id: z.string().uuid(),
@@ -222,6 +280,7 @@ export function registerTemplateTools(server) {
             category: z.string().optional(),
             description: z.string().optional(),
             tags: z.array(z.string()).optional(),
+            brand_asset_ids: z.array(z.string().uuid()).optional().describe('Stable brand_media_assets ids explicitly referenced by this template.'),
         },
     }, async ({ id, ...updates }) => {
         const projectId = getProjectId();
@@ -256,9 +315,26 @@ export function registerTemplateTools(server) {
             .single();
         if (error)
             return j({ error: error.message });
+        await recordBrandAssetUsage({
+            client: db(),
+            projectId,
+            source: 'campaign_template',
+            resourceId: data.id,
+            html: updates.body_html,
+            assetIds: updates.brand_asset_ids,
+        }).catch((err) => {
+            console.warn('Failed to record brand asset usage for MCP template update:', err);
+        });
         return j({ template: data, ok: true });
     });
     server.registerTool('delete_template', {
+        title: 'Delete Template',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
         description: 'Archive an email template. System templates cannot be deleted.',
         inputSchema: { id: z.string().uuid() },
     }, async ({ id }) => {