@sendinel/mcp-server 1.0.101 → 1.0.102

package/build/lib/send-audience.d.ts

@@ -9,7 +9,11 @@ import { type SegmentRules } from '@sendinel/domain';
  * Every read throws on failure: an unknown audience must never read as "nobody" or "everyone".
  */
 export type SendClass = 'broadcast' | 'product';
-/** Contact ids matching segment rules (same semantics as the segments tools and the dashboard). */
+/**
+ * Contact ids matching segment rules (same semantics as the segments tools and the dashboard).
+ * Throws SegmentRulesError for invalid rules (#4270): a malformed rule never widens to everyone,
+ * and `{ match_all: true }` is the only way to ask for every contact.
+ */
 export declare function resolveSegmentContactIds(projectId: string, rules: SegmentRules): Promise<string[]>;
 export type SendAudience = {
     /** People the send will enroll. */

package/build/lib/send-audience.js

@@ -15,9 +15,15 @@ async function loadFieldTypes(projectId) {
     }
     return fields;
 }
-/** Contact ids matching segment rules (same semantics as the segments tools and the dashboard). */
+/**
+ * Contact ids matching segment rules (same semantics as the segments tools and the dashboard).
+ * Throws SegmentRulesError for invalid rules (#4270): a malformed rule never widens to everyone,
+ * and `{ match_all: true }` is the only way to ask for every contact.
+ */
 export async function resolveSegmentContactIds(projectId, rules) {
     const tree = normalizeSegmentRulesToTree(rules);
+    if (tree.match_none)
+        return [];
     const fieldTypes = rules.custom_property ? await loadFieldTypes(projectId) : {};
     const q = buildSegmentBaseQuery(db(), projectId);
     const { query: filtered, siteContactIds } = await applySegmentRules(q, rules, db(), projectId, fieldTypes);

package/build/tools/campaigns.js

@@ -2,7 +2,7 @@ import { readCampaignPeriods, campaignPeriodFields } from "@sendinel/domain";
 import { CAMPAIGN_BRANCH_CONDITIONS, campaignBranchConditionValue, isContactPropertyConditionList, STEP_PROPERTY_CONDITIONS_ERROR, validateStepPropertyRules } from "@sendinel/domain";
 import { z } from 'zod';
 import Anthropic from '@anthropic-ai/sdk';
-import { assertSendAccepted, providerSendError, sendError, SendRefusedError, BLOCKING_CONTENT_ISSUE_KINDS, computeSendContentKey, findContentIssues, sendingHostOf, NAME_FALLBACKS, ONE_SEND_MATCH_STATUSES, ONE_SEND_SENT_STATUSES, ONE_SEND_WINDOW_DAYS, normalizeTriggerConfig, renderTemplateString as renderTemplateVars, resolveBrandTokens, brandWarnings, readAllRows, } from '@sendinel/domain';
+import { assertSendAccepted, providerSendError, sendError, SendRefusedError, BLOCKING_CONTENT_ISSUE_KINDS, computeSendContentKey, findContentIssues, sendingHostOf, NAME_FALLBACKS, ONE_SEND_MATCH_STATUSES, ONE_SEND_SENT_STATUSES, ONE_SEND_WINDOW_DAYS, normalizeTriggerConfig, renderTemplateString as renderTemplateVars, resolveBrandTokens, brandWarnings, readAllRows, isSegmentRulesError, scopeSegmentRulesToSite, SegmentRulesError, validateSegmentRules, } from '@sendinel/domain';
 // Subpath import, not the barrel above -- reply-actions.ts uses node:crypto,
 // and MCP-server-side that's fine (this never runs in an Edge Function), but
 // keeping it off the shared barrel avoids re-creating the Edge-Function
@@ -15,7 +15,7 @@ import { checkPlanLimit } from '../plan-limits.js';
 import { buildVoicePrompt, buildEmailSystemPrompt, deriveTemplateVariables, validateTemplate } from '../lib/voice.js';
 import { fireWebhookEvent } from '../lib/webhook-events.js';
 import { approvalExcerpt, assertChannelCanExecute, currentChannelContext, requestApproval, checkApproval, withApproval } from '../lib/action-approvals.js';
-import { resolveSendAudience } from '../lib/send-audience.js';
+import { resolveSegmentContactIds, resolveSendAudience } from '../lib/send-audience.js';
 import { generateEmailFromBrief, parseAudienceRules } from '../lib/email-generation.js';
 import { getAnthropicModelId } from '../anthropic-model.js';
 import { assertUsableStopReason } from '@sendinel/domain';
@@ -1164,10 +1164,7 @@ export function registerCampaignTools(server) {
             .maybeSingle();
         if (segmentErr || !segment)
             return j({ error: segmentErr?.message ?? 'Segment not found', code: 'SEGMENT_NOT_FOUND' });
-        const rules = {
-            ...(segment.rules ?? {}),
-            ...(segment.site_id ? { site_id: segment.site_id } : {}),
-        };
+        const rules = scopeSegmentRulesToSite(segment.rules, segment.site_id);
         // #3669: the same audience rules as send_broadcast and the dashboard: paged, signed up to this
         // sender, consent gate applied. The count shown is the count enrolled.
         let audience;
@@ -1175,6 +1172,9 @@ export function registerCampaignTools(server) {
             audience = await resolveSendAudience(projectId, site_id, rules);
         }
         catch (error) {
+            // #4270: a malformed segment enrolls nobody and says why.
+            if (isSegmentRulesError(error))
+                return j({ error: error.message, code: 'INVALID_SEGMENT_RULES', errors: error.errors });
             return j({ error: `Could not load this audience: ${error instanceof Error ? error.message : String(error)}`, code: 'AUDIENCE_LOOKUP_FAILED' });
         }
         const contactIds = audience.contactIds;
@@ -1423,7 +1423,7 @@ export function registerCampaignTools(server) {
                 return j({ error: segmentErr.message, code: 'SEGMENT_LOOKUP_FAILED' });
             if (!segment)
                 return j({ error: 'Segment not found', code: 'SEGMENT_NOT_FOUND' });
-            rules = { ...(segment.rules ?? {}), ...(segment.site_id ? { site_id: segment.site_id } : {}) };
+            rules = scopeSegmentRulesToSite(segment.rules, segment.site_id);
             segmentName = segment.name;
         }
         else {
@@ -1441,6 +1441,9 @@ export function registerCampaignTools(server) {
             resolved = await resolveSendAudience(projectId, site.id, rules, sendClass);
         }
         catch (error) {
+            // #4270: malformed segment or parsed audience rules send to nobody and say why.
+            if (isSegmentRulesError(error))
+                return j({ error: error.message, code: 'INVALID_SEGMENT_RULES', errors: error.errors, rules });
             return j({ error: `Could not load this audience: ${error instanceof Error ? error.message : String(error)}`, code: 'AUDIENCE_LOOKUP_FAILED' });
         }
         if (resolved.contactIds.length === 0) {
@@ -1884,6 +1887,10 @@ Adapt your tone accordingly:
         async function launchFromPlan(plan) {
             let segId = segment_id;
             if (segment_description) {
+                // #4270: never save a segment from rules the segment engine can't use.
+                const rulesCheck = validateSegmentRules(plan.rules);
+                if (!rulesCheck.ok)
+                    return txt(`Error: Could not use the audience rules. ${rulesCheck.errors[0]} Nothing was created.`);
                 const { data: seg, error: segErr } = await db()
                     .from('segments')
                     .insert({ project_id: projectId, name: plan.segment_name, description: segment_description, rules: plan.rules })
@@ -2006,8 +2013,22 @@ Adapt your tone accordingly:
                 q = q.lte(column, rule.before);
             return q;
         }
-        // Helper to get segment contact IDs (simplified inline)
+        // Helper to get segment contact IDs (simplified inline). #4270: rules are validated first
+        // (SegmentRulesError), and anything this flat helper cannot evaluate (rule trees, markers,
+        // custom_property, company filters, multi-tag) goes through the shared evaluator instead of
+        // being ignored, which used to widen those segments to everyone.
+        const INLINE_RULE_KEYS = new Set([
+            'lifecycle_stage', 'payment', 'min_score', 'max_score', 'source', 'subscribed_after', 'subscribed_before',
+            'has_opened', 'has_clicked', 'tag', 'site_id', 'exclude_suppressed', 'metadata',
+        ]);
         const getContactIds = async (rules) => {
+            const check = validateSegmentRules(rules);
+            if (!check.ok)
+                throw new SegmentRulesError(check.errors);
+            const inlineCanEvaluate = Object.keys(rules).every((key) => rules[key] === undefined || INLINE_RULE_KEYS.has(key))
+                && (rules.tag === undefined || typeof rules.tag === 'string');
+            if (!inlineCanEvaluate)
+                return resolveSegmentContactIds(projectId, rules);
             let q = db().from('subscribers').select('id, email').eq('project_id', projectId).eq('global_unsubscribed', false).is('cooled_at', null);
             if (rules.lifecycle_stage)
                 q = q.eq('lifecycle_stage', rules.lifecycle_stage);
@@ -2073,7 +2094,14 @@ Adapt your tone accordingly:
             catch {
                 return txt(`Error: Failed to parse segment from "${segment_description}"`);
             }
-            contactIds = await getContactIds(parsedRules);
+            try {
+                contactIds = await getContactIds(parsedRules);
+            }
+            catch (error) {
+                if (isSegmentRulesError(error))
+                    return txt(`Error: Could not use the audience parsed from "${segment_description}". ${error.message}`);
+                throw error;
+            }
             contactCount = contactIds.length;
             segmentName = `${name} — segment`;
         }
@@ -2088,7 +2116,14 @@ Adapt your tone accordingly:
                 return txt('Error: segment not found');
             segmentName = seg.name;
             parsedRules = seg.rules;
-            contactIds = await getContactIds(parsedRules);
+            try {
+                contactIds = await getContactIds(parsedRules);
+            }
+            catch (error) {
+                if (isSegmentRulesError(error))
+                    return txt(`Error: Segment "${seg.name}" has rules that can't be used. ${error.message}`);
+                throw error;
+            }
             contactCount = contactIds.length;
         }
         if (!confirmed) {

package/build/tools/contacts.js

@@ -1,7 +1,7 @@
 import { ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { CONTACT_ENRICHMENT_PROVIDERS } from '@desler/models';
 import { createContactEnrichmentAdapters, enrichContactFromConnections, } from '@desler/models/contact-enrichment';
-import { buildPreviewAttentionEnvelope, applySegmentRules, ContactPropertyAnomalyLogger, normalizeContactProperties, getAttentionDecision, getContactNeighborhood, getScheduledTouches, findContactDuplicateGroups, readAllPages, readAllRows, chunkIds, } from '@sendinel/domain';
+import { buildPreviewAttentionEnvelope, applySegmentRules, isSegmentRulesError, ContactPropertyAnomalyLogger, normalizeContactProperties, getAttentionDecision, getContactNeighborhood, getScheduledTouches, findContactDuplicateGroups, readAllPages, readAllRows, chunkIds, } from '@sendinel/domain';
 import { z } from 'zod';
 import { callSendinelV1 } from '../lib/v1-client.js';
 import { db, projectClientForWriteback } from '../db.js';
@@ -2103,11 +2103,20 @@ Requirements: urgency without desperation, acknowledge the gap, one clear CTA, v
             q = q.eq('company_id', params.company_id);
         const fieldTypes = params.custom_property ? await loadContactPropertyDefinitions(projectId) : {};
         if (params.custom_property) {
-            ({ query: q } = await applySegmentRules(q, { custom_property: params.custom_property }, db(), projectId, fieldTypes));
+            try {
+                // #4270: the query runs as-is, so a filter it cannot express is an error, not dropped.
+                ({ query: q } = await applySegmentRules(q, { custom_property: params.custom_property }, db(), projectId, fieldTypes, { pushDownOnly: true }));
+            }
+            catch (error) {
+                if (isSegmentRulesError(error))
+                    return txt(`Error: ${error.message}`);
+                throw error;
+            }
         }
         if (params.site_id) {
             // Shared site filter: an inner join, not an id list that overflows past ~350 contacts (#3674).
-            const siteFiltered = await applySegmentRules(q, { site_id: params.site_id }, db(), projectId);
+            // Deliberately everyone on the site, so allowEmpty.
+            const siteFiltered = await applySegmentRules(q, { site_id: params.site_id }, db(), projectId, {}, { allowEmpty: true });
             if (siteFiltered.siteContactIds && siteFiltered.siteContactIds.length === 0)
                 return j({ total: 0, sample: [] });
             q = siteFiltered.query;
@@ -2155,11 +2164,11 @@ Requirements: urgency without desperation, acknowledge the gap, one clear CTA, v
         if (params.tag)
             countQ = countQ.contains('tags', [params.tag]);
         if (params.custom_property) {
-            ({ query: countQ } = await applySegmentRules(countQ, { custom_property: params.custom_property }, db(), projectId, fieldTypes));
+            ({ query: countQ } = await applySegmentRules(countQ, { custom_property: params.custom_property }, db(), projectId, fieldTypes, { pushDownOnly: true }));
         }
         // The total must count the same site the sample came from (#3674).
         if (params.site_id)
-            ({ query: countQ } = await applySegmentRules(countQ, { site_id: params.site_id }, db(), projectId));
+            ({ query: countQ } = await applySegmentRules(countQ, { site_id: params.site_id }, db(), projectId, {}, { allowEmpty: true }));
         const { count } = await countQ;
         return j({ total: count ?? (data ?? []).length, sample: data ?? [] });
     });

package/build/tools/lists.js

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { applySegmentRules, buildSegmentBaseQuery, evaluateSegmentRules, normalizeSegmentRulesToTree, readAllRows, } from '@sendinel/domain';
+import { applySegmentRules, buildSegmentBaseQuery, evaluateSegmentRules, isSegmentRulesError, normalizeSegmentRulesToTree, readAllRows, } from '@sendinel/domain';
 import { db } from '../db.js';
 import { getProjectId } from '../project.js';
 import { logAudit } from '../audit.js';
@@ -28,7 +28,10 @@ async function loadFieldTypes(projectId) {
 }
 async function getSegmentContactIds(rules) {
     const projectId = getProjectId();
+    // Throws SegmentRulesError for invalid rules (#4270) instead of widening to everyone.
     const tree = normalizeSegmentRulesToTree(rules);
+    if (tree.match_none)
+        return [];
     const fieldTypes = rules.custom_property ? await loadFieldTypes(projectId) : {};
     const q = buildSegmentBaseQuery(db(), projectId);
     const { query: filtered, siteContactIds } = await applySegmentRules(q, rules, db(), projectId, fieldTypes);
@@ -357,7 +360,16 @@ export function registerListTools(server) {
         },
     }, async ({ list_id, rules, confirmed, approval_id }) => {
         const projectId = getProjectId();
-        const normalizedRules = normalizeSegmentRulesToTree(rules);
+        let normalizedRules;
+        try {
+            normalizedRules = normalizeSegmentRulesToTree(rules);
+        }
+        catch (rulesError) {
+            // #4270: invalid (or empty) filter rules add nobody and say why. Everyone is { match_all: true }.
+            if (isSegmentRulesError(rulesError))
+                return j({ error: rulesError.message, code: 'INVALID_SEGMENT_RULES', errors: rulesError.errors });
+            throw rulesError;
+        }
         const approvalParams = { list_id, rules: normalizedRules };
         const { data: list, error: listError } = await db()
             .from('contact_lists')

package/build/tools/segments.js

@@ -5,7 +5,7 @@ import { db } from '../db.js';
 import { getProjectId } from '../project.js';
 import { getAnthropicModelId } from '../anthropic-model.js';
 import { assertUsableStopReason } from '@sendinel/domain';
-import { applySegmentRules, buildSegmentBaseQuery, evaluateSegmentRules, normalizeSegmentRulesToTree, readAllRows, } from '@sendinel/domain';
+import { applySegmentRules, buildSegmentBaseQuery, evaluateSegmentRules, isSegmentRulesError, normalizeSegmentRulesToTree, prepareSegmentRulesForStorage, readAllRows, } from '@sendinel/domain';
 async function loadFieldTypes(projectId) {
     const client = db();
     const scoped = typeof client.schema === 'function' ? client.schema('email') : client;
@@ -27,7 +27,10 @@ async function loadFieldTypes(projectId) {
 }
 async function getSegmentContactIds(rules) {
     const projectId = getProjectId();
+    // Throws SegmentRulesError for invalid rules (#4270) instead of widening to everyone.
     const tree = normalizeSegmentRulesToTree(rules);
+    if (tree.match_none)
+        return [];
     const fieldTypes = rules.custom_property ? await loadFieldTypes(projectId) : {};
     // Shared base query (#3084). This used to be hand-written here and omitted
     // is_test / source_deleted_at / the cooled exclusion the dashboard applies,
@@ -53,6 +56,13 @@ async function getSegmentContactIds(rules) {
 }
 const txt = (text) => ({ content: [{ type: 'text', text }] });
 const j = (data) => txt(JSON.stringify(data, null, 2));
+/**
+ * #4270: invalid segment rules are an error response naming the first problem,
+ * never an audience of everyone. Returns null for any other error.
+ */
+function invalidRules(error) {
+    return isSegmentRulesError(error) ? txt(`Error: ${error.message}`) : null;
+}
 export function registerSegmentTools(server) {
     server.registerTool('create_segment', {
         title: 'Create Segment',
@@ -69,9 +79,19 @@ export function registerSegmentTools(server) {
             rules: z.record(z.string(), z.unknown()).describe('Segment rule tree: {op:"AND"|"OR", conditions:[{field, operator, value}]} or legacy flat rules. Supported fields include lifecycle_stage, engagement_score, source, created_at, last_opened_at, last_clicked_at, introduced_by_subscriber_id, tags, custom_properties.<key>, payment.<key>. tag may be a plain string (one tag) or {values: string[], mode: "any"|"all"} to match several tags at once.'),
         },
     }, async ({ name, description, rules }) => {
+        let storedRules;
+        try {
+            storedRules = prepareSegmentRulesForStorage(rules);
+        }
+        catch (rulesError) {
+            const invalid = invalidRules(rulesError);
+            if (invalid)
+                return invalid;
+            throw rulesError;
+        }
         const { data, error } = await db()
             .from('segments')
-            .insert({ project_id: getProjectId(), name, description, rules: normalizeSegmentRulesToTree(rules) })
+            .insert({ project_id: getProjectId(), name, description, rules: storedRules })
             .select('id, name, description, rules, created_at')
             .single();
         if (error)
@@ -105,7 +125,17 @@ export function registerSegmentTools(server) {
             return txt(`Error: ${error.message}`);
         const segments = [];
         for (const seg of data ?? []) {
-            const ids = await getSegmentContactIds(seg.rules);
+            let ids;
+            try {
+                ids = await getSegmentContactIds(seg.rules);
+            }
+            catch (rulesError) {
+                if (!isSegmentRulesError(rulesError))
+                    throw rulesError;
+                // #4270: one stored segment with invalid rules matches nobody; its count is unknown, not 0.
+                segments.push({ ...seg, contact_count: null, rules_error: rulesError.message });
+                continue;
+            }
             segments.push({ ...seg, contact_count: ids.length });
         }
         return j(segments);
@@ -131,8 +161,17 @@ export function registerSegmentTools(server) {
             updates.name = name;
         if (description !== undefined)
             updates.description = description;
-        if (rules)
-            updates.rules = normalizeSegmentRulesToTree(rules);
+        if (rules) {
+            try {
+                updates.rules = prepareSegmentRulesForStorage(rules);
+            }
+            catch (rulesError) {
+                const invalid = invalidRules(rulesError);
+                if (invalid)
+                    return invalid;
+                throw rulesError;
+            }
+        }
         const { data, error } = await db()
             .from('segments')
             .update(updates)
@@ -199,7 +238,16 @@ export function registerSegmentTools(server) {
         else {
             return txt('Provide either segment_id or rules.');
         }
-        const ids = await getSegmentContactIds(segRules);
+        let ids;
+        try {
+            ids = await getSegmentContactIds(segRules);
+        }
+        catch (rulesError) {
+            const invalid = invalidRules(rulesError);
+            if (invalid)
+                return invalid;
+            throw rulesError;
+        }
         const sample = ids.slice(0, 10);
         let sampleContacts = [];
         if (sample.length) {
@@ -243,9 +291,12 @@ export function registerSegmentTools(server) {
             return txt(`Error: Failed to parse rules from "${description}"`);
         let parsedRules;
         try {
-            parsedRules = normalizeSegmentRulesToTree(JSON.parse(raw.replace(/```json?\n?|```/g, '').trim()));
+            parsedRules = prepareSegmentRulesForStorage(JSON.parse(raw.replace(/```json?\n?|```/g, '').trim()));
         }
-        catch {
+        catch (parseError) {
+            // #4270: parsed rules that are missing or malformed are an error, never "everyone".
+            if (isSegmentRulesError(parseError))
+                return txt(`Error: Could not use the rules parsed from "${description}". ${parseError.message}`);
             return txt(`Error: Failed to parse rules from "${description}"`);
         }
         const ids = await getSegmentContactIds(parsedRules);

package/package.json

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