@agifyai/leadify-mcp 1.4.1

package/README.md

@@ -0,0 +1,117 @@
+# Leadify MCP Server
+
+Serveur MCP (Model Context Protocol) pour l'API Leadify. Expose tous les endpoints REST de Leadify sous forme de tools MCP, utilisables depuis Claude Desktop, Claude Code ou tout client compatible MCP.
+
+## Installation
+
+Le serveur est publié sur npm sous `@agifyai/leadify-mcp`. Aucun clone, aucun build local : `npx` télécharge la dernière version à chaque démarrage.
+
+### Claude Desktop
+
+Ouvrir le fichier de configuration :
+- **macOS** : `~/Library/Application Support/Claude/claude_desktop_config.json`
+- **Windows** : `%APPDATA%\Claude\claude_desktop_config.json`
+
+Ajouter une entrée `"leadify"` dans `"mcpServers"` :
+
+```json
+{
+  "mcpServers": {
+    "leadify": {
+      "command": "npx",
+      "args": ["-y", "@agifyai/leadify-mcp@latest"],
+      "env": {
+        "LEADIFY_API_KEY": "votre-clé-api"
+      }
+    }
+  }
+}
+```
+
+Redémarrer Claude Desktop. Les tools apparaissent (icône marteau).
+
+### Claude Code
+
+```bash
+claude mcp add leadify npx -y @agifyai/leadify-mcp@latest -e LEADIFY_API_KEY=votre-clé-api
+```
+
+### Mise à jour automatique
+
+Le tag `@latest` force `npx` à vérifier la version publiée à chaque lancement de session MCP. Quand un nouveau tool est mergé sur `main` et publié, il est dispo à la session suivante — pas de `git pull`, pas de rebuild.
+
+## Développement
+
+Pour bosser sur le MCP en local :
+
+```bash
+git clone git@github.com:AgifyAI/mcp_leadify.git
+cd mcp_leadify
+npm install
+npm run build
+```
+
+Pointer Claude Code sur la build locale :
+
+```bash
+claude mcp add leadify-dev node /chemin/absolu/vers/mcp_leadify/dist/index.js -e LEADIFY_API_KEY=votre-clé-api
+```
+
+### Publier une nouvelle version
+
+```bash
+npm version patch   # ou minor / major
+git push && git push --tags
+```
+
+GitHub Actions build et publie sur npm automatiquement (workflow `.github/workflows/publish.yml`). Si la version dans `package.json` n'a pas bougé, le workflow skip — pas de doublon.
+
+## Tools disponibles
+
+| Tool | Description |
+|------|-------------|
+| `test_api_key` | Vérifier que la clé API configurée est valide (health check). |
+| `add_leads` | Ajouter un ou plusieurs leads à un groupe. |
+| `get_leads` | Rechercher et lister des leads avec filtres, recherche et pagination. |
+| `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. |
+| `delete_leads` | Supprimer définitivement des leads par leurs IDs. |
+| `update_schema` | Ajouter ou modifier les définitions de champs d'un groupe. |
+| `delete_columns` | Supprimer des colonnes du schéma et des données d'un groupe. |
+| `update_hidden_columns` | Afficher ou masquer des colonnes dans la vue tableau (réversible). |
+| `add_campaign_log` | Enregistrer une entrée de log de campagne pour un lead. |
+| `get_campaign_logs` | Récupérer les logs de campagne avec filtres et pagination. |
+| `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). |
+| `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. |
+| `add_signal` | Ajouter un signal de business intelligence à un lead (INFO, CRITICAL, GOLDEN). |
+| `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é, documents, personas. |
+| `update_data_room` | Mettre à jour les informations société (companyInfo) de la data room. |
+| `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. |
+| `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). |
+| `delete_data_source` | Supprimer définitivement une source de données (admin uniquement). |
+| `get_outreach_settings` | Récupérer la config outreach d'un lead group (positioning, sequence, rules, URLs, case studies). |
+| `update_outreach_settings` | Update full-form (escape hatch) — remplace les blocs JSON entièrement. Préférer les tools granulaires ci-dessous. |
+| `update_outreach_positioning` | Patch partiel du positioning (dream / fear / whyNow individuellement). |
+| `update_outreach_sequence_slot` | Patch d'un seul slot de séquence (connexion, linkedin.one/two/three, email.one/two/three) sans toucher les autres. |
+| `update_outreach_rules` | Patch du bloc rules : forbidden/priority (replace), format.* (deep-merge). |
+| `update_outreach_case_study` | Ajouter / remplacer / supprimer un case study par index, sans re-envoyer la liste. |
+| `update_outreach_urls` | Patch booking_url et/ou website_url uniquement. |
+| `set_outreach_connection_request` | Toggle du flag connectionRequestEnabled (LinkedIn invite vs cold DM). |
+
+## Développement
+
+Mode watch pour le développement :
+
+```bash
+npm run dev
+```

