@agifyai/leadify-mcp 3.3.0 → 3.5.0

package/dist/server.js

@@ -16,7 +16,7 @@ import { registerPipelineTools } from "./tools/pipeline.js";
 export function createServer() {
     const server = new McpServer({
         name: "leadify",
-        version: "3.3.0",
+        version: "3.5.0",
     });
     registerAuthTools(server);
     registerOrganizationTools(server);

package/dist/tools/lead_groups.js

@@ -160,24 +160,39 @@ export function registerLeadGroupTools(server) {
         "Returns null persona if none is assigned. Use this to check what targeting " +
         "rules apply to a group before generating messages. " +
         "By default, `persona` is SLIM ({id, name, organizationId}) — about ~150 chars " +
-        "instead of 69k — just enough to resolve the org / link the persona to a lead group. " +
-        "Pass `view=full` to get the complete persona (legacy behaviour). " +
-        "Pass `view=outreach` to get the outreach-specific projection.", {
+        "instead of 63k — just enough to resolve the org / link the persona to a lead group. " +
+        "Pass `view=outreach` to get the outreach-specific projection (only when you actually " +
+        "need the outreach trio — prefer the dedicated get_outreach_templates tool for that). " +
+        "SILO: outreach data is its own concern. It does not leak into the default persona payload.", {
         lead_group_id: z.string().describe("Lead group ID."),
         view: z
-            .enum(["slim", "outreach", "full"])
+            .enum(["slim", "outreach"])
             .optional()
             .default("slim")
             .describe("Persona projection. " +
             "'slim' (default) = {id, name, organizationId} — fast, context-friendly. " +
             "'outreach' = projection used by the outreach agent (messaging + targeting). " +
-            "'full' = complete persona payload (legacy 69k-char shape, escape hatch)."),
+            "The legacy 'full' view is gone (SILO enforcement) — use get_persona + " +
+            "get_outreach_templates for a complete picture, scoped per concern."),
     }, async ({ lead_group_id, view }) => {
         try {
             const params = new URLSearchParams();
             if (view)
                 params.set("view", view);
             const data = await getClient().get(`/api/lead-group/${encodeURIComponent(lead_group_id)}/persona`, params);
+            // SILO defense in depth: even if the API returns the full payload for
+            // `view=slim` (the view param is best-effort on the backend), strip the
+            // outreach trio locally so it can never leak through this tool.
+            // Outreach data belongs to the dedicated outreach tools.
+            if (view !== "outreach" && data && typeof data === "object") {
+                const wrapper = data;
+                const persona = wrapper.persona ?? null;
+                if (persona && typeof persona === "object") {
+                    delete persona.outreachTemplates;
+                    delete persona.outreachSignalRouting;
+                    delete persona.outreachFields;
+                }
+            }
             return toolResult(data);
         }
         catch (error) {

package/dist/tools/personas.js

@@ -445,6 +445,31 @@ export function registerPersonaTools(server) {
             .describe("Override SDR identity at persona level ({name, title})."),
     }, async (params) => {
         try {
+            // SILO guard: the upsert escape hatch must NOT be used for outreach
+            // data. Outreach is its own concern with its own granular tools
+            // (update_persona_outreach_template, update_persona_outreach_signal_routing).
+            // Reject early with a clear pointer so the caller knows what to use.
+            if (params.outreach_signal_routing !== undefined ||
+                params.outreach_templates !== undefined ||
+                params.outreach_fields !== undefined) {
+                return toolError("SILO: upsert_persona does NOT accept outreach fields. " +
+                    "Use the dedicated outreach tools instead: " +
+                    "update_persona_outreach_template (add/replace/remove a template), " +
+                    "update_persona_outreach_signal_routing (patch the signal routing block). " +
+                    "For a read of the trio, use get_outreach_templates({ lead_group_id }).", {
+                    rejectedParams: [
+                        ...(params.outreach_signal_routing !== undefined
+                            ? ["outreach_signal_routing"]
+                            : []),
+                        ...(params.outreach_templates !== undefined
+                            ? ["outreach_templates"]
+                            : []),
+                        ...(params.outreach_fields !== undefined
+                            ? ["outreach_fields"]
+                            : []),
+                    ],
+                });
+            }
             const body = { name: params.name };
             if (params.id !== undefined)
                 body.id = params.id;
@@ -503,21 +528,12 @@ export function registerPersonaTools(server) {
                     rules: (params.signal_tier_rules.rules ?? []).map(mapSignalTierRule),
                 };
             }
-            if (params.outreach_signal_routing !== undefined) {
-                const osr = {};
-                if (params.outreach_signal_routing.signal_source_field !== undefined)
-                    osr.signalSourceField =
-                        params.outreach_signal_routing.signal_source_field;
-                if (params.outreach_signal_routing.default_signal !== undefined)
-                    osr.defaultSignal = params.outreach_signal_routing.default_signal;
-                if (params.outreach_signal_routing.signals !== undefined)
-                    osr.signals = params.outreach_signal_routing.signals;
-                body.outreachSignalRouting = osr;
-            }
-            if (params.outreach_templates !== undefined)
-                body.outreachTemplates = params.outreach_templates.map(mapOutreachTemplate);
-            if (params.outreach_fields !== undefined)
-                body.outreachFields = params.outreach_fields;
+            // SILO: outreach_* params are accepted on the schema (so users discover
+            // they exist here) but ALWAYS rejected by the guard at the top of this
+            // handler. Outreach data flows through update_persona_outreach_template
+            // and update_persona_outreach_signal_routing only. The unreachable
+            // mapping code below was removed — TypeScript narrows the params to
+            // `never` after the guard, so the old branches would never run anyway.
             if (params.tone_instructions !== undefined)
                 body.toneInstructions = params.tone_instructions;
             if (params.context !== undefined)
@@ -535,17 +551,91 @@ export function registerPersonaTools(server) {
         }
     });
     // ── get_persona ────────────────────────────────────────────────────────
-    server.tool("get_persona", "Retrieve a single persona by ID, including all lead groups it's assigned to.", {
+    server.tool("get_persona", "Retrieve a single persona by ID, including all lead groups it's assigned to. " +
+        "SILO: the outreach trio (outreachTemplates, outreachSignalRouting, outreachFields) " +
+        "is STRIPPED by default to keep the response focused on the persona's targeting & " +
+        "qualification concerns (~37k chars instead of ~63k). Pass include_outreach=true to " +
+        "get the full payload — but for outreach-only reads prefer get_outreach_templates " +
+        "(a much smaller, dedicated read).", {
         id: z.string().describe("Persona ID."),
-    }, async ({ id }) => {
+        include_outreach: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("If true, keep the outreach trio in the response (outreachTemplates, " +
+            "outreachSignalRouting, outreachFields). Default false (SILO: outreach lives " +
+            "in its own tool)."),
+    }, async ({ id, include_outreach }) => {
         try {
             const data = await getClient().get(`/api/persona/${encodeURIComponent(id)}`);
+            // SILO defense in depth: strip the outreach trio locally unless the
+            // caller explicitly opted in. Outreach data belongs to the dedicated
+            // outreach tools — never mix it with the persona read by default.
+            if (!include_outreach && data && typeof data === "object") {
+                const wrapper = data;
+                if (wrapper && typeof wrapper === "object") {
+                    delete wrapper.outreachTemplates;
+                    delete wrapper.outreachSignalRouting;
+                    delete wrapper.outreachFields;
+                }
+                // The persona can also be wrapped under {persona: {...}} depending
+                // on the API path. Strip there too.
+                const inner = wrapper.persona;
+                if (inner && typeof inner === "object") {
+                    delete inner.outreachTemplates;
+                    delete inner.outreachSignalRouting;
+                    delete inner.outreachFields;
+                }
+            }
             return toolResult(data);
         }
         catch (error) {
             return handlePersonaToolError(error);
         }
     });
+    // ── get_outreach_templates ─────────────────────────────────────────────
+    server.tool("get_outreach_templates", "Read the persona's outreach trio ONLY (outreachSignalRouting, outreachTemplates, " +
+        "outreachFields). SILO: this is the dedicated read for outreach data — never call " +
+        "get_persona with include_outreach=true for routine reads. Returns a small payload " +
+        "regardless of persona size, so it's safe to call mid-session without saturating " +
+        "the LLM context. " +
+        "Resolves the persona from the lead group (lead_group_id → personaId → persona), " +
+        "then projects the trio. If the lead group has no persona, returns an error.", {
+        lead_group_id: z
+            .string()
+            .describe("Lead group ID. The persona is resolved server-side from the group's personaId."),
+    }, async ({ lead_group_id }) => {
+        try {
+            // Step 1: resolve the persona assigned to this lead group (slim view).
+            // We only need the persona's id from here — we re-fetch the full
+            // persona below to grab the outreach trio.
+            const groupPersona = (await getClient().get(`/api/lead-group/${encodeURIComponent(lead_group_id)}/persona`));
+            const personaId = groupPersona?.persona?.id;
+            if (!personaId) {
+                return toolError(`No persona is assigned to lead group "${lead_group_id}". ` +
+                    `Assign one via update_lead_group({ persona_id }) before reading outreach templates.`);
+            }
+            // Step 2: fetch the full persona so we can project the trio.
+            const full = (await getClient().get(`/api/persona/${encodeURIComponent(personaId)}`));
+            // The API may return either a bare persona or {persona: {...}}.
+            const persona = full.persona ?? full;
+            const trio = {
+                outreachSignalRouting: persona.outreachSignalRouting ?? null,
+                outreachTemplates: persona.outreachTemplates ?? [],
+                outreachFields: persona.outreachFields ?? [],
+            };
+            return toolResult({
+                personaId,
+                ...trio,
+                _note: "SILO projection. To edit, use update_persona_outreach_template or " +
+                    "update_persona_outreach_signal_routing. Do NOT use upsert_persona for outreach " +
+                    "fields (SILO rejection).",
+            });
+        }
+        catch (error) {
+            return handlePersonaToolError(error);
+        }
+    });
     // ── list_personas ──────────────────────────────────────────────────────
     server.tool("list_personas", "List all personas accessible to the caller, optionally scoped to a specific organization " +
         "and/or including global personas. Use this to discover persona IDs before calling " +

package/dist/tools/pipeline.js

@@ -15,24 +15,14 @@ export function registerPipelineTools(server) {
         "card_* sequence fields to lead.data). " +
         "The 'force' flag (default false) bypasses the 'already has a message?' guard — " +
         "useful for re-generating on an already-processed lead. " +
-        "`campaign_id` is OPTIONAL: when omitted, the MCP sends no campaign hint to the backend " +
-        "(useful for dry-runs, smoke tests, or skill flows that want to skip the pilot-pinning). " +
-        "When provided, it must be a pilot slug (e.g. 'agify-medtech-fr-v2') that matches a pilot " +
-        "file pair in the Trigger.dev repo (pilots/{campaign_id}.md + .json), paired to the lead's " +
-        "group. The writer hard-fails if the pilot is missing on a real run. " +
-        "The lead's `leadGroupId` is resolved server-side from the lead (one extra " +
+        "The pilot pinning (which Trigger.dev pilot/copywriting ruleset to follow) is resolved " +
+        "server-side from the lead's group — the caller never has to pass a campaign id. " +
+        "The lead's `leadGroupId` is also resolved server-side from the lead (one extra " +
         "`get_lead` call); the caller only needs `lead_id`. " +
         "The response is decorated with a Trigger.dev `traceUrl` deep-link when missing " +
         "(https://cloud.trigger.dev/runs/{runId}), so you can always jump to the trace. " +
         "Waits up to 120s for the remote agent to complete.", {
         lead_id: z.string().describe("ID of the lead to generate a message for."),
-        campaign_id: z
-            .string()
-            .optional()
-            .describe("OPTIONAL pilot slug driving the copywriting (e.g. 'agify-medtech-fr-v2'). NOT a DB " +
-            "campaign id. Must match a pilot file pair in the Trigger.dev repo whose .json is " +
-            "paired to this lead's group. The writer hard-fails if the pilot is missing. " +
-            "Omit to skip the pilot-pinning (e.g. for dry-runs or smoke tests)."),
         dryrun: z
             .boolean()
             .optional()
@@ -46,7 +36,7 @@ export function registerPipelineTools(server) {
             .default(false)
             .describe("true = bypass the 'already has a message?' check so you can re-generate. " +
             "false (default) = normal behaviour: skip leads that already have card_message."),
-    }, async ({ lead_id, campaign_id, dryrun, force }) => {
+    }, async ({ lead_id, dryrun, force }) => {
         try {
             // Resolve leadGroupId server-side. The Trigger.dev task payload requires
             // `leadGroupId`, but the lead_id alone is enough on the MCP side — we
@@ -62,17 +52,16 @@ export function registerPipelineTools(server) {
                     `The lead was not found, or it has no groupId. ` +
                     `Check that the lead exists via get_lead.`);
             }
+            // No campaign_id is sent — pilot pinning is resolved server-side from
+            // the lead's group. Keeping the field out of the MCP surface is a
+            // SILO move: the caller (human or LLM) does not need to know about
+            // pilot slugs, and there's no risk of passing a stale or wrong slug.
             const body = {
                 leadId: lead_id,
                 leadGroupId,
                 dryrun,
                 force,
             };
-            // campaignId is optional: only include it when the caller passed one.
-            // Backend defaults are left to handle the omitted case.
-            if (campaign_id !== undefined) {
-                body.campaignId = campaign_id;
-            }
             const data = (await getClient().post("/api/trigger-outreach", body));
             // Decorate the response with a Trigger.dev run deep-link when the
             // backend didn't ship one. Applies to BOTH success and failure paths

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agifyai/leadify-mcp",
-  "version": "3.3.0",
+  "version": "3.5.0",
   "description": "MCP server for Leadify lead management API",
   "type": "module",
   "main": "dist/index.js",