@agifyai/leadify-mcp 8.6.11 → 8.7.1

package/README.md

@@ -232,6 +232,7 @@ Leadify et ne doit jamais être envoyée par un agent MCP.
 | `create_lead_group` | Créer un groupe et choisir son type canonique optionnel (`GENERIC`, `COMPANY` ou `PERSON`) via `entity_kind`. |
 | `update_lead_group` | Modifier un groupe, y compris son `entity_kind`, avec réconciliation du schéma côté Leadify. |
 | `add_leads` | Ajouter un ou plusieurs leads à un groupe. |
+| `upsert_person_leads_with_employment` | Créer ou réconcilier atomiquement des Person Leads, PERSON, EMPLOYED_BY, projections et historique, sans effet commercial. |
 | `get_leads` | Rechercher et lister des leads avec filtres, recherche et pagination, dont le critère composé `event_filter`. |
 | `get_lead` | Récupérer les détails complets d'un lead par son ID. |
 | `update_lead` | Mettre à jour un ou plusieurs champs d'un lead existant. |
@@ -299,10 +300,10 @@ Leadify et ne doit jamais être envoyée par un agent MCP.
 | `apply_canonical_identity_backfill` | Appliquer exactement un backfill d'identité relu par digest, sans outreach ni activation. |
 | `update_company_brain_sections` | Modifier uniquement les sections globales encore actives (`identity`, `positioning`, `allowedVocabulary`, `prohibitedVocabulary`, `legalConstraints`). Les anciennes sections Offre/Verticale sont filtrées et refusées. |
 | `publish_context_workspace` | Publier une révision prête du Company Brain après confirmation explicite (`confirm_publish: true`). Admin de l'organisation requis ; les raisons de non-readiness sont renvoyées par le serveur. |
-| `list_persona_contracts` / `get_persona_contract` | Lister ou lire les contrats Persona canoniques d’une organisation explicitement sélectionnée. |
-| `create_persona_contract` | Créer un Persona tenant-scoped et lié à une Verticale depuis un contrat canonique v2 complet et strict. Toute clé inconnue est refusée. |
-| `replace_persona_contract` / `patch_persona_contract` | Remplacer ou modifier un contrat canonique v2 avec verrou optimiste. Le document est revalidé intégralement avant l’écriture et aucune colonne Persona historique n’est exposée. |
-| `change_persona_status` | Passer un Persona entre `DRAFT`, `ACTIVE` et `ARCHIVED` avec le même verrou `updated_at`, readiness et protection des références. |
+| `list_persona_contracts` / `get_persona_contract` | Lister ou lire les contrats Persona canoniques v2 d’une organisation explicitement sélectionnée. `intelligence` ne contient que `painPoints`, `icpStrategy` et `cardAnalysisSections` ; `activeTools` n’appartient pas au contrat. |
+| `create_persona_contract` | Créer un Persona tenant-scoped et lié à une Verticale depuis un contrat canonique v2 complet et strict. `tool_pack_id` est requis à la création et reste hors contrat. Toute clé inconnue est refusée. |
+| `replace_persona_contract` / `patch_persona_contract` | Remplacer ou modifier un contrat canonique v2 avec verrou optimiste. `name` / `description` sont acceptés sur replace. `tool_pack_id` est optionnel : s’il est omis, le pack persisté est réutilisé. Une Persona ACTIVE mutée repasse en DRAFT. |
+| `change_persona_status` | Passer un Persona entre `DRAFT`, `ACTIVE` et `ARCHIVED` avec le même verrou `updated_at`, readiness et protection des références. Après un replace/patch, rappeler ce tool vers `ACTIVE` pour que les groupes résolvent à nouveau la Persona. |
 | `list_data_sources` | Lister toutes les sources de données configurées (par pays puis nom). |
 | `create_data_source` | Créer une nouvelle source de données (admin uniquement). |
 | `update_data_source` | Modifier une source de données existante (admin uniquement). |

package/dist/server.js