package/dist/client.d.ts

@@ -0,0 +1,11 @@
+export declare class LeadifyClient {
+    private readonly baseUrl;
+    private readonly apiKey;
+    constructor();
+    private request;
+    get(path: string, params?: URLSearchParams): Promise<unknown>;
+    post(path: string, body: unknown): Promise<unknown>;
+    put(path: string, body: unknown): Promise<unknown>;
+    delete(path: string): Promise<unknown>;
+}
+export declare function getClient(): LeadifyClient;

package/dist/client.js

@@ -0,0 +1,62 @@
+import { LeadifyApiError } from "./types.js";
+export class LeadifyClient {
+    baseUrl;
+    apiKey;
+    constructor() {
+        this.baseUrl = "https://api-leadify.agify.fr";
+        const key = process.env.LEADIFY_API_KEY;
+        if (!key) {
+            throw new Error("LEADIFY_API_KEY environment variable is required. " +
+                "Set it before starting the server.");
+        }
+        this.apiKey = key;
+    }
+    async request(method, url, body) {
+        const headers = {
+            Authorization: `Bearer ${this.apiKey}`,
+        };
+        const init = { method, headers };
+        if (body !== undefined && (method === "POST" || method === "PUT")) {
+            headers["Content-Type"] = "application/json";
+            init.body = JSON.stringify(body);
+        }
+        const response = await fetch(url.toString(), init);
+        let data;
+        try {
+            data = await response.json();
+        }
+        catch {
+            data = { raw: await response.text() };
+        }
+        if (!response.ok) {
+            throw new LeadifyApiError(response.status, data);
+        }
+        return data;
+    }
+    async get(path, params) {
+        const url = new URL(path, this.baseUrl);
+        if (params) {
+            params.forEach((value, key) => url.searchParams.set(key, value));
+        }
+        return this.request("GET", url);
+    }
+    async post(path, body) {
+        const url = new URL(path, this.baseUrl);
+        return this.request("POST", url, body);
+    }
+    async put(path, body) {
+        const url = new URL(path, this.baseUrl);
+        return this.request("PUT", url, body);
+    }
+    async delete(path) {
+        const url = new URL(path, this.baseUrl);
+        return this.request("DELETE", url);
+    }
+}
+let _client = null;
+export function getClient() {
+    if (!_client) {
+        _client = new LeadifyClient();
+    }
+    return _client;
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { createServer } from "./server.js";
+async function main() {
+    const server = createServer();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch((error) => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+});

package/dist/server.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function createServer(): McpServer;

package/dist/server.js

@@ -0,0 +1,34 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { registerAuthTools } from "./tools/auth.js";
+import { registerLeadTools } from "./tools/leads.js";
+import { registerSchemaTools } from "./tools/schema.js";
+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 { registerOutreachSettingsTools } from "./tools/outreach_settings.js";
+export function createServer() {
+    const server = new McpServer({
+        name: "leadify",
+        version: "1.4.1",
+    });
+    registerAuthTools(server);
+    registerOrganizationTools(server);
+    registerLeadGroupTools(server);
+    registerLeadTools(server);
+    registerSchemaTools(server);
+    registerLogTools(server);
+    registerCampaignTools(server);
+    registerSignalTools(server);
+    registerActivityTools(server);
+    registerDataRoomTools(server);
+    registerDataSourceTools(server);
+    registerPersonaTools(server);
+    registerOutreachSettingsTools(server);
+    return server;
+}

package/dist/tools/activities.d.ts

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

package/dist/tools/activities.js

@@ -0,0 +1,103 @@
+import { z } from "zod";
+import { getClient } from "../client.js";
+import { toolResult, handleToolError } from "../types.js";
+const ACTIVITY_TYPES = [
+    "LINKEDIN_INVITATION_SENT",
+    "LINKEDIN_INVITATION_ACCEPTED",
+    "LINKEDIN_MESSAGE_SENT",
+    "LINKEDIN_MESSAGE_RECEIVED",
+    "LINKEDIN_INMAIL_SENT",
+    "LINKEDIN_MESSAGE_READ",
+    "EMAIL_SENT",
+    "EMAIL_RECEIVED",
+    "EMAIL_SENT_MANUAL",
+    "PHONE_CALL",
+    "LINKEDIN_MESSAGE",
+    "MESSAGE",
+];
+export function registerActivityTools(server) {
+    // ── add_activity ───────────────────────────────────────────────────────
+    server.tool("add_activity", "Log a prospect interaction as an activity on a lead's live feed — LinkedIn " +
+        "invitations, messages, InMails, calls, emails sent or received. Supply unipile " +
+        "chat/account IDs to thread follow-up messages together. Use this to keep the " +
+        "lead timeline in sync with what happens in external tools.", {
+        lead_id: z.string().describe("ID of the target lead."),
+        type: z.enum(ACTIVITY_TYPES).describe("Type of activity."),
+        title: z
+            .string()
+            .describe("Short title of the activity (e.g. 'Invitation envoyée à Dr. Martin')."),
+        preview: z
+            .string()
+            .optional()
+            .describe("Message preview or detailed description."),
+        date: z
+            .string()
+            .optional()
+            .describe("Activity date in ISO 8601 format. Defaults to now."),
+        sender_name: z.string().optional().describe("Name of the sender."),
+        sender_email: z
+            .string()
+            .email()
+            .optional()
+            .describe("Sender email (for email activities)."),
+        recipient_email: z
+            .string()
+            .email()
+            .optional()
+            .describe("Recipient email (for email activities)."),
+        unipile_chat_id: z
+            .string()
+            .optional()
+            .describe("Unipile conversation ID (to link follow-up messages)."),
+        unipile_account_id: z
+            .string()
+            .optional()
+            .describe("Unipile account ID that performed this action."),
+        provider_profile_url: z
+            .string()
+            .url()
+            .optional()
+            .describe("URL of the prospect's LinkedIn profile."),
+        campaign_id: z
+            .string()
+            .optional()
+            .describe("Campaign ID to attach this activity to."),
+        metadata: z
+            .record(z.unknown())
+            .optional()
+            .describe("Supplementary metadata as a JSON object."),
+    }, async (params) => {
+        try {
+            const body = {
+                leadId: params.lead_id,
+                type: params.type,
+                title: params.title,
+            };
+            if (params.preview !== undefined)
+                body.preview = params.preview;
+            if (params.date !== undefined)
+                body.date = params.date;
+            if (params.sender_name !== undefined)
+                body.senderName = params.sender_name;
+            if (params.sender_email !== undefined)
+                body.senderEmail = params.sender_email;
+            if (params.recipient_email !== undefined)
+                body.recipientEmail = params.recipient_email;
+            if (params.unipile_chat_id !== undefined)
+                body.unipileChatId = params.unipile_chat_id;
+            if (params.unipile_account_id !== undefined)
+                body.unipileAccountId = params.unipile_account_id;
+            if (params.provider_profile_url !== undefined)
+                body.providerProfileUrl = params.provider_profile_url;
+            if (params.campaign_id !== undefined)
+                body.campaignId = params.campaign_id;
+            if (params.metadata !== undefined)
+                body.metadata = params.metadata;
+            const data = await getClient().post("/add-activity", body);
+            return toolResult(data);
+        }
+        catch (error) {
+            return handleToolError(error);
+        }
+    });
+}

package/dist/tools/auth.d.ts

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

package/dist/tools/auth.js

@@ -0,0 +1,16 @@
+import { getClient } from "../client.js";
+import { toolResult, handleToolError } from "../types.js";
+export function registerAuthTools(server) {
+    server.tool("test_api_key", "Verify that the configured Leadify API key is valid and has not been revoked. " +
+        "Returns a success message if the key is active. Use this as a health check " +
+        "before performing other operations, or to diagnose authentication errors " +
+        "(401/403) from other tools.", {}, async () => {
+        try {
+            const data = await getClient().get("/test-api-key");
+            return toolResult(data);
+        }
+        catch (error) {
+            return handleToolError(error);
+        }
+    });
+}

package/dist/tools/campaigns.d.ts

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

package/dist/tools/campaigns.js

@@ -0,0 +1,144 @@
+import { z } from "zod";
+import { getClient } from "../client.js";
+import { toolResult, handleToolError } from "../types.js";
+export function registerCampaignTools(server) {
+    // ── 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 " +
+        "merge with existing values. Use this to push up-to-date counters from an external " +
+        "sender (opens, clicks, replies, etc.). Only fields you pass are updated.", {
+        lead_group_id: z.string().describe("ID of the lead group."),
+        campaign_slug: z
+            .string()
+            .describe("Unique campaign slug identifier (e.g. 'q1-2025')."),
+        lead_total: z.number().int().optional().describe("Total leads in the campaign."),
+        lead_to_launch: z.number().int().optional().describe("Leads to launch."),
+        lead_ready_to_send: z.number().int().optional().describe("Leads ready to send."),
+        lead_in_progress: z.number().int().optional().describe("Leads in progress."),
+        lead_completed: z
+            .number()
+            .int()
+            .optional()
+            .describe("Leads with completed processing."),
+        sent_count: z.number().int().optional().describe("Number of emails sent."),
+        delivered_count: z
+            .number()
+            .int()
+            .optional()
+            .describe("Number of emails delivered."),
+        opened_count: z.number().int().optional().describe("Number of emails opened."),
+        clicked_count: z.number().int().optional().describe("Number of clicks in emails."),
+        replied_count: z.number().int().optional().describe("Number of replies received."),
+        interested_count: z
+            .number()
+            .int()
+            .optional()
+            .describe("Number of leads marked as interested."),
+    }, async (params) => {
+        try {
+            const body = {
+                leadGroupId: params.lead_group_id,
+                campaignSlug: params.campaign_slug,
+            };
+            if (params.lead_total !== undefined)
+                body.leadTotal = params.lead_total;
+            if (params.lead_to_launch !== undefined)
+                body.leadToLaunch = params.lead_to_launch;
+            if (params.lead_ready_to_send !== undefined)
+                body.leadReadyToSend = params.lead_ready_to_send;
+            if (params.lead_in_progress !== undefined)
+                body.leadInProgress = params.lead_in_progress;
+            if (params.lead_completed !== undefined)
+                body.leadCompleted = params.lead_completed;
+            if (params.sent_count !== undefined)
+                body.sentCount = params.sent_count;
+            if (params.delivered_count !== undefined)
+                body.deliveredCount = params.delivered_count;
+            if (params.opened_count !== undefined)
+                body.openedCount = params.opened_count;
+            if (params.clicked_count !== undefined)
+                body.clickedCount = params.clicked_count;
+            if (params.replied_count !== undefined)
+                body.repliedCount = params.replied_count;
+            if (params.interested_count !== undefined)
+                body.interestedCount = params.interested_count;
+            const data = await getClient().post("/update-campaign-stats", body);
+            return toolResult(data);
+        }
+        catch (error) {
+            return handleToolError(error);
+        }
+    });
+    // ── create_campaign ────────────────────────────────────────────────────
+    server.tool("create_campaign", "Create a new campaign linked to an existing lead group. The campaign is initialized " +
+        "in DRAFT status and can be configured with a persona. Returns the new campaign ID. " +
+        "Use update_campaign_status afterwards to move it to ACTIVE when ready.", {
+        name: z.string().describe("Campaign name."),
+        lead_group_id: z.string().describe("ID of the lead group to associate."),
+        description: z.string().optional().describe("Optional description."),
+        persona_id: z
+            .string()
+            .optional()
+            .describe("ID of the persona to assign (optional)."),
+    }, async ({ name, lead_group_id, description, persona_id }) => {
+        try {
+            const body = {
+                name,
+                leadGroupId: lead_group_id,
+            };
+            if (description !== undefined)
+                body.description = description;
+            if (persona_id !== undefined)
+                body.personaId = persona_id;
+            const data = await getClient().post("/api/campaign", body);
+            return toolResult(data);
+        }
+        catch (error) {
+            return handleToolError(error);
+        }
+    });
+    // ── 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.", {
+        id: z.string().describe("Campaign ID."),
+    }, async ({ id }) => {
+        try {
+            const data = await getClient().get(`/api/campaign/${encodeURIComponent(id)}`);
+            return toolResult(data);
+        }
+        catch (error) {
+            return handleToolError(error);
+        }
+    });
+    // ── update_campaign_status ─────────────────────────────────────────────
+    server.tool("update_campaign_status", "Change a campaign's workflow status. Allowed values: DRAFT, ACTIVE, PAUSED, COMPLETED. " +
+        "Moving to ACTIVE starts outbound execution; PAUSED halts it; COMPLETED marks the " +
+        "campaign as finished. Always confirm with the user before calling this tool.", {
+        id: z.string().describe("Campaign ID."),
+        status: z
+            .enum(["DRAFT", "ACTIVE", "PAUSED", "COMPLETED"])
+            .describe("New campaign status."),
+    }, async ({ id, status }) => {
+        try {
+            const data = await getClient().put(`/api/campaign/${encodeURIComponent(id)}/status`, { status });
+            return toolResult(data);
+        }
+        catch (error) {
+            return handleToolError(error);
+        }
+    });
+    // ── export_campaign ────────────────────────────────────────────────────
+    server.tool("export_campaign", "Export a campaign's full statistics and metrics as CSV. Returns the raw CSV text. " +
+        "Use this for external analysis or reporting.", {
+        id: z.string().describe("Campaign ID."),
+    }, async ({ id }) => {
+        try {
+            const data = await getClient().get(`/api/campaign/${encodeURIComponent(id)}/export`);
+            return toolResult(data);
+        }
+        catch (error) {
+            return handleToolError(error);
+        }
+    });
+}

