@vitrion/zentria-mcp 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vitrion
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,131 @@
+# @vitrion/zentria-mcp
+
+[![npm version](https://img.shields.io/npm/v/@vitrion/zentria-mcp.svg)](https://www.npmjs.com/package/@vitrion/zentria-mcp)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+[![Node.js Version](https://img.shields.io/badge/node-%3E%3D20-brightgreen.svg)](https://nodejs.org/)
+[![MCP](https://img.shields.io/badge/MCP-compatible-purple.svg)](https://modelcontextprotocol.io/)
+
+**Zentria MCP server** — full [Zentria public team API](https://app.zentria.nl/api/public/docs) coverage for AI assistants via the [Model Context Protocol](https://modelcontextprotocol.io/).
+
+Published as [`@vitrion/zentria-mcp`](https://www.npmjs.com/package/@vitrion/zentria-mcp).
+
+This server uses the official **public REST API** at `/api/public`. Paths and request bodies match the [OpenAPI docs](https://app.zentria.nl/api/public/docs); they are not invented.
+
+## Features
+
+- **76 tools** covering discovery, to-dos, sales (people, deals, notes, activities, organizations, pipelines, forms, submissions), customers, CRM, Speed to Lead, webhooks, members, settings, and integrations
+- Team-bound **Personal Access Token** auth (`Authorization: Bearer`)
+- Automatic rate-limit retry (429 + `Retry-After`)
+- Stdio transport (Cursor, Claude Desktop, Claude Code)
+- Logs only to stderr (stdio-safe)
+
+## Requirements
+
+- Node.js **>= 20**
+- A Zentria team **API key** (Teams → API keys) with the scopes you need
+
+## Environment variables
+
+| Variable | Required | Description |
+|----------|----------|-------------|
+| `ZENTRIA_API_KEY` | Yes | Team Personal Access Token |
+| `ZENTRIA_BASE_URL` | No | Zentria origin (default `https://app.zentria.nl`). Do not append `/api/public`. |
+
+The client also sends `Accept: application/json` and `User-Agent: @vitrion/zentria-mcp/<version>`. The API key is never written to logs.
+
+## Install
+
+```bash
+npx -y @vitrion/zentria-mcp
+```
+
+### Cursor
+
+Add to your user config (`~/.cursor/mcp.json`) or project config (`.cursor/mcp.json`):
+
+```json
+{
+  "mcpServers": {
+    "zentria": {
+      "command": "npx",
+      "args": ["-y", "@vitrion/zentria-mcp"],
+      "env": {
+        "ZENTRIA_API_KEY": "<team-pat>",
+        "ZENTRIA_BASE_URL": "https://app.zentria.nl"
+      }
+    }
+  }
+}
+```
+
+### Claude Desktop
+
+**macOS:** `~/Library/Application Support/Claude/claude_desktop_config.json`  
+**Windows:** `%APPDATA%\Claude\claude_desktop_config.json`
+
+Use the same `mcpServers` block as Cursor.
+
+### Claude Code
+
+```bash
+claude mcp add zentria -- npx -y @vitrion/zentria-mcp
+```
+
+Set `ZENTRIA_API_KEY` in your shell environment or MCP host config.
+
+## For AI agents
+
+- Call **`get-me`** first to learn the bound team, enabled modules, and token scopes.
+- API keys are bound to **one team** — you cannot switch teams with headers.
+- Use the narrowest scopes when minting keys (`sales:read`, `sales:write`, etc.).
+- Public API docs: [`/api/public/docs`](https://app.zentria.nl/api/public/docs)
+- PAT writes can emit webhooks — avoid update loops on the same event.
+
+## Tool groups
+
+| Group | Examples |
+|-------|----------|
+| **Discovery** | `get-me`, `list-teams`, `get-team`, `list-tenants`, `get-tenant` |
+| **To-dos** | `list-todos`, `create-todo`, `get-todo`, `update-todo`, `delete-todo` |
+| **Sales** | `list-deals`, `create-deal`, `move-deal-stage`, `list-people`, `list-notes`, `list-activities`, `list-pipelines`, `get-default-pipeline` |
+| **Customers** | `list-customers`, `create-customer`, `archive-customer`, `list-customer-contacts` |
+| **CRM** | `list-crm-leads`, `approve-crm-lead`, `reject-crm-lead` |
+| **Speed to Lead** | `list-stl-flows`, `list-stl-sms-templates`, `list-stl-leads` |
+| **Webhooks** | `list-webhooks`, `create-webhook` (secret returned once) |
+| **Members** | `list-members`, `invite-member`, `change-member-role` |
+| **Settings** | `get-settings`, `get-integrations` |
+
+## Development
+
+```bash
+git clone https://github.com/vitrionbv/zentria-mcp.git
+cd zentria-mcp
+npm install
+npm run build
+npm test
+npm run dev
+```
+
+## Inspector
+
+```bash
+npm run build
+npm run inspector
+```
+
+## Publishing
+
+Releases go to [npm](https://www.npmjs.com/package/@vitrion/zentria-mcp) with [trusted publishing](https://docs.npmjs.com/trusted-publishers) (OIDC). Push a `v*` tag to run [`.github/workflows/npm-publish.yml`](.github/workflows/npm-publish.yml). The workflow uses `id-token: write` and does **not** use `NODE_AUTH_TOKEN`.
+
+Configure the trusted publisher on npm: GitHub org `vitrionbv`, repo `zentria-mcp`, workflow `npm-publish.yml`.
+
+## License
+
+MIT — see [LICENSE](LICENSE).
+
+## Links
+
+- [npm: @vitrion/zentria-mcp](https://www.npmjs.com/package/@vitrion/zentria-mcp)
+- [GitHub: vitrionbv/zentria-mcp](https://github.com/vitrionbv/zentria-mcp)
+- [Zentria public API docs](https://app.zentria.nl/api/public/docs)
+- [Zentria n8n community node](https://www.npmjs.com/package/@vitrion/n8n-nodes-zentria)

package/dist/create-server.js

@@ -0,0 +1,43 @@
+import { McpServer } from "@modelcontextprotocol/server";
+import { ZentriaClient } from "./zentria/client.js";
+import { registerCrmTools } from "./tools/crm.js";
+import { registerCustomerContactTools } from "./tools/customer-contacts.js";
+import { registerCustomerTools } from "./tools/customers.js";
+import { registerDiscoveryTools } from "./tools/discovery.js";
+import { registerMemberTools, registerSettingsTools } from "./tools/members.js";
+import { registerSalesFormTools, registerSalesSubmissionTools, } from "./tools/sales-forms.js";
+import { registerSalesActivityTools } from "./tools/sales-activities.js";
+import { registerSalesDealTools } from "./tools/sales-deals.js";
+import { registerSalesNoteTools } from "./tools/sales-notes.js";
+import { registerSalesOrganizationTools } from "./tools/sales-organizations.js";
+import { registerSalesPeopleTools } from "./tools/sales-people.js";
+import { registerSalesPipelineTools } from "./tools/sales-pipelines.js";
+import { registerStlTools } from "./tools/stl.js";
+import { registerTodoTools } from "./tools/todos.js";
+import { registerWebhookTools } from "./tools/webhooks.js";
+import { PACKAGE_NAME, PACKAGE_VERSION } from "./version.js";
+export function createServer() {
+    const server = new McpServer({
+        name: PACKAGE_NAME,
+        version: PACKAGE_VERSION,
+    });
+    const client = new ZentriaClient();
+    registerDiscoveryTools(server, client);
+    registerTodoTools(server, client);
+    registerSalesPeopleTools(server, client);
+    registerSalesDealTools(server, client);
+    registerSalesNoteTools(server, client);
+    registerSalesActivityTools(server, client);
+    registerSalesOrganizationTools(server, client);
+    registerSalesPipelineTools(server, client);
+    registerSalesFormTools(server, client);
+    registerSalesSubmissionTools(server, client);
+    registerCustomerTools(server, client);
+    registerCustomerContactTools(server, client);
+    registerCrmTools(server, client);
+    registerStlTools(server, client);
+    registerWebhookTools(server, client);
+    registerMemberTools(server, client);
+    registerSettingsTools(server, client);
+    return server;
+}

package/dist/index.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+import { serveStdio } from "@modelcontextprotocol/server/stdio";
+import { createServer } from "./create-server.js";
+void serveStdio(createServer);
+console.error("zentria-mcp running on stdio");

package/dist/tools/_shared.js

@@ -0,0 +1,75 @@
+import * as z from "zod/v4";
+import { ZentriaError } from "../zentria/errors.js";
+export function jsonResult(data) {
+    return {
+        content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+        structuredContent: data,
+    };
+}
+export function errorResult(error) {
+    if (error instanceof ZentriaError) {
+        const payload = {
+            status: error.status,
+            message: error.message,
+        };
+        if (error.details !== undefined) {
+            payload.details = error.details;
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify(payload, null, 2) }],
+            isError: true,
+        };
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+        content: [{ type: "text", text: message }],
+        isError: true,
+    };
+}
+export function compactBody(record) {
+    const out = {};
+    for (const [key, value] of Object.entries(record)) {
+        if (value !== undefined) {
+            out[key] = value;
+        }
+    }
+    return Object.keys(out).length > 0 ? out : undefined;
+}
+export function encodePathSegment(value) {
+    return encodeURIComponent(String(value));
+}
+export const paginationSchema = {
+    q: z.string().optional().describe("Search query."),
+    page: z.number().int().min(1).optional().describe("Page number (default 1)."),
+    itemsPerPage: z
+        .number()
+        .int()
+        .min(1)
+        .max(100)
+        .optional()
+        .describe("Items per page (default 25, max 100)."),
+};
+export const idSchema = z.number().int().positive().describe("Resource id.");
+export function registerJsonTool(server, name, options, handler) {
+    server.registerTool(name, options, async (input) => {
+        try {
+            return jsonResult(await handler(input));
+        }
+        catch (error) {
+            return errorResult(error);
+        }
+    });
+}
+export function paginationQuery(input) {
+    const query = {};
+    if (input.q) {
+        query.q = input.q;
+    }
+    if (input.page !== undefined) {
+        query.page = input.page;
+    }
+    if (input.itemsPerPage !== undefined) {
+        query.itemsPerPage = input.itemsPerPage;
+    }
+    return query;
+}

package/dist/tools/crm.js

@@ -0,0 +1,54 @@
+import * as z from "zod/v4";
+import { encodePathSegment, paginationQuery, paginationSchema, registerJsonTool, } from "./_shared.js";
+export function registerCrmTools(server, client) {
+    registerJsonTool(server, "list-crm-leads", {
+        description: "List CRM leads (GET /api/public/crm/leads). Scope: crm:read.",
+        annotations: { readOnlyHint: true },
+        inputSchema: z.object({ ...paginationSchema }),
+    }, async (input) => client.request({
+        path: "/api/public/crm/leads",
+        query: paginationQuery(input),
+    }));
+    registerJsonTool(server, "get-crm-lead", {
+        description: "Fetch a CRM lead (GET /api/public/crm/leads/{id}). Scope: crm:read.",
+        annotations: { readOnlyHint: true },
+        inputSchema: z.object({
+            id: z.number().int().positive().describe("CRM lead id."),
+        }),
+    }, async (input) => client.request({ path: `/api/public/crm/leads/${encodePathSegment(input.id)}` }));
+    registerJsonTool(server, "approve-crm-lead", {
+        description: "Approve a CRM lead (POST /api/public/crm/leads/{id}/approve). Scope: crm:write.",
+        inputSchema: z.object({
+            id: z.number().int().positive().describe("CRM lead id."),
+        }),
+    }, async (input) => client.request({
+        method: "POST",
+        path: `/api/public/crm/leads/${encodePathSegment(input.id)}/approve`,
+        body: {},
+    }));
+    registerJsonTool(server, "reject-crm-lead", {
+        description: "Reject a CRM lead (POST /api/public/crm/leads/{id}/reject). Scope: crm:write.",
+        inputSchema: z.object({
+            id: z.number().int().positive().describe("CRM lead id."),
+        }),
+    }, async (input) => client.request({
+        method: "POST",
+        path: `/api/public/crm/leads/${encodePathSegment(input.id)}/reject`,
+        body: {},
+    }));
+    registerJsonTool(server, "list-crm-submissions", {
+        description: "List CRM lead submissions (GET /api/public/crm/submissions). Scope: crm:read.",
+        annotations: { readOnlyHint: true },
+        inputSchema: z.object({ ...paginationSchema }),
+    }, async (input) => client.request({
+        path: "/api/public/crm/submissions",
+        query: paginationQuery(input),
+    }));
+    registerJsonTool(server, "get-crm-submission", {
+        description: "Fetch a CRM lead submission (GET /api/public/crm/submissions/{id}). Scope: crm:read.",
+        annotations: { readOnlyHint: true },
+        inputSchema: z.object({
+            id: z.number().int().positive().describe("Submission id."),
+        }),
+    }, async (input) => client.request({ path: `/api/public/crm/submissions/${encodePathSegment(input.id)}` }));
+}

package/dist/tools/customer-contacts.js

@@ -0,0 +1,59 @@
+import * as z from "zod/v4";
+import { compactBody, encodePathSegment, paginationQuery, paginationSchema, registerJsonTool, } from "./_shared.js";
+export function registerCustomerContactTools(server, client) {
+    registerJsonTool(server, "list-customer-contacts", {
+        description: "List contacts for a customer (GET /api/public/customers/{customerId}/contacts). Scope: customers:read.",
+        annotations: { readOnlyHint: true },
+        inputSchema: z.object({
+            customerId: z.number().int().positive().describe("Customer id."),
+            ...paginationSchema,
+        }),
+    }, async (input) => {
+        const { customerId, ...pagination } = input;
+        return client.request({
+            path: `/api/public/customers/${encodePathSegment(customerId)}/contacts`,
+            query: paginationQuery(pagination),
+        });
+    });
+    registerJsonTool(server, "create-customer-contact", {
+        description: "Create a contact on a customer (POST /api/public/customers/{customerId}/contacts). Scope: customers:write.",
+        inputSchema: z.object({
+            customerId: z.number().int().positive().describe("Customer id."),
+            name: z.string().min(1),
+            email: z.string().email().optional(),
+            phone: z.string().optional(),
+            isPrimary: z.boolean().optional(),
+        }),
+    }, async (input) => {
+        const { customerId, ...body } = input;
+        return client.request({
+            method: "POST",
+            path: `/api/public/customers/${encodePathSegment(customerId)}/contacts`,
+            body: compactBody(body) ?? {},
+        });
+    });
+    registerJsonTool(server, "get-contact", {
+        description: "Fetch a customer contact (GET /api/public/contacts/{id}). Scope: customers:read.",
+        annotations: { readOnlyHint: true },
+        inputSchema: z.object({
+            id: z.number().int().positive().describe("Contact id."),
+        }),
+    }, async (input) => client.request({ path: `/api/public/contacts/${encodePathSegment(input.id)}` }));
+    registerJsonTool(server, "update-contact", {
+        description: "Update a customer contact (PUT /api/public/contacts/{id}). Scope: customers:write.",
+        inputSchema: z.object({
+            id: z.number().int().positive().describe("Contact id."),
+            name: z.string().optional(),
+            email: z.string().email().nullable().optional(),
+            phone: z.string().nullable().optional(),
+            isPrimary: z.boolean().optional(),
+        }),
+    }, async (input) => {
+        const { id, ...body } = input;
+        return client.request({
+            method: "PUT",
+            path: `/api/public/contacts/${encodePathSegment(id)}`,
+            body: compactBody(body) ?? {},
+        });
+    });
+}

package/dist/tools/customers.js

@@ -0,0 +1,58 @@
+import * as z from "zod/v4";
+import { compactBody, encodePathSegment, paginationQuery, paginationSchema, registerJsonTool, } from "./_shared.js";
+export function registerCustomerTools(server, client) {
+    registerJsonTool(server, "list-customers", {
+        description: "List customers (GET /api/public/customers). Scope: customers:read.",
+        annotations: { readOnlyHint: true },
+        inputSchema: z.object({ ...paginationSchema }),
+    }, async (input) => client.request({
+        path: "/api/public/customers",
+        query: paginationQuery(input),
+    }));
+    registerJsonTool(server, "create-customer", {
+        description: "Create a customer (POST /api/public/customers). Scope: customers:write.",
+        inputSchema: z.object({
+            name: z.string().min(1),
+            email: z.string().email().optional(),
+            phone: z.string().optional(),
+        }),
+    }, async (input) => client.request({
+        method: "POST",
+        path: "/api/public/customers",
+        body: compactBody(input) ?? {},
+    }));
+    registerJsonTool(server, "get-customer", {
+        description: "Fetch a customer (GET /api/public/customers/{id}). Scope: customers:read.",
+        annotations: { readOnlyHint: true },
+        inputSchema: z.object({
+            id: z.number().int().positive().describe("Customer id."),
+        }),
+    }, async (input) => client.request({ path: `/api/public/customers/${encodePathSegment(input.id)}` }));
+    registerJsonTool(server, "update-customer", {
+        description: "Update a customer (PUT /api/public/customers/{id}). Scope: customers:write.",
+        inputSchema: z.object({
+            id: z.number().int().positive().describe("Customer id."),
+            name: z.string().optional(),
+            email: z.string().email().nullable().optional(),
+            phone: z.string().nullable().optional(),
+        }),
+    }, async (input) => {
+        const { id, ...body } = input;
+        return client.request({
+            method: "PUT",
+            path: `/api/public/customers/${encodePathSegment(id)}`,
+            body: compactBody(body) ?? {},
+        });
+    });
+    registerJsonTool(server, "archive-customer", {
+        description: "Archive a customer (PATCH /api/public/customers/{id}/archive). Scope: customers:write.",
+        annotations: { destructiveHint: true },
+        inputSchema: z.object({
+            id: z.number().int().positive().describe("Customer id."),
+        }),
+    }, async (input) => client.request({
+        method: "PATCH",
+        path: `/api/public/customers/${encodePathSegment(input.id)}/archive`,
+        body: {},
+    }));
+}

package/dist/tools/discovery.js

@@ -0,0 +1,39 @@
+import * as z from "zod/v4";
+import { encodePathSegment, paginationQuery, paginationSchema, registerJsonTool } from "./_shared.js";
+export function registerDiscoveryTools(server, client) {
+    registerJsonTool(server, "get-me", {
+        description: "Return the signed-in user, PAT-bound team, enabled modules, and token scopes (GET /api/public/me). Call this first to learn team id and available modules.",
+        annotations: { readOnlyHint: true },
+        inputSchema: z.object({}),
+    }, async () => client.getMe(true));
+    registerJsonTool(server, "list-teams", {
+        description: "List teams visible to this PAT (GET /api/public/teams). A team-bound PAT returns exactly one team.",
+        annotations: { readOnlyHint: true },
+        inputSchema: z.object({ ...paginationSchema }),
+    }, async (input) => client.request({
+        path: "/api/public/teams",
+        query: paginationQuery(input),
+    }));
+    registerJsonTool(server, "get-team", {
+        description: "Fetch a team by id (GET /api/public/teams/{id}).",
+        annotations: { readOnlyHint: true },
+        inputSchema: z.object({
+            id: z.number().int().positive().describe("Team id."),
+        }),
+    }, async (input) => client.request({ path: `/api/public/teams/${encodePathSegment(input.id)}` }));
+    registerJsonTool(server, "list-tenants", {
+        description: "List tenants for this PAT (GET /api/public/tenants).",
+        annotations: { readOnlyHint: true },
+        inputSchema: z.object({ ...paginationSchema }),
+    }, async (input) => client.request({
+        path: "/api/public/tenants",
+        query: paginationQuery(input),
+    }));
+    registerJsonTool(server, "get-tenant", {
+        description: "Fetch a tenant by id (GET /api/public/tenants/{id}).",
+        annotations: { readOnlyHint: true },
+        inputSchema: z.object({
+            id: z.number().int().positive().describe("Tenant id."),
+        }),
+    }, async (input) => client.request({ path: `/api/public/tenants/${encodePathSegment(input.id)}` }));
+}

package/dist/tools/members.js

@@ -0,0 +1,53 @@
+import * as z from "zod/v4";
+import { compactBody, encodePathSegment, paginationQuery, paginationSchema, registerJsonTool, } from "./_shared.js";
+export function registerMemberTools(server, client) {
+    registerJsonTool(server, "list-members", {
+        description: "List team members (GET /api/public/members). Scope: members:read.",
+        annotations: { readOnlyHint: true },
+        inputSchema: z.object({ ...paginationSchema }),
+    }, async (input) => client.request({
+        path: "/api/public/members",
+        query: paginationQuery(input),
+    }));
+    registerJsonTool(server, "get-member", {
+        description: "Fetch a team member (GET /api/public/members/{id}). Scope: members:read.",
+        annotations: { readOnlyHint: true },
+        inputSchema: z.object({
+            id: z.number().int().positive().describe("Member user id."),
+        }),
+    }, async (input) => client.request({ path: `/api/public/members/${encodePathSegment(input.id)}` }));
+    registerJsonTool(server, "invite-member", {
+        description: "Invite a member by email (POST /api/public/members). Scope: members:write.",
+        inputSchema: z.object({
+            email: z.string().email().describe("Invitee email."),
+            role: z.string().min(1).describe("Team role name."),
+        }),
+    }, async (input) => client.request({
+        method: "POST",
+        path: "/api/public/members",
+        body: compactBody(input) ?? {},
+    }));
+    registerJsonTool(server, "change-member-role", {
+        description: "Change a member role (PATCH /api/public/members/{id}/role). Scope: members:write.",
+        inputSchema: z.object({
+            id: z.number().int().positive().describe("Member user id."),
+            role: z.string().min(1).describe("New team role name."),
+        }),
+    }, async (input) => client.request({
+        method: "PATCH",
+        path: `/api/public/members/${encodePathSegment(input.id)}/role`,
+        body: { role: input.role },
+    }));
+}
+export function registerSettingsTools(server, client) {
+    registerJsonTool(server, "get-settings", {
+        description: "Fetch non-secret team settings (GET /api/public/settings). Scope: settings:read.",
+        annotations: { readOnlyHint: true },
+        inputSchema: z.object({}),
+    }, async () => client.request({ path: "/api/public/settings" }));
+    registerJsonTool(server, "get-integrations", {
+        description: "List connected integrations without secrets (GET /api/public/integrations). Scope: integrations:read.",
+        annotations: { readOnlyHint: true },
+        inputSchema: z.object({}),
+    }, async () => client.request({ path: "/api/public/integrations" }));
+}

package/dist/tools/sales-activities.js

@@ -0,0 +1,54 @@
+import * as z from "zod/v4";
+import { compactBody, encodePathSegment, paginationQuery, paginationSchema, registerJsonTool, } from "./_shared.js";
+export function registerSalesActivityTools(server, client) {
+    registerJsonTool(server, "list-activities", {
+        description: "List sales activities (GET /api/public/sales/activities). Scope: sales:read.",
+        annotations: { readOnlyHint: true },
+        inputSchema: z.object({ ...paginationSchema }),
+    }, async (input) => client.request({
+        path: "/api/public/sales/activities",
+        query: paginationQuery(input),
+    }));
+    registerJsonTool(server, "create-activity", {
+        description: "Create a sales activity (POST /api/public/sales/activities). Scope: sales:write.",
+        inputSchema: z.object({
+            type: z.string().min(1).describe("Activity type (call, meeting, task, etc.)."),
+            title: z.string().min(1).describe("Activity title."),
+            dealId: z.number().int().positive().optional(),
+            personId: z.number().int().positive().optional(),
+            dueAt: z.string().optional().describe("ISO datetime."),
+            assigneeUserId: z.number().int().positive().optional(),
+            body: z.string().optional(),
+        }),
+    }, async (input) => client.request({
+        method: "POST",
+        path: "/api/public/sales/activities",
+        body: compactBody(input) ?? {},
+    }));
+    registerJsonTool(server, "get-activity", {
+        description: "Fetch a sales activity (GET /api/public/sales/activities/{id}). Scope: sales:read.",
+        annotations: { readOnlyHint: true },
+        inputSchema: z.object({
+            id: z.number().int().positive().describe("Activity id."),
+        }),
+    }, async (input) => client.request({ path: `/api/public/sales/activities/${encodePathSegment(input.id)}` }));
+    registerJsonTool(server, "update-activity", {
+        description: "Update or complete/cancel a sales activity (PATCH /api/public/sales/activities/{id}). Set status to done or cancelled. Scope: sales:write.",
+        inputSchema: z.object({
+            id: z.number().int().positive().describe("Activity id."),
+            title: z.string().optional(),
+            dueAt: z.string().nullable().optional(),
+            assigneeUserId: z.number().int().positive().nullable().optional(),
+            body: z.string().nullable().optional(),
+            status: z.enum(["open", "done", "cancelled"]).optional(),
+            cancelledReason: z.string().optional(),
+        }),
+    }, async (input) => {
+        const { id, ...body } = input;
+        return client.request({
+            method: "PATCH",
+            path: `/api/public/sales/activities/${encodePathSegment(id)}`,
+            body: compactBody(body) ?? {},
+        });
+    });
+}