@sendinel/mcp-server 1.0.4 → 1.0.6

package/build/tools/content.js

@@ -1,9 +1,113 @@
 import { z } from 'zod';
-import { db } from '../db.js';
+import { adminDb, db } from '../db.js';
 import { getProjectId } from '../project.js';
 const j = (data) => ({ content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] });
 export function registerContentTools(server) {
+    server.registerTool('create_asset_link', {
+        title: 'Create Asset Link',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
+        description: 'Create an email-gated, trackable asset link. Viewers submit an email at /a/{slug}; each view creates or attaches a contact and emits asset_link.viewed.',
+        inputSchema: {
+            title: z.string().min(1).max(255),
+            slug: z.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/).max(100),
+            asset_url: z.string().url().max(2000),
+            asset_type: z.enum(['pdf', 'page', 'deck', 'video', 'other']).optional().default('page'),
+            site_id: z.string().uuid().optional(),
+            source_attribution: z.string().max(500).optional(),
+            gate_headline: z.string().max(255).optional(),
+            gate_body: z.string().max(1000).optional(),
+        },
+    }, async ({ title, slug, asset_url, asset_type = 'page', site_id, source_attribution, gate_headline, gate_body }) => {
+        const { data, error } = await db().from('asset_links')
+            .insert({
+            project_id: getProjectId(),
+            site_id: site_id ?? null,
+            title,
+            slug,
+            asset_url,
+            asset_type,
+            source_attribution: source_attribution ?? null,
+            gate_headline: gate_headline ?? null,
+            gate_body: gate_body ?? null,
+        })
+            .select('id, title, slug, asset_type, status, source_attribution, gate_headline, gate_body, total_views, total_captures, created_at')
+            .single();
+        if (error)
+            return j({ error: error.message, code: error.code });
+        const appUrl = process.env.NEXT_PUBLIC_APP_URL ?? process.env.SENDINEL_APP_URL ?? 'https://sendinel.ai';
+        return j({ asset_link: { ...data, url: `${appUrl.replace(/\/$/, '')}/a/${data.slug}` } });
+    });
+    server.registerTool('list_asset_links', {
+        title: 'List Asset Links',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+        description: 'List email-gated asset links and aggregate capture/view counters.',
+        inputSchema: {
+            status: z.enum(['draft', 'active', 'archived']).optional(),
+            limit: z.number().int().min(1).max(200).optional().default(50),
+        },
+    }, async ({ status, limit = 50 }) => {
+        let query = db().from('asset_links')
+            .select('id, title, slug, asset_type, status, source_attribution, total_views, total_captures, created_at, updated_at')
+            .eq('project_id', getProjectId())
+            .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 });
+        const appUrl = (process.env.NEXT_PUBLIC_APP_URL ?? process.env.SENDINEL_APP_URL ?? 'https://sendinel.ai').replace(/\/$/, '');
+        return j({ asset_links: (data ?? []).map((row) => ({ ...row, url: `${appUrl}/a/${row.slug}` })) });
+    });
+    server.registerTool('get_asset_link_views', {
+        title: 'Get Asset Link Views',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+        description: 'List per-view events for a gated asset link, including captured email, contact id, and duration when available.',
+        inputSchema: {
+            asset_link_id: z.string().uuid(),
+            limit: z.number().int().min(1).max(200).optional().default(50),
+        },
+    }, async ({ asset_link_id, limit = 50 }) => {
+        const { data: assetLink } = await db().from('asset_links')
+            .select('id')
+            .eq('id', asset_link_id)
+            .eq('project_id', getProjectId())
+            .maybeSingle();
+        if (!assetLink)
+            return j({ error: 'Asset link not found', code: 'NOT_FOUND' });
+        const { data, error } = await db().from('asset_link_views')
+            .select('id, contact_id, viewer_email, is_new_contact, source_attribution, viewed_at, left_at, duration_seconds, referrer')
+            .eq('asset_link_id', asset_link_id)
+            .eq('project_id', getProjectId())
+            .order('viewed_at', { ascending: false })
+            .limit(limit);
+        if (error)
+            return j({ error: error.message });
+        return j({ views: data ?? [] });
+    });
     server.registerTool('list_content_blocks', {
+        title: 'List Content Blocks',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
         description: 'List reusable content blocks for the project, optionally filtered by category.',
         inputSchema: { category: z.enum(['header', 'footer', 'cta', 'legal', 'general']).optional() },
     }, async ({ category }) => {
@@ -16,6 +120,13 @@ export function registerContentTools(server) {
         return j({ blocks: data ?? [] });
     });
     server.registerTool('create_content_block', {
+        title: 'Create Content Block',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
         description: 'Create a reusable content block.',
         inputSchema: {
             name: z.string().min(1),
@@ -33,6 +144,13 @@ export function registerContentTools(server) {
         return j({ block: data });
     });
     server.registerTool('delete_content_block', {
+        title: 'Delete Content Block',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
         description: 'Delete a reusable content block.',
         inputSchema: { block_id: z.string().uuid() },
     }, async ({ block_id }) => {
@@ -42,6 +160,13 @@ export function registerContentTools(server) {
         return j({ deleted: true });
     });
     server.registerTool('list_content_sources', {
+        title: 'List Content Sources',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
         description: 'List configured content sources and draft counts.',
         inputSchema: {},
     }, async () => {
@@ -54,6 +179,13 @@ export function registerContentTools(server) {
         return j({ sources: (data ?? []).map((row) => ({ id: row.id, name: row.name, type: row.source_type, url: row.feed_url, active: row.active, last_fetched: row.last_polled_at, draft_count: row.items_generated ?? 0 })) });
     });
     server.registerTool('trigger_content_pipeline', {
+        title: 'Trigger Content Pipeline',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
         description: 'Mark one or all content sources ready for the content pipeline cron.',
         inputSchema: { source_id: z.string().uuid().optional() },
     }, async ({ source_id }) => {
@@ -65,4 +197,137 @@ export function registerContentTools(server) {
             return j({ error: error.message });
         return j({ drafts_created: 0, queued_for_pipeline: true });
     });
+    // Blogs (#2033): the primary agent door for ingesting a blog written by the
+    // user's LLM/agent. Lands as a draft staged for review; publishing to the
+    // user's own site is a separate step. Sender-owns-schema -- only title is
+    // required, and unmapped fields are preserved in source_payload.
+    const slugify = (s) => s.toLowerCase().trim().replace(/[^a-z0-9\s-]/g, '').replace(/\s+/g, '-').replace(/-+/g, '-').slice(0, 120).replace(/^-|-$/g, '');
+    server.registerTool('create_blog_post', {
+        title: 'Create Blog Post',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
+        description: 'Ingest a blog post (written by your AI/agent) into Sendinel. By default it lands as a draft in the review queue. For a trusted, hands-off flow, set auto_publish=true with publish_to (a destination name or id from list_blog_destinations) to skip review and publish to the user\'s own site — now, or at scheduled_at. Only title is required; everything else is optional.',
+        inputSchema: {
+            title: z.string().min(1).max(300),
+            body: z.string().optional(),
+            excerpt: z.string().max(1000).optional(),
+            author: z.string().max(120).optional(),
+            slug: z.string().max(120).optional(),
+            tags: z.array(z.string().max(64)).max(30).optional(),
+            cover_image_url: z.string().url().max(2000).optional(),
+            site_id: z.string().uuid().optional(),
+            seo: z.record(z.string(), z.unknown()).optional(),
+            publish_destination: z.record(z.string(), z.unknown()).optional(),
+            scheduled_at: z.string().datetime().optional(),
+            auto_publish: z.boolean().optional(),
+            publish_to: z.string().max(200).optional(),
+        },
+    }, async (args) => {
+        const { data: proj, error: projErr } = await adminDb().from('projects').select('org_id').eq('id', getProjectId()).single();
+        if (projErr || !proj?.org_id)
+            return j({ error: 'Organization not found for project' });
+        const { title, body, excerpt, author, slug, tags, cover_image_url, site_id, seo, publish_destination, scheduled_at, auto_publish, publish_to } = args;
+        // One-shot auto-publish: skip the review queue and hand the post straight to
+        // the publish worker (status='scheduled', due now unless scheduled_at is set).
+        // Requires a resolvable, active destination so a typo can't silently drop the
+        // post into a limbo state.
+        let status = 'draft';
+        let resolvedScheduledAt = scheduled_at ?? null;
+        let resolvedDestination = publish_destination ?? {};
+        if (auto_publish) {
+            if (!publish_to) {
+                return j({ error: 'auto_publish requires publish_to (a destination name or id). Call list_blog_destinations to see the options.' });
+            }
+            const { data: dests, error: destErr } = await db().from('blog_destinations')
+                .select('id, name')
+                .eq('project_id', getProjectId())
+                .eq('is_active', true);
+            if (destErr)
+                return j({ error: destErr.message });
+            const target = publish_to.trim().toLowerCase();
+            const match = (dests ?? []).find((d) => d.id === publish_to || String(d.name ?? '').toLowerCase() === target);
+            if (!match) {
+                return j({ error: `No active publish destination matching "${publish_to}". Add one on the Blog page, or call list_blog_destinations.` });
+            }
+            status = 'scheduled';
+            resolvedScheduledAt = scheduled_at ?? new Date().toISOString();
+            resolvedDestination = { destination_id: match.id };
+        }
+        const { data, error } = await db().from('blog_posts')
+            .insert({
+            org_id: proj.org_id,
+            project_id: getProjectId(),
+            site_id: site_id ?? null,
+            title,
+            slug: slug ? slugify(slug) : slugify(title),
+            body: body ?? null,
+            excerpt: excerpt ?? null,
+            author: author ?? null,
+            tags: tags ?? [],
+            cover_image_url: cover_image_url ?? null,
+            seo: seo ?? {},
+            status,
+            source: 'mcp',
+            source_payload: args,
+            publish_destination: resolvedDestination,
+            scheduled_at: resolvedScheduledAt,
+        })
+            .select('id, title, slug, status, source, scheduled_at, created_at')
+            .single();
+        if (error)
+            return j({ error: error.message, code: error.code });
+        return j({ blog_post: data, ...(auto_publish ? { note: scheduled_at ? 'Scheduled — the publish worker will send it at scheduled_at.' : 'Queued for immediate publish — the worker publishes it within a few minutes.' } : {}) });
+    });
+    server.registerTool('list_blog_posts', {
+        title: 'List Blog Posts',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+        description: 'List ingested blog posts for this project, newest first. Optional status filter.',
+        inputSchema: {
+            status: z.enum(['draft', 'scheduled', 'published', 'archived']).optional(),
+            limit: z.number().int().min(1).max(200).optional().default(50),
+        },
+    }, async ({ status, limit = 50 }) => {
+        let query = db().from('blog_posts')
+            .select('id, title, slug, status, source, external_url, scheduled_at, published_at, created_at')
+            .eq('project_id', getProjectId())
+            .order('created_at', { ascending: false })
+            .limit(limit);
+        if (status)
+            query = query.eq('status', status);
+        else
+            query = query.neq('status', 'archived');
+        const { data, error } = await query;
+        if (error)
+            return j({ error: error.message });
+        return j({ blog_posts: data ?? [] });
+    });
+    server.registerTool('list_blog_destinations', {
+        title: 'List Blog Destinations',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+        description: 'List this project\'s configured blog publish destinations (WordPress sites / signed webhooks) by id, name, and kind — pass a name or id as create_blog_post\'s publish_to to auto-publish. Never returns credentials.',
+        inputSchema: {},
+    }, async () => {
+        const { data, error } = await db().from('blog_destinations')
+            .select('id, name, kind, is_active')
+            .eq('project_id', getProjectId())
+            .eq('is_active', true)
+            .order('created_at', { ascending: false });
+        if (error)
+            return j({ error: error.message });
+        return j({ destinations: data ?? [] });
+    });
 }

package/build/tools/data-proposals.js

@@ -26,6 +26,13 @@ async function engagementSnapshot(projectId) {
 }
 export function registerDataProposalTools(server) {
     server.registerTool('propose_campaign_from_data', {
+        title: 'Propose Campaign From Data',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
         description: 'Create an approve-gated campaign proposal from recent engagement signals and project Brand Brain.',
         inputSchema: {
             source_type: z.enum(['engagement_signal', 'segment_trend', 'cross_channel_synthesis']).optional().default('engagement_signal'),
@@ -72,6 +79,13 @@ export function registerDataProposalTools(server) {
         return j({ proposal: data });
     });
     server.registerTool('list_data_proposals', {
+        title: 'List Data Proposals',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
         description: 'List data-triggered campaign proposals for the current project.',
         inputSchema: {
             status: z.enum(['pending', 'approved', 'rejected', 'converted_to_draft', 'expired']).optional(),
@@ -92,6 +106,13 @@ export function registerDataProposalTools(server) {
         return j({ proposals: data ?? [] });
     });
     server.registerTool('approve_data_proposal', {
+        title: 'Approve Data Proposal',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
         description: 'Approve a data-triggered campaign proposal and convert it into an AI draft for review.',
         inputSchema: {
             proposal_id: z.string().uuid(),

package/build/tools/data.js

@@ -30,6 +30,13 @@ function toCsv(rows, columns) {
 function toJsonl(rows) {
     return rows.map((row) => JSON.stringify(row)).join('\n');
 }
+function importStatus(row) {
+    if (row.dry_run === true)
+        return 'dry_run';
+    if ((row.invalid ?? 0) > 0)
+        return 'partial';
+    return 'completed';
+}
 const MIGRATION_PROVIDERS = ['customerio', 'mailchimp', 'klaviyo', 'activecampaign', 'convertkit', 'kit', 'resend'];
 const CONNECTED_PLATFORMS = [
     'stripe',
@@ -131,14 +138,23 @@ function createCampaignMigrationTotals(options) {
         },
     };
 }
-function createPlatformMigrationTotals(artifactTypes) {
+function createPlatformMigrationTotals(artifactTypes, platform) {
     const requested = artifactTypes?.length ? new Set(artifactTypes) : null;
-    const enabled = (key) => !requested || requested.has(key);
+    const customerIoOnly = new Set(['newsletters', 'broadcasts', 'transactional', 'snippets', 'collections', 'messages']);
+    const enabled = (key) => (!customerIoOnly.has(key) || platform === 'customerio') && (!requested || requested.has(key));
     return {
         contacts: { total: enabled('contacts') ? 1 : 0, processed: 0 },
         templates: { total: enabled('templates') ? 1 : 0, processed: 0 },
         campaigns: { total: enabled('campaigns') ? 1 : 0, processed: 0 },
         suppressions: { total: enabled('suppressions') ? 1 : 0, processed: 0 },
+        segments: { total: enabled('segments') ? 1 : 0, processed: 0 },
+        enrollments: { total: enabled('enrollments') ? 1 : 0, processed: 0 },
+        newsletters: { total: enabled('newsletters') ? 1 : 0, processed: 0 },
+        broadcasts: { total: enabled('broadcasts') ? 1 : 0, processed: 0 },
+        transactional: { total: enabled('transactional') ? 1 : 0, processed: 0 },
+        snippets: { total: enabled('snippets') ? 1 : 0, processed: 0 },
+        collections: { total: enabled('collections') ? 1 : 0, processed: 0 },
+        messages: { total: enabled('messages') ? 1 : 0, processed: 0 },
         processed: 0,
         errors: 0,
         account_name: 'Platform migration',
@@ -147,6 +163,14 @@ function createPlatformMigrationTotals(artifactTypes) {
             import_templates: enabled('templates'),
             import_campaigns: enabled('campaigns'),
             import_suppressions: enabled('suppressions'),
+            import_segments: enabled('segments'),
+            import_enrollments: enabled('enrollments'),
+            import_newsletters: enabled('newsletters'),
+            import_broadcasts: enabled('broadcasts'),
+            import_transactional: enabled('transactional'),
+            import_snippets: enabled('snippets'),
+            import_collections: enabled('collections'),
+            import_messages: enabled('messages'),
             migration_entry_point: 'mcp_connection',
         },
     };
@@ -201,6 +225,13 @@ function createZip(files) {
 }
 export function registerDataTools(server) {
     server.registerTool('list_connected_platforms', {
+        title: 'List Connected Platforms',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
         description: 'List connected external platforms and integration status for the current project organization. Does not return credential material.',
         inputSchema: {
             org_id: z.string().uuid().optional(),
@@ -232,13 +263,20 @@ export function registerDataTools(server) {
         }
     });
     server.registerTool('connect_platform', {
+        title: 'Connect Platform',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
         description: 'Store encrypted credentials for an external platform connection and mark it ready for trigger configuration.',
         inputSchema: {
             org_id: z.string().uuid().optional(),
             platform: z.enum(CONNECTED_PLATFORMS),
-            credentials: z.record(z.unknown()),
+            credentials: z.record(z.string(), z.unknown()),
             display_name: z.string().min(1).optional(),
-            config: z.record(z.unknown()).optional().default({}),
+            config: z.record(z.string(), z.unknown()).optional().default({}),
             status: z.enum(PLATFORM_STATUSES).optional().default('connected'),
         },
     }, async ({ org_id, platform, credentials, display_name, config = {}, status = 'connected' }) => {
@@ -291,6 +329,13 @@ export function registerDataTools(server) {
         }
     });
     server.registerTool('disconnect_platform', {
+        title: 'Disconnect Platform',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
         description: 'Disconnect an external platform connection for the current project organization and remove stored credentials.',
         inputSchema: {
             org_id: z.string().uuid().optional(),
@@ -329,6 +374,13 @@ export function registerDataTools(server) {
         }
     });
     server.registerTool('list_platform_events', {
+        title: 'List Platform Events',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
         description: 'List recent raw events received from connected platforms for troubleshooting trigger mappings.',
         inputSchema: {
             org_id: z.string().uuid().optional(),
@@ -359,6 +411,13 @@ export function registerDataTools(server) {
         }
     });
     server.registerTool('configure_platform_trigger', {
+        title: 'Configure Platform Trigger',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
         description: 'Configure an event-to-action mapping for a connected platform, such as adding a Shopify customer to a list after an order.',
         inputSchema: {
             org_id: z.string().uuid().optional(),
@@ -422,19 +481,40 @@ export function registerDataTools(server) {
         }
     });
     server.registerTool('list_import_history', {
+        title: 'List Import History',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
         description: 'List recent subscriber import history rows.',
         inputSchema: { limit: z.number().int().min(1).max(100).optional().default(25) },
     }, async ({ limit = 25 }) => {
         const { data, error } = await db().from('import_log')
-            .select('id, source, status, imported_count, failed_count, created_at')
+            .select('id, source, imported, skipped, invalid, total_found, dry_run, tags, created_at')
             .eq('project_id', getProjectId())
             .order('created_at', { ascending: false })
             .limit(limit);
         if (error)
             return j({ error: error.message });
-        return j({ imports: data ?? [] });
+        return j({
+            imports: (data ?? []).map((row) => ({
+                ...row,
+                status: importStatus(row),
+                imported_count: row.imported,
+                failed_count: row.invalid,
+            })),
+        });
     });
     server.registerTool('list_api_keys', {
+        title: 'List API Keys',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
         description: 'List API keys without returning secret material.',
         inputSchema: {},
     }, async () => {
@@ -448,6 +528,13 @@ export function registerDataTools(server) {
         return j({ keys: data ?? [] });
     });
     server.registerTool('create_api_key', {
+        title: 'Create API Key',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
         description: 'Create an API key and return the secret once.',
         inputSchema: {
             name: z.string().min(1),
@@ -466,6 +553,13 @@ export function registerDataTools(server) {
         return j({ key_id: data.id, name: data.name, slug: data.slug, secret });
     });
     server.registerTool('revoke_api_key', {
+        title: 'Revoke API Key',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
         description: 'Revoke an API key.',
         inputSchema: { key_id: z.string().uuid() },
     }, async ({ key_id }) => {
@@ -475,6 +569,13 @@ export function registerDataTools(server) {
         return j({ revoked: true });
     });
     server.registerTool('migrate_campaigns_from', {
+        title: 'Migrate Campaigns From',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
         description: 'Start a campaign-artifact migration from a provider token. Imports templates and campaigns as draft, approval-required Sendinel assets; Customer.io is the first-class path.',
         inputSchema: {
             provider: z.enum(MIGRATION_PROVIDERS),
@@ -539,10 +640,20 @@ export function registerDataTools(server) {
         });
     });
     server.registerTool('start_platform_migration', {
+        title: 'Start Platform Migration',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
         description: 'Start a migration from a stored external platform connection into Sendinel. Returns a job_id for status polling.',
         inputSchema: {
             connection_id: z.string().uuid(),
-            artifact_types: z.array(z.enum(['contacts', 'templates', 'campaigns', 'suppressions'])).optional(),
+            artifact_types: z.array(z.enum([
+                'contacts', 'templates', 'campaigns', 'suppressions', 'segments', 'enrollments',
+                'newsletters', 'broadcasts', 'transactional', 'snippets', 'collections', 'messages',
+            ])).optional(),
             dry_run: z.boolean().optional().default(false),
         },
     }, async ({ connection_id, artifact_types, dry_run = false }) => {
@@ -574,7 +685,7 @@ export function registerDataTools(server) {
             provider: connection.platform,
             status: 'pending',
             progress_pct: 0,
-            totals: createPlatformMigrationTotals(artifact_types),
+            totals: createPlatformMigrationTotals(artifact_types, connection.platform),
             errors: [],
             credentials_enc: encrypt(JSON.stringify(credentials)),
             field_mapping: null,
@@ -588,6 +699,13 @@ export function registerDataTools(server) {
         return j({ job_id: data.id, status: 'pending', connection_id, provider: connection.platform });
     });
     server.registerTool('list_notifications', {
+        title: 'List Notifications',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
         description: 'List in-app notifications.',
         inputSchema: { unread_only: z.boolean().optional().default(false) },
     }, async ({ unread_only = false }) => {
@@ -600,6 +718,13 @@ export function registerDataTools(server) {
         return j({ notifications: data ?? [] });
     });
     server.registerTool('mark_notifications_read', {
+        title: 'Mark Notifications Read',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
         description: 'Mark selected notifications read, or all unread notifications if ids is omitted.',
         inputSchema: { ids: z.array(z.string().uuid()).optional() },
     }, async ({ ids }) => {
@@ -612,6 +737,13 @@ export function registerDataTools(server) {
         return j({ updated: data?.length ?? 0 });
     });
     server.registerTool('tenant_export_full', {
+        title: 'Tenant Export Full',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
         description: 'Export all tenant data classes for portability. Returns inline data for small exports or a signed archive URL for large exports.',
         inputSchema: {
             siteId: z.string().uuid(),