@agifyai/leadify-mcp 7.1.3 → 8.1.0

package/README.md

@@ -192,6 +192,7 @@ Conséquences pratiques :
 | `delete_campaign_log` | Supprimer une entrée de log de campagne. |
 | `update_campaign_stats` | Mettre à jour les statistiques d'email d'une campagne pour un groupe de leads. |
 | `create_campaign` | Créer une nouvelle campagne rattachée à un groupe de leads (statut DRAFT). |
+| `list_campaigns` | Lister compactement les campagnes d'une organisation explicitement sélectionnée et leur statut courant. |
 | `get_campaign` | Récupérer les détails d'une campagne et ses KPIs temps réel. |
 | `update_campaign_status` | Changer le statut d'une campagne (DRAFT, ACTIVE, PAUSED, COMPLETED). |
 | `export_campaign` | Exporter les statistiques complètes d'une campagne en CSV. |
@@ -200,9 +201,11 @@ Conséquences pratiques :
 | `signal_disable` | Désactiver un signal (faux positif / écarté manuellement). Flip de `state` uniquement. |
 | `signal_delete` | Supprimer définitivement un signal (cas rare : donnée erronée, doublon). |
 | `add_activity` | Journaliser une interaction prospect (LinkedIn, email, call) dans le feed du lead. |
-| `get_data_room` | Récupérer la data room complète : infos société (v2), documents, personas. |
+| `get_context_workspace` | Lire le Context Workspace canonique versionné (`company_brain` ou `gtm_playbook`) d'une organisation explicitement sélectionnée. Retourne le brouillon et la dernière version publiée. |
+| `update_company_brain_sections` | Modifier uniquement les sections indiquées du Company Brain : le MCP relit le brouillon ou la dernière publication, fusionne les sections ciblées, puis sauvegarde avec révision attendue et clé d'idempotence. |
+| `update_gtm_playbook_sections` | Modifier uniquement les sections indiquées du GTM Playbook, avec la même lecture-fusion-révision atomiquement contrôlée. |
+| `publish_context_workspace` | Publier une révision prête du Context Workspace après confirmation explicite (`confirm_publish: true`). Admin de l'organisation requis ; les raisons de non-readiness sont renvoyées par le serveur. |
 | `describe_company_info_schema` | Lire le schéma companyInfo v2 mirroré côté MCP (enums, max-lengths, sections, patch tool par section). À appeler avant la première update. |
-| `update_data_room` | Update WHOLESALE (escape hatch) — remplace l'intégralité de companyInfo. Requis pour le bootstrap initial. Préférer les tools granulaires pour l'incrémental. |
 | `update_company_info_identity` | Patch name + website. Reads + merges + PUTs le full v2 payload. |
 | `update_company_info_snapshot` | Patch du bloc snapshot (pitchOneLiner, marketSpecialty, stage, salesTeamSizeFR, geo, constraints). geo merge shallow. |
 | `update_company_info_constraint` | Add / replace / remove une seule contrainte dans snapshot.constraints[]. label + type enum + note≤150. Cap 10. |
@@ -210,7 +213,6 @@ Conséquences pratiques :
 | `update_company_info_economics` | Patch du bloc economics (pricingModel, ticketRange, salesCycleMonths, triggers, defaultBaseline). |
 | `update_company_info_product_icp` | Add / replace / remove un seul ICP dans productICPs[]. Lookup par productId (must match a products[].name). Cap 5. |
 | `update_company_info_proof_wording` | Patch du bloc proofWording (keyMetrics, miniStories, forbiddenWords). |
-| `add_data_room_document` | Ajouter un document textuel à la data room avec catégorie. |
 | `upsert_persona` | Créer ou mettre à jour un persona (ciblage, messaging, outils actifs). |
 | `get_persona` | Récupérer un persona par son ID. |
 | `get_lead_group_persona` | Récupérer le persona assigné à un groupe de leads. |

package/dist/server.js

@@ -6,17 +6,17 @@ import { registerLogTools } from "./tools/logs.js";
 import { registerCampaignTools } from "./tools/campaigns.js";
 import { registerSignalTools } from "./tools/signals.js";
 import { registerActivityTools } from "./tools/activities.js";