@@ -19,6 +19,7 @@ import { registerCanonicalBackfillTools } from "./tools/canonical_backfill.js";
 import { registerCommercialTruthTools } from "./tools/commercial_truth.js";
 import { registerEventTools } from "./tools/events.js";
 import { registerContextEntityTools } from "./tools/context_entities.js";
+import { registerPersonEmploymentTools } from "./tools/person_employment.js";
 import { MCP_SERVER_NAME, MCP_VERSION } from "./version.js";
 export function createServer() {
     const server = new McpServer({
@@ -32,6 +33,7 @@ export function createServer() {
     registerLeadTools(server);
     registerRelationshipTools(server);
     registerCanonicalBackfillTools(server);
+    registerPersonEmploymentTools(server);
     registerEventTools(server);
     registerCommercialTruthTools(server);
     registerSchemaTools(server);

package/dist/tools/person_employment.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerPersonEmploymentTools(server: McpServer, client?: import("../client.js").LeadifyClient): void;

package/dist/tools/person_employment.js

@@ -0,0 +1,35 @@
+import { z } from "zod";
+import { getClient } from "../client.js";
+import { handleToolError, toolResult } from "../types.js";
+export function registerPersonEmploymentTools(server, client = getClient()) {
+    server.tool("upsert_person_leads_with_employment", "Atomically create or reconcile Person Leads with their canonical PERSON identity, EMPLOYED_BY relationship, parent_lead/child_leads projections, evidence and append-only card_history. company_lead_id must be exact and already project an Account plus Legal Entity or compatible Establishment. Each batch entry is independently transactional and idempotent. This is the only supported Person write path for sourcing; never fall back to add_leads, canonical backfill, or separate relationship writes. It never qualifies, enriches contact details, sends outreach, creates campaigns, or activates anything.", {
+        people: z.array(z.object({
+            organization_id: z.string().trim().min(1),
+            person_group_id: z.string().trim().min(1),
+            company_lead_id: z.string().trim().min(1),
+            person_lead_id: z.string().trim().min(1).optional(),
+            fields: z.record(z.unknown()),
+            card_history_append: z.string().trim().min(1).max(100_000),
+            evidence_ids: z.array(z.string().trim().min(1)).min(1).max(100),
+            idempotency_key: z.string().trim().min(1).max(220),
+        }).strict()).min(1).max(100),
+    }, async ({ people }) => {
+        try {
+            return toolResult(await client.post("/api/person-employment/upsert", {
+                people: people.map((person) => ({
+                    organizationId: person.organization_id,
+                    personGroupId: person.person_group_id,
+                    companyLeadId: person.company_lead_id,
+                    personLeadId: person.person_lead_id,
+                    fields: person.fields,
+                    cardHistoryAppend: person.card_history_append,
+                    evidenceIds: person.evidence_ids,
+                    idempotencyKey: person.idempotency_key,
+                })),
+            }));
+        }
+        catch (error) {
+            return handleToolError(error);
+        }
+    });
+}

package/dist/tools/personas.js

@@ -5,6 +5,10 @@ import { LeadifyApiError, handleToolError, toolResult } from "../types.js";
  * PRD-1423 hard cutover: Persona business content is represented only by the
  * versioned `personaContract`. These tools deliberately do not expose any
  * historical Persona field or field-specific patch operation.
+ *
+ * The published MCP contract must match the server `personaContractSchema`.
+ * `intelligence.activeTools` is not part of that document; the tool pack lives
+ * on `toolPackId`, outside the contract.
  */
 const tierSchema = z.object({
     rule: z.string(),
@@ -38,7 +42,6 @@ const commonContractSchema = z.object({
         enableSignals: z.boolean(),
     }).strict(),
     intelligence: z.object({
-        activeTools: z.array(z.string()),
         painPoints: z.unknown().nullable(),
         icpStrategy: z.unknown().nullable(),
         cardAnalysisSections: z.unknown().nullable(),
@@ -67,7 +70,24 @@ const personExtensionSchema = z.object({
 const contractSchema = z.discriminatedUnion("kind", [
     commonContractSchema.extend({ kind: z.literal("COMPANY"), person: z.null() }).strict(),
     commonContractSchema.extend({ kind: z.literal("PERSON"), person: personExtensionSchema }).strict(),
-]).describe("Complete strict Persona contract, schemaVersion 2.");
+]);
+function withoutOutOfContractKeys(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return value;
+    const contract = structuredClone(value);
+    const intelligence = contract.intelligence;
+    if (intelligence && typeof intelligence === "object" && !Array.isArray(intelligence)) {
+        delete intelligence.activeTools;
+    }
+    return contract;
+}
+function parsePersistedContract(value) {
+    return contractSchema.parse(withoutOutOfContractKeys(value));
+}
+function parseWrittenContract(value) {
+    return parsePersistedContract(value);
+}
+const contractInputSchema = z.preprocess(withoutOutOfContractKeys, contractSchema).describe("Complete strict Persona contract, schemaVersion 2. intelligence.activeTools is not a contract field and is stripped if sent.");
 const tenantScope = {
     organization_id: z
         .string()
@@ -82,15 +102,23 @@ const optimisticScope = {
         .datetime({ offset: true })
         .describe("Exact updatedAt obtained from a preceding read."),
 };
+function requireToolPackId(persona, override) {
+    const toolPackId = override?.trim() || persona.toolPackId?.trim();
+    if (!toolPackId)
+        throw new Error("PERSONA_TOOL_PACK_REQUIRED");
+    return toolPackId;
+}
 function canonicalPersona(persona) {
     if (!persona.personaContract || typeof persona.personaContract !== "object") {
         throw new Error("PERSONA_CONTRACT_REQUIRED: run the audited Persona migration before using this MCP.");
     }
-    const contract = contractSchema.parse(persona.personaContract);
+    const contract = parsePersistedContract(persona.personaContract);
     return {
         id: persona.id,
         name: persona.name,
+        description: persona.description ?? null,
         verticalId: persona.verticalId,
+        toolPackId: persona.toolPackId ?? null,
         updatedAt: persona.updatedAt,
         revision: persona.revision ?? 0,
         status: persona.status,
@@ -139,11 +167,13 @@ async function replaceContract(input) {
     }
     return input.client.post("/api/persona", {
         id: persona.id,
-        name: persona.name,
+        name: input.name ?? persona.name,
         organizationId: input.organizationId,
         verticalId: persona.verticalId,
         expectedUpdatedAt: input.expectedUpdatedAt,
-        personaContract: input.contract,
+        toolPackId: requireToolPackId(persona, input.toolPackId),
+        ...(input.description !== undefined ? { description: input.description } : {}),
+        personaContract: parseWrittenContract(input.contract),
     });
 }
 export function registerPersonaTools(server, injectedClient) {
@@ -168,33 +198,54 @@ export function registerPersonaTools(server, injectedClient) {
             return handleToolError(error);
         }
     });
-    server.tool("create_persona_contract", "Create a Persona from one complete canonical contract. Historical Persona fields are not accepted.", {
+    server.tool("create_persona_contract", "Create a Persona from one complete canonical contract v2. intelligence.activeTools is not part of the contract. tool_pack_id is required on create and lives outside the contract.", {
         ...tenantScope,
         vertical_id: z.string().trim().min(1),
         name: z.string().trim().min(1),
         description: z.string().optional(),
-        contract: contractSchema,
-    }, async ({ organization_id, vertical_id, name, description, contract }) => {
+        tool_pack_id: z
+            .string()
+            .trim()
+            .min(1)
+            .describe("Tenant-scoped tool pack. Not part of personaContract."),
+        contract: contractInputSchema,
+    }, async ({ organization_id, vertical_id, name, description, tool_pack_id, contract }) => {
         try {
             return toolResult(await client.post("/api/persona", {
                 organizationId: organization_id,
                 verticalId: vertical_id,
                 name,
+                toolPackId: tool_pack_id,
                 ...(description !== undefined ? { description } : {}),
-                personaContract: contract,
+                personaContract: parseWrittenContract(contract),
             }));
         }
         catch (error) {
             return handleToolError(error);
         }
     });
-    server.tool("replace_persona_contract", "Replace the complete canonical contract using optimistic concurrency.", { ...optimisticScope, id: z.string().min(1), contract: contractSchema }, async ({ organization_id, id, expected_updated_at, contract }) => {
+    server.tool("replace_persona_contract", "Replace the complete canonical contract using optimistic concurrency. Omitting tool_pack_id reuses the persisted pack. Mutating an ACTIVE Persona returns it to DRAFT; call change_persona_status to reactivate.", {
+        ...optimisticScope,
+        id: z.string().min(1),
+        name: z.string().trim().min(1).optional(),
+        description: z.string().optional(),
+        tool_pack_id: z
+            .string()
+            .trim()
+            .min(1)
+            .optional()
+            .describe("Optional pack change. When omitted, the persisted toolPackId is reused."),
+        contract: contractInputSchema,
+    }, async ({ organization_id, id, expected_updated_at, name, description, tool_pack_id, contract }) => {
         try {
             return toolResult(await replaceContract({
                 organizationId: organization_id,
                 id,
                 expectedUpdatedAt: expected_updated_at,
-                contract,
+                name,
+                description,
+                toolPackId: tool_pack_id,
+                contract: parseWrittenContract(contract),
                 client,
             }));
         }
@@ -202,12 +253,18 @@ export function registerPersonaTools(server, injectedClient) {
             return handleToolError(error);
         }
     });
-    server.tool("patch_persona_contract", "Change one canonical contract path using optimistic concurrency. Removing a field is forbidden because the contract is strict and complete.", {
+    server.tool("patch_persona_contract", "Change one canonical contract path using optimistic concurrency. Removing a field is forbidden because the contract is strict and complete. intelligence.activeTools is not a contract path. Mutating an ACTIVE Persona returns it to DRAFT; call change_persona_status to reactivate.", {
         ...optimisticScope,
         id: z.string().min(1),
         path: z.string().trim().min(1),
         value: z.unknown(),
-    }, async ({ organization_id, id, expected_updated_at, path, value }) => {
+        tool_pack_id: z
+            .string()
+            .trim()
+            .min(1)
+            .optional()
+            .describe("Optional pack change. When omitted, the persisted toolPackId is reused."),
+    }, async ({ organization_id, id, expected_updated_at, path, value, tool_pack_id }) => {
         try {
             const persona = await fetchPersona(id, organization_id, client);
             const contract = canonicalPersona(persona).contract;
@@ -215,6 +272,7 @@ export function registerPersonaTools(server, injectedClient) {
                 organizationId: organization_id,
                 id,
                 expectedUpdatedAt: expected_updated_at,
+                toolPackId: tool_pack_id,
                 contract: contractSchema.parse(setContractPath(contract, path, value)),
                 client,
             }));
@@ -223,7 +281,7 @@ export function registerPersonaTools(server, injectedClient) {
             return handleToolError(error);
         }
     });
-    server.tool("change_persona_status", "Change only Persona lifecycle status; it never changes business contract content.", { ...optimisticScope, id: z.string().min(1), status: z.enum(["DRAFT", "ACTIVE", "ARCHIVED"]) }, async ({ organization_id, id, expected_updated_at, status }) => {
+    server.tool("change_persona_status", "Change only Persona lifecycle status; it never changes business contract content. After replace/patch, an ACTIVE Persona is typically returned to DRAFT and must be set back to ACTIVE for groups to resolve it again.", { ...optimisticScope, id: z.string().min(1), status: z.enum(["DRAFT", "ACTIVE", "ARCHIVED"]) }, async ({ organization_id, id, expected_updated_at, status }) => {
         try {
             return toolResult(await client.post(`/api/persona/${encodeURIComponent(id)}/status?organizationId=${encodeURIComponent(organization_id)}`, { expectedUpdatedAt: expected_updated_at, status }));
         }

package/package.json

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