package/dist/tools/dataroom.d.ts

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

package/dist/tools/dataroom.js

@@ -0,0 +1,82 @@
+import { z } from "zod";
+import { getClient } from "../client.js";
+import { toolResult, handleToolError } from "../types.js";
+const DOCUMENT_CATEGORIES = [
+    "PRODUCT_CATALOG",
+    "CONGRESS_LIST",
+    "TARGET_LIST",
+    "COMPANY_INFO",
+    "COMPETITOR_INFO",
+    "CAMPAIGN_BRIEF",
+    "OTHER",
+];
+const ORG_ID_DESC = "Optional Clerk organization ID to target a specific org's data room. " +
+    "Defaults to the caller's own org. Requires admin access for writes.";
+export function registerDataRoomTools(server) {
+    // ── get_data_room ──────────────────────────────────────────────────────
+    server.tool("get_data_room", "Retrieve the organization's full data room: company info, all documents, and every " +
+        "persona defined for the workspace. Use this as the entry point when you need to " +
+        "understand the company's context before writing campaigns or messages.", {
+        organization_id: z.string().optional().describe(ORG_ID_DESC),
+    }, async ({ organization_id }) => {
+        try {
+            const params = organization_id
+                ? new URLSearchParams({ organizationId: organization_id })
+                : undefined;
+            const data = await getClient().get("/api/data-room", params);
+            return toolResult(data);
+        }
+        catch (error) {
+            return handleToolError(error);
+        }
+    });
+    // ── update_data_room ───────────────────────────────────────────────────
+    server.tool("update_data_room", "Update the organization's company info in the data room. Accepts any freeform " +
+        "fields under companyInfo — common ones: name, sector, description, size, website, " +
+        "products, valueProposition, competitors, targetRegions, sender. Only the fields " +
+        "you pass are updated.", {
+        company_info: z
+            .record(z.unknown())
+            .describe("Freeform object of company details. Common fields: name, sector, description, " +
+            "size, website, products, valueProposition, competitors, targetRegions, sender."),
+        organization_id: z.string().optional().describe(ORG_ID_DESC),
+    }, async ({ company_info, organization_id }) => {
+        try {
+            const body = { companyInfo: company_info };
+            if (organization_id)
+                body.organizationId = organization_id;
+            const data = await getClient().put("/api/data-room", body);
+            return toolResult(data);
+        }
+        catch (error) {
+            return handleToolError(error);
+        }
+    });
+    // ── add_data_room_document ─────────────────────────────────────────────
+    server.tool("add_data_room_document", "Add a textual/markdown document to the data room under a predefined category. " +
+        "Use this to store product catalogs, congress lists, target lists, competitor briefs, " +
+        "or campaign briefs that personas and agents can reference.", {
+        title: z.string().describe("Document title."),
+        category: z
+            .enum(DOCUMENT_CATEGORIES)
+            .describe("Document classification."),
+        content: z
+            .string()
+            .optional()
+            .describe("Text or markdown content."),
+        organization_id: z.string().optional().describe(ORG_ID_DESC),
+    }, async ({ title, category, content, organization_id }) => {
+        try {
+            const body = { title, category };
+            if (content !== undefined)
+                body.content = content;
+            if (organization_id)
+                body.organizationId = organization_id;
+            const data = await getClient().post("/api/data-room/document", body);
+            return toolResult(data);
+        }
+        catch (error) {
+            return handleToolError(error);
+        }
+    });
+}

package/dist/tools/datasources.d.ts

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