@agifyai/leadify-mcp 7.1.3 → 8.0.0

package/README.md

@@ -200,9 +200,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 +212,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.0.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/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.0.0",
   "description": "MCP server for Leadify lead management API",
   "type": "module",
   "main": "dist/index.js",