@sendinel/mcp-server 1.0.190 → 1.0.192

package/README.md

@@ -59,7 +59,9 @@ Sendinel currently exposes 35 tool groups and 349 tools (gateway mode exposes 4
 | `webhooks` | 5 | Webhook subscription management |
 
 `cancel_approval({approval_id})` rejects an unexpired, unused pending/approved
-request in the current project for any write-scoped credential.
+request in the current project for any write-scoped credential. It returns
+`status: "rejected"` (kept for compatibility) plus `outcome: "cancelled"` and
+`cancelled: true`.
 `approve_approval({approval_id})` requires the person's own live OAuth connection
 (`connection_role: NULL`) and its own pending request in that project. Tester,
 agent, API key, service-token and scoped-JWT credentials cannot approve. Sends

package/build/lib/action-approvals.d.ts

@@ -100,6 +100,8 @@ export declare function checkApproval(approvalId: string, options?: {
 }): Promise<Omit<Awaited<ReturnType<typeof checkApprovalState>>, 'decision_channel'> & {
     decision_channel?: string;
     decision_evidence?: DecisionEvidence;
+    outcome?: 'cancelled';
+    cancelled?: true;
 }>;
 declare function checkApprovalState(approvalId: string, options?: {
     consume?: boolean;

package/build/lib/action-approvals.js

@@ -469,7 +469,7 @@ export async function checkApproval(approvalId, options = {}) {
                 .eq('action', 'approval.cancelled').limit(1);
             const cancel = data?.[0];
             if (!error && cancel?.actor_id && typeof cancel.details?.channel === 'string') {
-                return { ...result, decided_by: cancel.actor_id, decision_channel: cancel.details.channel };
+                return { ...result, decided_by: cancel.actor_id, decision_channel: cancel.details.channel, outcome: 'cancelled', cancelled: true };
             }
         }
         catch { /* A failed audit read cannot grant authority or change the status. */ }
@@ -604,10 +604,17 @@ async function checkApprovalState(approvalId, options = {}) {
         approved: true,
         status: 'approved',
         decided_by: claimed.decided_by,
-        ...(options.action && ['send_test_email', 'identify_subscriber', 'emit_contact_event', 'delete_campaign'].includes(options.action) ? { consumed_at: consumedAt } : {}),
+        ...(options.action && RELEASABLE_APPROVAL_ACTIONS.has(options.action) ? { consumed_at: consumedAt } : {}),
         ...(sandboxDecision ? { decision_channel: 'sandbox' } : {}),
     };
 }
+/** Actions whose approval claim can be released (markNotExecuted) after a refusal that changed nothing. */
+const RELEASABLE_APPROVAL_ACTIONS = new Set([
+    'send_test_email', 'identify_subscriber', 'emit_contact_event', 'delete_campaign',
+    // Deletes refused by a foreign key (#4503): nothing was removed, so the same approval can be retried.
+    'delete_campaign_step', 'delete_content_block', 'delete_landing_page', 'delete_signature', 'delete_list',
+    'delete_segment', 'delete_subscriber_view', 'delete_custom_field', 'delete_webhook_subscription',
+]);
 const approvalPreflights = new Map();
 /** Validate live targets before any approval is requested or consumed, including registry gates. */
 export function registerApprovalPreflight(action, fn) {

package/build/lib/approval-tool-decisions.d.ts

@@ -4,6 +4,8 @@ export declare function cancelApproval(approvalId: string, transportClientName?:
 } | {
     approval_id: string;
     status: 'rejected';
+    outcome: 'cancelled';
+    cancelled: true;
 }>;
 export declare function approveApproval(approvalId: string, transportClientName?: string): Promise<{
     code: string;

package/build/lib/approval-tool-decisions.js

@@ -53,12 +53,12 @@ export async function cancelApproval(approvalId, transportClientName) {
             project_id: projectId, actor_type: actor.actorType ?? actor.authKind ?? 'api_key',
             actor_id: actor.actorId ?? actor.keyId ?? actor.oauthTokenId ?? null,
             action: 'approval.cancelled', resource_type: 'approval', resource_id: approvalId,
-            details: { status: 'rejected', channel, client_name: name, auth_kind: actor.authKind ?? null,
+            details: { status: 'rejected', outcome: 'cancelled', channel, client_name: name, auth_kind: actor.authKind ?? null,
                 oauth_token_id: actor.oauthTokenId ?? null, api_key_id: actor.keyId ?? null },
         });
         if (auditError)
             return refuse('approval_audit_failed', 'Approval cancelled, but audit failed. Check its status before retrying.');
-        return { approval_id: approvalId, status: 'rejected' };
+        return { approval_id: approvalId, status: 'rejected', outcome: 'cancelled', cancelled: true };
     }
     catch {
         return refuse('approval_failed', 'Cancellation failed. Check approval status before retrying.');

package/build/lib/db-error.d.ts

@@ -28,6 +28,32 @@ export declare function toolError(body: unknown): {
         text: string;
     }[];
 };
+/** A table known to block a delete. `count` is best-effort; it may throw or return null. */
+export interface DeleteBlocker {
+    table: string;
+    singular: string;
+    plural: string;
+    count: () => Promise<number | null | undefined>;
+}
+/**
+ * A DELETE refused by a foreign key (23503) is a conflict ("something still uses this"), not a
+ * missing record. Returns null for any other error so callers fall through to their normal path.
+ * The global 23503 -> not_found mapping stays correct for INSERTs and is deliberately untouched.
+ * Never copies the database message or constraint names; counts are best-effort and a failed
+ * count never changes the conflict outcome.
+ */
+export declare function deleteBlockedResult(error: unknown, subject: string, blockers?: DeleteBlocker[]): Promise<{
+    error: string;
+    code: 'conflict';
+} | null>;
+/** MCP-result form of deleteBlockedResult: an isError toolError, or null when not a 23503. */
+export declare function deleteBlockedToolResult(error: unknown, subject: string, blockers?: DeleteBlocker[]): Promise<{
+    isError: true;
+    content: {
+        type: 'text';
+        text: string;
+    }[];
+} | null>;
 /** Formats Zod validation issues into plain-English sentences without raw JSON. */
 export declare function formatZodError(error: z.ZodError | {
     issues: Array<{

package/build/lib/db-error.js

@@ -47,6 +47,39 @@ export function dbToolError(error, message = 'Unable to complete database operat
 export function toolError(body) {
     return { isError: true, content: [{ type: 'text', text: JSON.stringify(body, null, 2) }] };
 }
+/**
+ * A DELETE refused by a foreign key (23503) is a conflict ("something still uses this"), not a
+ * missing record. Returns null for any other error so callers fall through to their normal path.
+ * The global 23503 -> not_found mapping stays correct for INSERTs and is deliberately untouched.
+ * Never copies the database message or constraint names; counts are best-effort and a failed
+ * count never changes the conflict outcome.
+ */
+export async function deleteBlockedResult(error, subject, blockers = []) {
+    const code = error && typeof error === 'object' && 'code' in error ? String(error.code) : '';
+    if (code !== '23503')
+        return null;
+    console.warn('[mcp] Delete blocked by linked records:', error);
+    const results = await Promise.allSettled(blockers.map(async (b) => b.count()));
+    const linked = [];
+    const unknown = [];
+    results.forEach((result, index) => {
+        const blocker = blockers[index];
+        const count = result.status === 'fulfilled' ? result.value : null;
+        if (typeof count !== 'number' || !Number.isInteger(count) || count < 0)
+            unknown.push(blocker.table);
+        else if (count > 0)
+            linked.push(`${count} ${count === 1 ? blocker.singular : blocker.plural} (${blocker.table})`);
+    });
+    const reason = linked.length
+        ? `This ${subject} still has ${linked.join(', ')} linked to it, so it cannot be deleted.`
+        : `This ${subject} cannot be deleted because linked records still reference it.`;
+    return { error: unknown.length ? `${reason} Counts for ${unknown.join(', ')} are unavailable.` : reason, code: 'conflict' };
+}
+/** MCP-result form of deleteBlockedResult: an isError toolError, or null when not a 23503. */
+export async function deleteBlockedToolResult(error, subject, blockers = []) {
+    const body = await deleteBlockedResult(error, subject, blockers);
+    return body ? toolError(body) : null;
+}
 /** Formats Zod validation issues into plain-English sentences without raw JSON. */
 export function formatZodError(error) {
     const messages = [];

package/build/lib/delete-blockers.d.ts

@@ -0,0 +1,7 @@
+import type { DeleteBlocker } from './db-error.js';
+/** Best-effort count of rows in email.<table> where <column> = id. Returns null when unknown. */
+export declare function countBlocker(table: string, column: string, id: string, singular: string, plural: string): DeleteBlocker;
+export declare const campaignStepBlockers: (stepId: string) => DeleteBlocker[];
+export declare const segmentBlockers: (segmentId: string) => DeleteBlocker[];
+export declare const subscriberBlockers: (contactId: string) => DeleteBlocker[];
+export declare const campaignBlockers: (campaignId: string) => DeleteBlocker[];

package/build/lib/delete-blockers.js

@@ -0,0 +1,31 @@
+import { db } from '../db.js';
+/** Best-effort count of rows in email.<table> where <column> = id. Returns null when unknown. */
+export function countBlocker(table, column, id, singular, plural) {
+    return {
+        table,
+        singular,
+        plural,
+        count: async () => {
+            const { count, error } = await db().schema('email').from(table)
+                .select('id', { count: 'exact', head: true }).eq(column, id);
+            return error ? null : count;
+        },
+    };
+}
+// NO ACTION foreign keys found by the 2026-11-09 prod scan. History tables stay blockers.
+export const campaignStepBlockers = (stepId) => [
+    countBlocker('email_log', 'step_id', stepId, 'email history record', 'email history records'),
+];
+export const segmentBlockers = (segmentId) => [
+    countBlocker('campaigns', 'segment_id', segmentId, 'campaign', 'campaigns'),
+];
+export const subscriberBlockers = (contactId) => [
+    countBlocker('email_log', 'contact_id', contactId, 'email history record', 'email history records'),
+    countBlocker('revenue_attribution', 'contact_id', contactId, 'revenue attribution record', 'revenue attribution records'),
+];
+export const campaignBlockers = (campaignId) => [
+    countBlocker('ai_drafts', 'campaign_id', campaignId, 'AI draft', 'AI drafts'),
+    countBlocker('email_log', 'campaign_id', campaignId, 'email history record', 'email history records'),
+    countBlocker('revenue_attribution', 'campaign_id', campaignId, 'revenue attribution record', 'revenue attribution records'),
+    countBlocker('campaign_goals', 'target_campaign_id', campaignId, 'campaign goal target', 'campaign goal targets'),
+];

package/build/tools/approvals.js

@@ -23,7 +23,7 @@ export function registerApprovalTools(server, options) {
     });
     server.registerTool('cancel_approval', {
         title: 'Cancel Approval',
-        description: 'Cancel an unexpired, unused pending or approved action approval in this project. Read-scoped OAuth connections can cancel only their own token’s requests; write/admin credentials can cancel any eligible request in this project. Sets it to rejected and records who cancelled and the request channel in the audit; check_approval returns that cancellation attribution. Cannot approve or undo cancellation.',
+        description: 'Cancel an unexpired, unused pending or approved action approval in this project. Read-scoped OAuth connections can cancel only their own token’s requests; write/admin credentials can cancel any eligible request in this project. Marks it cancelled (stored and reported as status `rejected` for backward compatibility; `outcome: "cancelled"` and `cancelled: true` distinguish a withdrawal from a person’s rejection) and records who cancelled and the request channel in the audit; check_approval returns that cancellation attribution. Cannot approve or undo cancellation.',
         annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
         inputSchema: { approval_id: z.string().uuid() },
     }, async ({ approval_id }) => {
@@ -59,7 +59,7 @@ export function registerApprovalTools(server, options) {
             idempotentHint: true,
             openWorldHint: false,
         },
-        description: 'Check the status of a pending action approval. Use this to poll after requesting an action that requires human approval. Returns approved/pending/rejected/expired.',
+        description: 'Check the status of a pending action approval. Use this to poll after requesting an action that requires human approval. Returns approved/pending/rejected/expired; a cancelled approval keeps status `rejected` and adds `outcome: "cancelled"` and `cancelled: true`.',
         inputSchema: {
             approval_id: z.string().uuid().describe('The approval ID returned by the original tool call'),
         },

package/build/tools/campaigns.js

@@ -17,7 +17,8 @@ import { finishCampaignEdit, resumeCampaignEdit, TRIGGER_EDIT_SELECT } from '../
 import { validTimezone } from '@sendinel/domain';
 import { adminDb, db, requestContext } from '../db.js';
 import { getProjectId } from '../project.js';
-import { dbErrorResult, dbToolError, toolError } from '../lib/db-error.js';
+import { dbErrorResult, dbToolError, toolError, deleteBlockedToolResult } from '../lib/db-error.js';
+import { campaignBlockers, campaignStepBlockers } from '../lib/delete-blockers.js';
 import { checkPlanLimit } from '../plan-limits.js';
 import { buildVoicePrompt, buildEmailSystemPrompt, deriveTemplateVariables, validateTemplate } from '../lib/voice.js';
 import { fireWebhookEvent } from '../lib/webhook-events.js';
@@ -38,36 +39,6 @@ import { callSendinelV1 } from '../lib/v1-client.js';
 import { countUniqueEngagementByCampaign } from '../lib/campaign-engagement.js';
 const txt = (text) => ({ content: [{ type: 'text', text }] });
 const j = (data) => txt(JSON.stringify(data, null, 2));
-/** Diagnose a rejected DELETE, without exposing Postgres diagnostics or guessing missing counts. */
-async function campaignDeleteConflict(campaignId) {
-    const sources = [
-        { table: 'ai_drafts', column: 'campaign_id', singular: 'AI draft', plural: 'AI drafts' },
-        { table: 'email_log', column: 'campaign_id', singular: 'email history record', plural: 'email history records' },
-        { table: 'revenue_attribution', column: 'campaign_id', singular: 'revenue attribution record', plural: 'revenue attribution records' },
-        { table: 'campaign_goals', column: 'target_campaign_id', singular: 'campaign goal target', plural: 'campaign goal targets' },
-    ];
-    // The caller has verified ownership of this campaign. Count all references to its UUID;
-    // campaign_goals has no project_id, and filtering by the owning campaign misses targets.
-    const results = await Promise.allSettled(sources.map(async (source) => {
-        const { count, error } = await db().schema('email').from(source.table)
-            .select('id', { count: 'exact', head: true }).eq(source.column, campaignId);
-        return !error && typeof count === 'number' && Number.isInteger(count) && count >= 0 ? count : null;
-    }));
-    const linked = [];
-    const unknown = [];
-    results.forEach((result, index) => {
-        const source = sources[index];
-        const count = result.status === 'fulfilled' ? result.value : null;
-        if (count === null)
-            unknown.push(source.table);
-        else if (count > 0)
-            linked.push(`${count} ${count === 1 ? source.singular : source.plural} (${source.table})`);
-    });
-    const reason = linked.length
-        ? `This campaign still has ${linked.join(', ')} linked to it, so it cannot be deleted.`
-        : 'This campaign cannot be deleted because linked records still reference it.';
-    return unknown.length ? `${reason} Counts for ${unknown.join(', ')} are unavailable.` : reason;
-}
 const ACTIVATION_APPROVAL_DESCRIPTION = 'Activation-only: requires_approval gates campaign activation. It does not stop sends of an already-active campaign or sends triggered by other paths.';
 const REENTRY_DESCRIPTION = 'Re-entry defaults to once ever. per_event_period uses a flat event-data period_key on event-triggered campaigns only. Changing a live campaign returns an approval request. Existing enrollments without a period cannot re-enter; sends wait for campaign-cycle approval.';
 const reentryFields = {
@@ -3611,6 +3582,9 @@ Return ONLY valid JSON with this exact shape:
             .from('campaign_steps')
             .delete()
             .eq('id', step_id);
+        const blocked = await deleteBlockedToolResult(error, 'step', campaignStepBlockers(step_id));
+        if (blocked)
+            return markNotExecuted(blocked);
         if (error)
             return j(dbToolError(error));
         return j({ ok: true, deleted: step_id });
@@ -3646,10 +3620,10 @@ Return ONLY valid JSON with this exact shape:
             .delete()
             .eq('id', campaign_id)
             .eq('project_id', projectId);
-        if (error?.code === '23503') {
-            // A rejected statement made no changes, so the same approval is safe to retry.
-            return markNotExecuted(toolError({ code: 'conflict', error: await campaignDeleteConflict(campaign_id) }));
-        }
+        // A rejected statement made no changes, so the same approval is safe to retry.
+        const blocked = await deleteBlockedToolResult(error, 'campaign', campaignBlockers(campaign_id));
+        if (blocked)
+            return markNotExecuted(blocked);
         if (error)
             return j(dbToolError(error));
         return j({ success: true, deleted: campaign.name });

package/build/tools/contacts.js

@@ -8,7 +8,7 @@ import { z } from 'zod';
 import { callSendinelV1 } from '../lib/v1-client.js';
 import { db, projectClientForWriteback } from '../db.js';
 import { getProjectId } from '../project.js';
-import { dbErrorResult, dbToolError, toolError } from '../lib/db-error.js';
+import { dbErrorResult, dbToolError, toolError, deleteBlockedToolResult } from '../lib/db-error.js';
 import { resolveSegmentContactIds } from '../lib/send-audience.js';
 import { checkPlanLimit, contactLimitMessage } from '../plan-limits.js';
 import { logConsent, logAudit } from '../audit.js';
@@ -1230,6 +1230,9 @@ Requirements: urgency without desperation, acknowledge the gap, one clear CTA, v
             .eq('project_id', getProjectId())
             .select('id')
             .maybeSingle();
+        const blocked = await deleteBlockedToolResult(error, 'subscriber view');
+        if (blocked)
+            return markNotExecuted(blocked);
         if (error)
             return txt(`Error: ${dbToolError(error).error}`);
         if (!data)
@@ -2940,6 +2943,9 @@ Requirements: urgency without desperation, acknowledge the gap, one clear CTA, v
             .eq('project_id', projectId)
             .select('id, key')
             .maybeSingle();
+        const blocked = await deleteBlockedToolResult(error, 'custom field');
+        if (blocked)
+            return markNotExecuted(blocked);
         if (error)
             return txt(`Error: ${dbToolError(error).error}`);
         if (!data)

package/build/tools/content.js

@@ -1,10 +1,10 @@
 import { withCreatedItems } from '../lib/mcp-created-items.js';
-import { withApproval } from '../lib/action-approvals.js';
+import { markNotExecuted, withApproval } from '../lib/action-approvals.js';
 import { z } from 'zod';
 import { adminDb, db } from '../db.js';
 import { getProjectId } from '../project.js';
 import { refuseActiveTextFields, stripActiveEmailContent, validateUnsubscribeFooterTemplate } from '@sendinel/domain';
-import { dbToolError, toolError } from '../lib/db-error.js';
+import { dbToolError, toolError, deleteBlockedToolResult } from '../lib/db-error.js';
 import { logAudit } from '../audit.js';
 import { assertHttpUrl } from '../lib/url-validation.js';
 const j = (data) => ({ content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] });
@@ -263,6 +263,9 @@ export function registerContentTools(server) {
         inputSchema: { approval_id: z.string().uuid().optional().describe('Get this by calling once without it, then have a human approve the returned approve_url. Re-call with only approval_id to run the action.'), block_id: z.string().uuid() },
     }, withApproval('delete_content_block', async ({ block_id }) => {
         const { error } = await db().from('content_blocks').delete().eq('project_id', getProjectId()).eq('id', block_id);
+        const blocked = await deleteBlockedToolResult(error, 'content block');
+        if (blocked)
+            return markNotExecuted(blocked);
         if (error)
             return j(dbToolError(error));
         return j({ deleted: true });

package/build/tools/data.js

@@ -7,7 +7,7 @@ import { normalizeActiveCampaignAccountUrl } from '../lib/url-validation.js';
 import { assertChannelCanExecute, checkApproval, currentChannelContext, requestApproval, withApproval } from '../lib/action-approvals.js';
 import { getProjectId } from '../project.js';
 import { logAudit } from '../audit.js';
-import { dbToolError } from '../lib/db-error.js';
+import { dbToolError, deleteBlockedToolResult } from '../lib/db-error.js';
 const j = (data) => ({ content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] });
 function generateApiKey() {
     const secret = `snk_${randomBytes(32).toString('hex')}`;
@@ -449,6 +449,9 @@ export function registerDataTools(server) {
                     .eq('project_id', context.projectId)
                     .select('id, platform')
                     .maybeSingle();
+                const blocked = await deleteBlockedToolResult(error, 'provider connection');
+                if (blocked)
+                    return blocked;
                 if (error)
                     return j(dbToolError(error));
                 if (!data)

package/build/tools/gdpr.js

@@ -4,7 +4,8 @@ import { db } from '../db.js';
 import { getProjectId } from '../project.js';
 import { logAudit } from '../audit.js';
 import { approvalSatisfied, assertChannelCanExecute, currentChannelContext, requestApproval, checkApproval } from '../lib/action-approvals.js';
-import { dbToolError } from '../lib/db-error.js';
+import { dbToolError, deleteBlockedToolResult } from '../lib/db-error.js';
+import { subscriberBlockers } from '../lib/delete-blockers.js';
 const txt = (text) => ({ content: [{ type: 'text', text }] });
 const j = (data) => txt(JSON.stringify(data, null, 2));
 export function registerGdprTools(server) {
@@ -52,6 +53,9 @@ export function registerGdprTools(server) {
             p_reason: reason ?? 'gdpr_request',
             p_deleted_by: 'mcp',
         });
+        const blocked = await deleteBlockedToolResult(error, 'subscriber', subscriberBlockers(contact_id));
+        if (blocked)
+            return blocked;
         if (error)
             return txt(`Error: ${dbToolError(error).error}`);
         logAudit({ action: 'contact.gdpr_deleted', resourceType: 'contact', resourceId: contact_id, details: { reason, result: data } });

package/build/tools/landing-pages.js

@@ -1,11 +1,11 @@
 import { withCreatedItems } from '../lib/mcp-created-items.js';
-import { withApproval } from '../lib/action-approvals.js';
+import { markNotExecuted, withApproval } from '../lib/action-approvals.js';
 import { z } from 'zod';
 import { db } from '../db.js';
 import { getProjectId } from '../project.js';
 import { logAudit } from '../audit.js';
 import { stripActiveEmailContent } from '@sendinel/domain';
-import { dbToolError, toolError } from '../lib/db-error.js';
+import { dbToolError, toolError, deleteBlockedToolResult } from '../lib/db-error.js';
 const j = (data) => ({ content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] });
 const SLUG_RE = /^[a-z0-9][a-z0-9\-]{0,62}$/;
 const VALID_STATUSES = ['draft', 'published', 'archived'];
@@ -274,6 +274,9 @@ export function registerLandingPageTools(server) {
             .delete()
             .eq('id', page_id)
             .eq('project_id', projectId);
+        const blocked = await deleteBlockedToolResult(error, 'landing page');
+        if (blocked)
+            return markNotExecuted(blocked);
         if (error)
             return j(dbToolError(error));
         await logAudit({ action: 'landing_page.deleted', resourceType: 'landing_page', resourceId: page_id });

package/build/tools/lists.js

@@ -5,8 +5,8 @@ import { applySegmentRules, buildSegmentBaseQuery, evaluateSegmentRules, hydrate
 import { db } from '../db.js';
 import { getProjectId } from '../project.js';
 import { logAudit } from '../audit.js';
-import { assertChannelCanExecute, checkApproval, currentChannelContext, requestApproval, withApproval, } from '../lib/action-approvals.js';
-import { dbToolError } from '../lib/db-error.js';
+import { assertChannelCanExecute, checkApproval, currentChannelContext, requestApproval, markNotExecuted, withApproval, } from '../lib/action-approvals.js';
+import { dbToolError, deleteBlockedToolResult } from '../lib/db-error.js';
 const LIST_MEMBER_BATCH_SIZE = 500;
 const txt = (text) => ({ content: [{ type: 'text', text }] });
 const j = (data) => txt(JSON.stringify(data, null, 2));
@@ -196,6 +196,9 @@ export function registerListTools(server) {
             .delete()
             .eq('id', list_id)
             .eq('project_id', projectId);
+        const blocked = await deleteBlockedToolResult(error, 'list');
+        if (blocked)
+            return markNotExecuted(blocked);
         if (error)
             return txt(`Error: ${dbToolError(error).error}`);
         await logAudit({ action: 'list.deleted', resourceType: 'list', resourceId: list_id });

package/build/tools/segments.js

@@ -1,10 +1,11 @@
 import { withCreatedItems } from '../lib/mcp-created-items.js';
-import { withApproval } from '../lib/action-approvals.js';
+import { markNotExecuted, withApproval } from '../lib/action-approvals.js';
 import { z } from 'zod';
 import Anthropic from '@anthropic-ai/sdk';
 import { db } from '../db.js';
 import { getProjectId } from '../project.js';
-import { dbErrorResult, dbToolError, toolError } from '../lib/db-error.js';
+import { dbErrorResult, dbToolError, toolError, deleteBlockedToolResult } from '../lib/db-error.js';
+import { segmentBlockers } from '../lib/delete-blockers.js';
 import { getAnthropicModelId } from '../anthropic-model.js';
 import { AI_MAX_TOKENS, outputConfig, anthropicCheckedText } from '@sendinel/domain';
 import { SEGMENT_OPERATORS_DESCRIPTION, applySegmentRules, buildSegmentBaseQuery, evaluateSegmentRules, hydrateEmailSendsContacts, isSegmentRulesError, normalizeSegmentRulesToTree, prepareSegmentRulesForStorage, readAllRows, } from '@sendinel/domain';
@@ -219,6 +220,9 @@ export function registerSegmentTools(server) {
             .delete()
             .eq('id', segment_id)
             .eq('project_id', getProjectId());
+        const blocked = await deleteBlockedToolResult(error, 'segment', segmentBlockers(segment_id));
+        if (blocked)
+            return markNotExecuted(blocked);
         if (error)
             return txt(`Error: ${dbToolError(error).error}`);
         return j({ deleted: true, segment_id });

package/build/tools/signatures.js

@@ -1,10 +1,10 @@
 import { withCreatedItems } from '../lib/mcp-created-items.js';
-import { withApproval } from '../lib/action-approvals.js';
+import { markNotExecuted, withApproval } from '../lib/action-approvals.js';
 import { z } from 'zod';
 import { db } from '../db.js';
 import { getProjectId } from '../project.js';
 import { logAudit } from '../audit.js';
-import { dbToolError } from '../lib/db-error.js';
+import { dbToolError, deleteBlockedToolResult } from '../lib/db-error.js';
 const txt = (text) => ({ content: [{ type: 'text', text }] });
 const j = (data) => txt(JSON.stringify(data, null, 2));
 const COLUMNS = 'id, site_id, name, html, is_default, created_at, updated_at';
@@ -158,6 +158,9 @@ export function registerSignatureTools(server) {
             .delete()
             .eq('id', id)
             .eq('project_id', projectId);
+        const blocked = await deleteBlockedToolResult(error, 'signature');
+        if (blocked)
+            return markNotExecuted(blocked);
         if (error)
             return j(dbToolError(error));
         await logAudit({

package/build/tools/webhooks.js

@@ -1,11 +1,11 @@
 import { withCreatedItems } from '../lib/mcp-created-items.js';
-import { withApproval } from '../lib/action-approvals.js';
+import { markNotExecuted, withApproval } from '../lib/action-approvals.js';
 import { z } from 'zod';
 import { listSandboxWebhookEvents } from '@sendinel/domain';
 import { db, adminDb } from '../db.js';
 import { getProjectId } from '../project.js';
 import { validateWebhookUrl, generateWebhookSecret } from '../lib/webhook-events.js';
-import { dbToolError } from '../lib/db-error.js';
+import { dbToolError, deleteBlockedToolResult } from '../lib/db-error.js';
 const txt = (text) => ({ content: [{ type: 'text', text }] });
 const j = (data) => txt(JSON.stringify(data, null, 2));
 const VALID_EVENTS = [
@@ -169,6 +169,9 @@ export function registerWebhookTools(server) {
             .delete()
             .eq('id', subscription_id)
             .eq('project_id', getProjectId());
+        const blocked = await deleteBlockedToolResult(error, 'webhook subscription');
+        if (blocked)
+            return markNotExecuted(blocked);
         if (error)
             return txt(`Error: ${dbToolError(error).error}`);
         return txt(`Subscription ${subscription_id} deleted.`);

package/package.json

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