@sendinel/mcp-server 1.0.4 → 1.0.5

package/build/tools/ai-work.js

@@ -0,0 +1,460 @@
+import { createHash } from 'node:crypto';
+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 workItemSelect = [
+    'id',
+    'org_id',
+    'project_id',
+    'site_id',
+    'kind',
+    'status',
+    'severity',
+    'confidence',
+    'source',
+    'title',
+    'why_now',
+    'evidence',
+    'recommended_actions',
+    'proposal_ids',
+    'surfaces',
+    'generated_at',
+    'snoozed_until',
+].join(', ');
+const proposalSelect = [
+    'id',
+    'project_id',
+    'org_id',
+    'type',
+    'target_table',
+    'target_id',
+    'target_label',
+    'before_json',
+    'after_json',
+    'reasoning',
+    'source_data_refs',
+    'confidence',
+    'status',
+    'expires_at',
+    'applied_at',
+    'applied_by',
+    'apply_method',
+    'apply_error',
+    'generated_at',
+    'generated_by',
+    'llm_model',
+].join(', ');
+const workStatusSchema = z.enum(['new', 'seen', 'accepted', 'dismissed', 'snoozed', 'resolved', 'failed']);
+const activeStatuses = ['new', 'seen', 'snoozed'];
+const contextEventTypes = ['strategic_segment_intent', 'business_priority', 'customer_journey_signal', 'campaign_opportunity', 'risk_signal'];
+const contextEventInput = {
+    workspace_id: z.string().min(1).max(255),
+    event_type: z.enum(contextEventTypes),
+    title: z.string().min(1).max(255),
+    detail: z.string().min(1).max(4000),
+    evidence: z.record(z.string(), z.unknown()).optional(),
+    suggested_actions: z.array(z.record(z.string(), z.unknown())).optional(),
+    idempotency_key: z.string().min(1).max(255),
+};
+function parseStatuses(status) {
+    if (!status)
+        return [...activeStatuses];
+    const requested = status.split(',').map((item) => item.trim()).filter(Boolean);
+    const valid = requested.filter((item) => workStatusSchema.safeParse(item).success);
+    return valid.length ? valid : [...activeStatuses];
+}
+async function updateWorkItemStatus(id, status, snoozedUntil) {
+    const updates = { status };
+    if (status === 'dismissed')
+        updates.dismissed_at = new Date().toISOString();
+    if (status === 'snoozed') {
+        if (!snoozedUntil)
+            return { error: 'snoozed_until is required.' };
+        updates.snoozed_until = snoozedUntil;
+    }
+    else {
+        updates.snoozed_until = null;
+    }
+    const { data, error } = await db()
+        .from('ai_work_items')
+        .update(updates)
+        .eq('project_id', getProjectId())
+        .eq('id', id)
+        .select(workItemSelect)
+        .maybeSingle();
+    if (error)
+        return { error: error.message };
+    if (!data)
+        return { error: 'AI work item not found.' };
+    return { work_item: data };
+}
+function stableUuid(input) {
+    const hex = createHash('sha256').update(input).digest('hex').slice(0, 32);
+    const variant = ((parseInt(hex.slice(16, 18), 16) & 0x3f) | 0x80).toString(16).padStart(2, '0');
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-4${hex.slice(13, 16)}-${variant}${hex.slice(18, 20)}-${hex.slice(20, 32)}`;
+}
+async function getOrgIdForProject(projectId) {
+    const { data, error } = await db()
+        .from('projects')
+        .select('org_id')
+        .eq('id', projectId)
+        .maybeSingle();
+    if (error)
+        throw new Error(error.message);
+    if (!data?.org_id)
+        throw new Error('Project org not found.');
+    return data.org_id;
+}
+function segmentActionFromContext(eventType, suggestedActions, title, detail) {
+    if (eventType !== 'strategic_segment_intent')
+        return null;
+    const action = (suggestedActions ?? []).find((candidate) => (candidate.type === 'create_recommended_segment' || candidate.type === 'create_segment' || candidate.kind === 'segment'));
+    if (!action || !action.rules || typeof action.rules !== 'object' || Array.isArray(action.rules))
+        return null;
+    const rawName = typeof action.segment_name === 'string' ? action.segment_name : typeof action.name === 'string' ? action.name : title;
+    return {
+        name: rawName.trim().startsWith('AI:') ? rawName.trim() : `AI: ${rawName.trim()}`,
+        description: typeof action.description === 'string' && action.description.trim() ? action.description.trim() : detail,
+        rules: action.rules,
+    };
+}
+async function submitContextEvent(input) {
+    const projectId = getProjectId();
+    const existing = await db()
+        .from('ai_context_events')
+        .select('*')
+        .eq('project_id', projectId)
+        .eq('source', 'synchronex')
+        .eq('idempotency_key', input.idempotency_key)
+        .maybeSingle();
+    if (existing.error)
+        return { error: existing.error.message };
+    if (existing.data)
+        return { context_event: existing.data, work_item: null, proposals: [], idempotent: true };
+    const orgId = await getOrgIdForProject(projectId);
+    const inserted = await db()
+        .from('ai_context_events')
+        .insert({
+        org_id: orgId,
+        project_id: projectId,
+        workspace_id: input.workspace_id,
+        source: 'synchronex',
+        event_type: input.event_type,
+        title: input.title,
+        detail: input.detail,
+        evidence: input.evidence ?? {},
+        suggested_actions: input.suggested_actions ?? [],
+        idempotency_key: input.idempotency_key,
+    })
+        .select('*')
+        .single();
+    if (inserted.error?.code === '23505') {
+        const duplicate = await db()
+            .from('ai_context_events')
+            .select('*')
+            .eq('project_id', projectId)
+            .eq('source', 'synchronex')
+            .eq('idempotency_key', input.idempotency_key)
+            .maybeSingle();
+        if (duplicate.error)
+            return { error: duplicate.error.message };
+        if (duplicate.data)
+            return { context_event: duplicate.data, work_item: null, proposals: [], idempotent: true };
+    }
+    if (inserted.error)
+        return { error: inserted.error.message };
+    const event = inserted.data;
+    const segmentAction = segmentActionFromContext(input.event_type, input.suggested_actions, input.title, input.detail);
+    const proposals = [];
+    if (segmentAction) {
+        const targetId = stableUuid(`synchronex-context:${projectId}:${event.id}:segment`);
+        const { data: proposal, error } = await db()
+            .from('agent_proposals')
+            .insert({
+            project_id: projectId,
+            org_id: orgId,
+            type: 'create_recommended_segment',
+            target_table: 'segments',
+            target_id: targetId,
+            target_label: segmentAction.name,
+            before_json: { existing_segment_id: null },
+            after_json: {
+                segment_id: targetId,
+                segment_name: segmentAction.name,
+                description: segmentAction.description,
+                rules: segmentAction.rules,
+                estimated_contacts: 0,
+                sample_contact_ids: [],
+                recommendation_kind: 'synchronex_context',
+            },
+            reasoning: input.detail,
+            source_data_refs: [{ table: 'email.ai_context_events', ids: [event.id] }],
+            confidence: typeof input.evidence?.confidence === 'number' ? Math.max(0, Math.min(100, Math.trunc(input.evidence.confidence))) : 75,
+            status: 'pending',
+            expires_at: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000).toISOString(),
+            generated_by: 'synchronex',
+            llm_model: null,
+        })
+            .select(proposalSelect)
+            .single();
+        if (error)
+            return { error: error.message };
+        proposals.push(proposal);
+    }
+    const proposalIds = proposals.map((proposal) => proposal.id);
+    const { data: workItem, error: workError } = await db()
+        .from('ai_work_items')
+        .insert({
+        org_id: orgId,
+        project_id: projectId,
+        kind: proposalIds.length ? 'segment_recommendation' : `synchronex_${input.event_type}`,
+        status: 'new',
+        severity: input.event_type === 'risk_signal' ? 'medium' : 'info',
+        confidence: typeof input.evidence?.confidence === 'number' ? Math.max(0, Math.min(100, Math.trunc(input.evidence.confidence))) : null,
+        source: 'synchronex',
+        title: input.title,
+        why_now: input.detail,
+        evidence: { ...(input.evidence ?? {}), context_event_id: event.id, synchronex_workspace_id: input.workspace_id, event_type: input.event_type },
+        recommended_actions: proposalIds.length
+            ? proposalIds.map((proposalId) => ({ type: 'review_proposal', label: 'Review recommended segment', proposal_id: proposalId, risk: 'low' }))
+            : [{ type: 'review_context', label: 'Review Synchronex context', risk: 'low' }],
+        surfaces: proposalIds.length ? ['overview', 'segments'] : ['overview'],
+        proposal_ids: proposalIds,
+        dedupe_key: `synchronex:${input.workspace_id}:${input.idempotency_key}`,
+        cooldown_until: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString(),
+    })
+        .select(workItemSelect)
+        .single();
+    if (workError)
+        return { error: workError.message };
+    const { data: updatedEvent, error: updateError } = await db()
+        .from('ai_context_events')
+        .update({ work_item_id: workItem.id, proposal_ids: proposalIds })
+        .eq('project_id', projectId)
+        .eq('id', event.id)
+        .select('*')
+        .single();
+    if (updateError)
+        return { error: updateError.message };
+    return { context_event: updatedEvent, work_item: workItem, proposals, idempotent: false };
+}
+export function registerAiWorkTools(server) {
+    server.registerTool('list_ai_work_items', {
+        title: 'List AI Work Items',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+        description: 'List proactive Sendinel AI work items for the current project.',
+        inputSchema: {
+            status: z.string().optional().describe('Comma-separated statuses. Defaults to active: new,seen,snoozed.'),
+            surface: z.string().min(1).max(64).optional(),
+            limit: z.number().int().min(1).max(100).optional().default(25),
+        },
+    }, async ({ status, surface, limit }) => {
+        let query = db()
+            .from('ai_work_items')
+            .select(workItemSelect)
+            .eq('project_id', getProjectId())
+            .in('status', parseStatuses(status))
+            .order('generated_at', { ascending: false })
+            .limit(limit ?? 25);
+        if (surface)
+            query = query.contains('surfaces', [surface]);
+        const { data, error } = await query;
+        if (error)
+            return txt(`Error: ${error.message}`);
+        return j({ work_items: data ?? [] });
+    });
+    server.registerTool('get_ai_work_item', {
+        title: 'Get AI Work Item',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+        description: 'Get one proactive Sendinel AI work item by id for the current project.',
+        inputSchema: {
+            work_item_id: z.string().uuid(),
+        },
+    }, async ({ work_item_id }) => {
+        const { data, error } = await db()
+            .from('ai_work_items')
+            .select(workItemSelect)
+            .eq('project_id', getProjectId())
+            .eq('id', work_item_id)
+            .maybeSingle();
+        if (error)
+            return txt(`Error: ${error.message}`);
+        if (!data)
+            return txt('AI work item not found.');
+        return j({ work_item: data });
+    });
+    server.registerTool('list_recommended_segments', {
+        title: 'List Recommended Segments',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+        description: 'List proactive segment recommendation work items and linked segment proposals.',
+        inputSchema: {
+            status: z.string().optional().describe('Comma-separated work item statuses. Defaults to active: new,seen,snoozed.'),
+            limit: z.number().int().min(1).max(100).optional().default(25),
+        },
+    }, async ({ status, limit }) => {
+        const { data: workItems, error } = await db()
+            .from('ai_work_items')
+            .select(workItemSelect)
+            .eq('project_id', getProjectId())
+            .eq('kind', 'segment_recommendation')
+            .in('status', parseStatuses(status))
+            .order('generated_at', { ascending: false })
+            .limit(limit ?? 25);
+        if (error)
+            return txt(`Error: ${error.message}`);
+        const proposalIds = [...new Set((workItems ?? []).flatMap((item) => Array.isArray(item.proposal_ids) ? item.proposal_ids : []))];
+        let proposals = [];
+        if (proposalIds.length) {
+            const proposalResult = await db()
+                .from('agent_proposals')
+                .select(proposalSelect)
+                .eq('project_id', getProjectId())
+                .in('id', proposalIds);
+            if (proposalResult.error)
+                return txt(`Error: ${proposalResult.error.message}`);
+            proposals = proposalResult.data ?? [];
+        }
+        return j({ work_items: workItems ?? [], proposals });
+    });
+    server.registerTool('mark_ai_work_item_seen', {
+        title: 'Mark AI Work Item Seen',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+        description: 'Mark a proactive Sendinel AI work item as seen.',
+        inputSchema: {
+            work_item_id: z.string().uuid(),
+        },
+    }, async ({ work_item_id }) => {
+        const result = await updateWorkItemStatus(work_item_id, 'seen');
+        return 'error' in result ? txt(`Error: ${result.error}`) : j(result);
+    });
+    server.registerTool('snooze_ai_work_item', {
+        title: 'Snooze AI Work Item',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+        description: 'Snooze a proactive Sendinel AI work item until a future ISO timestamp.',
+        inputSchema: {
+            work_item_id: z.string().uuid(),
+            snoozed_until: z.string().datetime(),
+        },
+    }, async ({ work_item_id, snoozed_until }) => {
+        const result = await updateWorkItemStatus(work_item_id, 'snoozed', snoozed_until);
+        return 'error' in result ? txt(`Error: ${result.error}`) : j(result);
+    });
+    server.registerTool('dismiss_ai_work_item', {
+        title: 'Dismiss AI Work Item',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+        description: 'Dismiss a proactive Sendinel AI work item.',
+        inputSchema: {
+            work_item_id: z.string().uuid(),
+        },
+    }, async ({ work_item_id }) => {
+        const result = await updateWorkItemStatus(work_item_id, 'dismissed');
+        return 'error' in result ? txt(`Error: ${result.error}`) : j(result);
+    });
+    server.registerTool('submit_ai_context_event', {
+        title: 'Submit AI Context Event',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
+        description: 'Submit Synchronex strategic context into Sendinel AI work queue without directly mutating email state.',
+        inputSchema: contextEventInput,
+    }, async (input) => {
+        const result = await submitContextEvent({ ...input, source: 'synchronex' });
+        return 'error' in result ? txt(`Error: ${result.error}`) : j(result);
+    });
+    server.registerTool('list_agent_proposals', {
+        title: 'List Agent Proposals',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+        description: 'List Sendinel agent proposals for the current project.',
+        inputSchema: {
+            status: z.enum(['pending', 'applied', 'auto_applied', 'dismissed', 'disputed', 'stale', 'failed', 'expired']).optional(),
+            type: z.string().min(1).max(96).optional(),
+            target_table: z.string().min(1).max(96).optional(),
+            target_id: z.string().optional(),
+            limit: z.number().int().min(1).max(100).optional().default(25),
+        },
+    }, async ({ status, type, target_table, target_id, limit }) => {
+        let query = db()
+            .from('agent_proposals')
+            .select(proposalSelect)
+            .eq('project_id', getProjectId())
+            .order('generated_at', { ascending: false })
+            .limit(limit ?? 25);
+        if (status)
+            query = query.eq('status', status);
+        if (type)
+            query = query.eq('type', type);
+        if (target_table)
+            query = query.eq('target_table', target_table);
+        if (target_id)
+            query = query.eq('target_id', target_id);
+        const { data, error } = await query;
+        if (error)
+            return txt(`Error: ${error.message}`);
+        return j({ proposals: data ?? [] });
+    });
+    server.registerTool('get_agent_proposal', {
+        title: 'Get Agent Proposal',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+        description: 'Get one Sendinel agent proposal by id for the current project.',
+        inputSchema: {
+            proposal_id: z.string().uuid(),
+        },
+    }, async ({ proposal_id }) => {
+        const { data, error } = await db()
+            .from('agent_proposals')
+            .select(proposalSelect)
+            .eq('project_id', getProjectId())
+            .eq('id', proposal_id)
+            .maybeSingle();
+        if (error)
+            return txt(`Error: ${error.message}`);
+        if (!data)
+            return txt('Agent proposal not found.');
+        return j({ proposal: data });
+    });
+}

package/build/tools/analytics.d.ts

@@ -3,6 +3,7 @@ type EmailLogRow = {
     id?: string;
     status: string;
     sent_at?: string | null;
+    campaign_id?: string | null;
 };
 type AnalyticsMetrics = {
     sent: number;