-import { registerDataRoomTools } from "./tools/dataroom.js";
 import { registerDataSourceTools } from "./tools/datasources.js";
 import { registerPersonaTools } from "./tools/personas.js";
 import { registerLeadGroupTools } from "./tools/lead_groups.js";
 import { registerOrganizationTools } from "./tools/organizations.js";
 import { registerPipelineTools } from "./tools/pipeline.js";
 import { registerFineTuningTools } from "./tools/fine_tuning.js";
+import { registerContextWorkspaceTools } from "./tools/context_workspace.js";
 export function createServer() {
     const server = new McpServer({
         name: "leadify",
-        version: "7.1.3",
+        version: "8.1.0",
     });
     registerAuthTools(server);
     registerOrganizationTools(server);
@@ -27,7 +27,7 @@ export function createServer() {
     registerCampaignTools(server);
     registerSignalTools(server);
     registerActivityTools(server);
-    registerDataRoomTools(server);
+    registerContextWorkspaceTools(server);
     registerDataSourceTools(server);
     registerPersonaTools(server);
     registerPipelineTools(server);

package/dist/tools/campaigns.d.ts

@@ -1,2 +1,5 @@
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-export declare function registerCampaignTools(server: McpServer): void;
+import { type LeadifyClient } from "../client.js";
+type CampaignReadClient = Pick<LeadifyClient, "get">;
+export declare function registerCampaignTools(server: McpServer, readClient?: CampaignReadClient): void;
+export {};

package/dist/tools/campaigns.js

@@ -1,7 +1,25 @@
 import { z } from "zod";
 import { getClient } from "../client.js";
 import { toolResult, handleToolError } from "../types.js";
-export function registerCampaignTools(server) {
+const CAMPAIGN_STATUSES = ["DRAFT", "ACTIVE", "PAUSED", "COMPLETED"];
+function assertCampaignBelongsToOrganization(data, organizationId) {
+    if (!data || typeof data !== "object") {
+        throw new Error("Leadify returned an invalid campaign response");
+    }
+    const campaign = data;
+    const leadGroup = campaign.leadGroup;
+    const actualOrganizationId = campaign.organizationId ?? (leadGroup && typeof leadGroup === "object"
+        ? leadGroup.organizationId
+        : undefined);
+    if (actualOrganizationId !== organizationId) {
+        throw new Error("Campaign does not belong to the explicitly selected organization");
+    }
+    if (!CAMPAIGN_STATUSES.includes(campaign.status)) {
+        throw new Error("Leadify returned a campaign with an invalid current status");
+    }
+    return campaign;
+}
+export function registerCampaignTools(server, readClient) {
     // ── update_campaign_stats ──────────────────────────────────────────────
     server.tool("update_campaign_stats", "Update email campaign statistics for a lead group. If the given campaignSlug " +
         "doesn't exist in the group's stats yet, it is created; otherwise provided fields " +
@@ -98,14 +116,63 @@ export function registerCampaignTools(server) {
         }
     });
     // ── get_campaign ───────────────────────────────────────────────────────
-    server.tool("get_campaign", "Retrieve full details for a campaign by its ID, including real-time calculated KPIs " +
-        "(invitations sent, accept rate, messages sent, emails sent, reply rate, golden signals). " +
-        "Use this to check a campaign's current performance.", {
+    server.tool("get_campaign", "Retrieve a campaign chosen from list_campaigns, scoped to the explicitly selected " +
+        "organization. Includes its normalized current status (DRAFT, ACTIVE, PAUSED, or COMPLETED) " +
+        "and real-time KPIs. Never use campaign logs as the source of status.", {
         id: z.string().describe("Campaign ID."),
-    }, async ({ id }) => {
+        organization_id: z.string().describe("Organization selected explicitly via discover_leadify_context or list_organizations."),
+    }, async ({ id, organization_id }) => {
         try {
-            const data = await getClient().get(`/api/campaign/${encodeURIComponent(id)}`);
-            return toolResult(data);
+            const data = await (readClient ?? getClient()).get(`/api/campaign/${encodeURIComponent(id)}`);
+            return toolResult(assertCampaignBelongsToOrganization(data, organization_id));
+        }
+        catch (error) {
+            return handleToolError(error);
+        }
+    });
+    // ── list_campaigns ─────────────────────────────────────────────────────
+    server.tool("list_campaigns", "List campaigns in one explicitly selected organization with compact current status metadata. " +
+        "Use this after discover_leadify_context to identify ACTIVE, DRAFT, PAUSED, or COMPLETED " +
+        "campaigns without reading historical logs.", {
+        organization_id: z.string().describe("Organization selected explicitly via discover_leadify_context or list_organizations."),
+        status: z.enum(CAMPAIGN_STATUSES).optional().describe("Optional current-status filter."),
+        limit: z.number().int().min(1).max(100).optional().default(50).describe("Maximum campaigns returned, bounded to 100."),
+    }, async ({ organization_id, status, limit }) => {
+        try {
+            const data = await (readClient ?? getClient()).get("/api/campaigns", new URLSearchParams({ organizationId: organization_id }));
+            if (!data || typeof data !== "object" || !Array.isArray(data.campaigns)) {
+                throw new Error("Leadify returned an invalid campaign list response");
+            }
+            const response = data;
+            if (response.organizationId !== organization_id) {
+                throw new Error("Leadify returned campaigns from a different organization");
+            }
+            const campaigns = response.campaigns.map((item) => {
+                if (!item || typeof item !== "object")
+                    throw new Error("Leadify returned an invalid campaign");
+                const campaign = item;
+                if (!CAMPAIGN_STATUSES.includes(campaign.status)) {
+                    throw new Error("Leadify returned a campaign with an invalid current status");
+                }
+                return {
+                    id: campaign.id,
+                    name: campaign.name,
+                    status: campaign.status,
+                    channel: campaign.channel,
+                    leadGroupId: campaign.leadGroupId,
+                    createdAt: campaign.createdAt,
+                    updatedAt: campaign.updatedAt,
+                };
+            });
+            const filtered = status ? campaigns.filter((campaign) => campaign.status === status) : campaigns;
+            const statusCounts = Object.fromEntries(CAMPAIGN_STATUSES.map((value) => [value, campaigns.filter((campaign) => campaign.status === value).length]));
+            return toolResult({
+                organizationId: organization_id,
+                campaigns: filtered.slice(0, limit),
+                total: filtered.length,
+                truncated: filtered.length > limit,
+                statusCounts,
+            });
         }
         catch (error) {
             return handleToolError(error);

package/dist/tools/context_workspace.d.ts

@@ -0,0 +1,9 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export interface ContextWorkspaceClient {
+    get(path: string, params?: URLSearchParams): Promise<unknown>;
+    put(path: string, body: unknown): Promise<unknown>;
+    post(path: string, body: unknown): Promise<unknown>;
+}
+/** Bounded projection for agents: the active draft and latest published version only. */
+export declare function projectContextWorkspaceRead(data: unknown): Record<string, unknown>;
+export declare function registerContextWorkspaceTools(server: McpServer, client?: ContextWorkspaceClient): void;

package/dist/tools/context_workspace.js

@@ -0,0 +1,178 @@
+import { z } from "zod";
+import { getClient } from "../client.js";
+import { handleToolError, toolResult } from "../types.js";
+const CONTEXT_KINDS = ["company_brain", "gtm_playbook"];
+const MAX_READINESS_ISSUES = 20;
+const kindSchema = z.enum(CONTEXT_KINDS);
+const sectionSchema = z.object({
+    value: z.unknown(),
+    evidenceIds: z.array(z.string().min(1)).max(100),
+    approved: z.boolean(),
+}).strict();
+const sectionPatchSchema = z.record(z.string().min(1), sectionSchema).refine(sections => Object.keys(sections).length > 0, "At least one section is required");
+function compactReadiness(readiness) {
+    if (!readiness || typeof readiness !== "object" || Array.isArray(readiness))
+        return readiness;
+    const source = readiness;
+    const issues = Array.isArray(source.issues) ? source.issues : [];
+    return {
+        ready: source.ready,
+        evaluated_at: source.evaluatedAt,
+        issue_count: issues.length,
+        issues: issues.slice(0, MAX_READINESS_ISSUES),
+        ...(issues.length > MAX_READINESS_ISSUES
+            ? { issues_truncated: true }
+            : {}),
+    };
+}
+function compactDraft(draft) {
+    if (!draft || typeof draft !== "object" || Array.isArray(draft))
+        return draft;
+    const source = draft;
+    return {
+        revision: source.revision,
+        base_version: source.baseVersion,
+        rollback_from_version: source.rollbackFromVersion,
+        readiness: compactReadiness(source.readiness),
+        content: source.content,
+        created_at: source.createdAt,
+        updated_at: source.updatedAt,
+    };
+}
+function compactPublished(published) {
+    if (!published || typeof published !== "object" || Array.isArray(published))
+        return published;
+    const source = published;
+    return {
+        version: source.version,
+        source_draft_id: source.sourceDraftId,
+        readiness: compactReadiness(source.readiness),
+        content: source.content,
+        published_at: source.publishedAt,
+    };
+}
+/** Bounded projection for agents: the active draft and latest published version only. */
+export function projectContextWorkspaceRead(data) {
+    const source = data && typeof data === "object" && !Array.isArray(data)
+        ? data
+        : {};
+    const published = Array.isArray(source.published) ? source.published : [];
+    return {
+        kind: source.kind,
+        draft: compactDraft(source.draft),
+        latest_published: compactPublished(published[0] ?? null),
+        published_version_count: published.length,
+        ...(published.length > 1 ? { historical_versions_omitted: published.length - 1 } : {}),
+    };
+}
+function record(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+function currentRevision(draft) {
+    const revision = record(draft).revision;
+    return typeof revision === "number" && Number.isInteger(revision) && revision >= 0
+        ? revision
+        : 0;
+}
+function mergeSections(read, sections) {
+    const state = record(read);
+    const draft = record(state.draft);
+    const published = Array.isArray(state.published) ? state.published : [];
+    // Start a new draft from the latest published document, then change only the
+    // named sections. This preserves every untouched section across revisions.
+    const base = Object.keys(draft).length > 0
+        ? record(draft.content)
+        : record(record(published[0]).content);
+    return { ...base, ...sections };
+}
+async function updateSections(client, input) {
+    const read = await client.get(`/api/context-workspace/${input.kind}`, new URLSearchParams({ organizationId: input.organizationId }));
+    const actualRevision = currentRevision(record(read).draft);
+    if (actualRevision !== input.expectedRevision) {
+        throw new Error(`Revision conflict before write: expected ${input.expectedRevision}, current ${actualRevision}. Re-read and retry without overwriting concurrent sections.`);
+    }
+    return client.put("/api/context-workspace/draft", {
+        organizationId: input.organizationId,
+        kind: input.kind,
+        content: mergeSections(read, input.sections),
+        expectedRevision: input.expectedRevision,
+        idempotencyKey: input.idempotencyKey,
+    });
+}
+export function registerContextWorkspaceTools(server, client = getClient()) {
+    server.registerTool("get_context_workspace", {
+        title: "Read canonical versioned Context Workspace",
+        description: "Read the canonical Leadify Context Workspace for one explicitly selected organization and kind. " +
+            "Returns the current draft plus the latest published Company Brain or GTM Playbook, with bounded readiness metadata. " +
+            "Use this for every Leadify workflow. The Data Room is no longer exposed by this MCP.",
+        inputSchema: {
+            organization_id: z.string().trim().min(1).describe("Required organization ID. Always select it explicitly; there is no default tenant."),
+            kind: kindSchema.describe("Canonical workspace document: `company_brain` or `gtm_playbook`."),
+        },
+        annotations: { readOnlyHint: true },
+    }, async ({ organization_id, kind }) => {
+        try {
+            const params = new URLSearchParams({ organizationId: organization_id });
+            const data = await client.get(`/api/context-workspace/${kind}`, params);
+            return toolResult(projectContextWorkspaceRead(data));
+        }
+        catch (error) {
+            return handleToolError(error);
+        }
+    });
+    const sectionTools = [
+        { name: "update_company_brain_sections", kind: "company_brain", title: "Update Company Brain sections" },
+        { name: "update_gtm_playbook_sections", kind: "gtm_playbook", title: "Update GTM Playbook sections" },
+    ];
+    for (const tool of sectionTools) {
+        server.registerTool(tool.name, {
+            title: tool.title,
+            description: "Update only the named canonical sections. The MCP re-reads the current draft (or latest published version), merges only those sections, " +
+                "and saves with optimistic concurrency. Unnamed sections are preserved; a concurrent revision is never overwritten.",
+            inputSchema: {
+                organization_id: z.string().trim().min(1).describe("Required organization ID; section writes require admin access."),
+                sections: sectionPatchSchema.describe("Only sections to change. Each section must include `value`, `evidenceIds`, and `approved`."),
+                expected_revision: z.number().int().nonnegative().describe("Current draft revision, or 0 when no draft exists. Re-read first."),
+                idempotency_key: z.string().trim().min(1).max(200).describe("Stable unique key for this exact section patch."),
+            },
+            annotations: { idempotentHint: true },
+        }, async ({ organization_id, sections, expected_revision, idempotency_key }) => {
+            try {
+                const data = await updateSections(client, { organizationId: organization_id, kind: tool.kind, sections, expectedRevision: expected_revision, idempotencyKey: idempotency_key });
+                return toolResult(compactDraft(data));
+            }
+            catch (error) {
+                return handleToolError(error);
+            }
+        });
+    }
+    server.registerTool("publish_context_workspace", {
+        title: "Publish a ready Context Workspace draft",
+        description: "Publish exactly one ready draft revision of the canonical Context Workspace. This is a consequential action: it requires " +
+            "an organization-admin write key, the precise current draft revision, and `confirm_publish: true`. The server rejects incomplete " +
+            "content with its readiness reasons and rejects stale revisions without overwriting anything.",
+        inputSchema: {
+            organization_id: z.string().trim().min(1).describe("Required organization ID; publication is restricted to an admin key for this tenant."),
+            kind: kindSchema,
+            expected_revision: z.number().int().positive().describe("Exact ready draft revision to publish, obtained from `get_context_workspace`."),
+            idempotency_key: z.string().trim().min(1).max(200).describe("Stable unique key for this exact publication request."),
+            confirm_publish: z.literal(true).describe("Must be explicitly true after the user has confirmed this publication."),
+        },
+        annotations: { destructiveHint: true, idempotentHint: true },
+    }, async ({ organization_id, kind, expected_revision, idempotency_key }) => {
+        try {
+            const data = await client.post("/api/context-workspace/publish", {
+                organizationId: organization_id,
+                kind,
+                expectedRevision: expected_revision,
+                idempotencyKey: idempotency_key,
+            });
+            return toolResult(compactPublished(data));
+        }
+        catch (error) {
+            return handleToolError(error);
+        }
+    });
+}

package/dist/tools/organizations.js

@@ -67,7 +67,7 @@ export function registerOrganizationTools(server) {
     server.tool("discover_leadify_context", "Safe zero-ID entry point for Leadify. With no organization_id, lists accessible organizations " +
         "and never chooses one when several are available. With an explicit organization_id, returns " +
         "a compact list of its lead groups. Use the returned lead_group_id with lead, campaign, persona " +
-        "and data-room tools.", {
+        "and Context Workspace tools.", {
         organization_id: z.string().optional().describe("Organization selected explicitly after discovery. Omit only for the first step."),
         limit: z.number().int().min(1).max(100).optional().default(50).describe("Maximum lead groups returned after selection."),
     }, async ({ organization_id, limit }) => {
@@ -92,7 +92,7 @@ export function registerOrganizationTools(server) {
                 leadGroups: groups.slice(0, limit).map((group) => ({ id: group.id, name: group.name, organizationId: group.organizationId, leadCount: group._count?.leads ?? 0, published: group.published ?? false })),
                 total: groups.length,
                 truncated: groups.length > limit,
-                next: "Choose a lead_group_id, then use get_leads, get_data_room_context, or get_lead_group_persona.",
+                next: "Choose a lead_group_id, then use get_leads, get_context_workspace, or get_lead_group_persona.",
             });
         }
         catch (error) {

package/package.json

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