conduyt-mcp 4.83.0 → 4.85.0

package/README.md

@@ -15,9 +15,10 @@ MCP server for [Conduyt CRM](https://conduyt.app) — expose your CRM as AI-acce
 | Tool | Description |
 |------|-------------|
 | `conduyt_list_contacts` | List and search contacts with filters |
-| `conduyt_get_contact` | Get full contact details with timeline; `hasOutboundSms` = the workspace has ever provably texted the contact |
+| `conduyt_get_contact` | Get full contact details with timeline; `hasOutboundSms` = the workspace has ever provably texted the contact; `hasOutboundEmail` = the same for email |
 | `conduyt_create_contact` | Create a new contact |
 | `conduyt_update_contact` | Update contact fields; optional `expectedRevision` (0..2147483647) refuses a stale save with 409 `contact_changed` (code + current revision in the error) |
+| `conduyt_merge_contacts` | DESTRUCTIVE: merge duplicates into a survivor (`POST /contacts/merge`, owner/admin); the losers are deleted. Two steps: without `confirmImpact` a preview (`counts`, `guardCounts`, `identifierOverflow`, `blockers`); with `confirmImpact: true` plus the preview's `expectedCounts`, `expectedGuardCounts` (and `expectedIdentifiers`) the merge; the confirm is sent only against a preview this server returned in the last 10 minutes (else refused locally); the server pins the record counts, guard counts and identifier plan, not other field edits made after the preview; 75 s timeout. Moved counts 409, 503 `merge_contacts_busy` / `merge_budget_exhausted` + Retry-After surfaced verbatim, never retried |
 | `conduyt_add_contact_collaborator` | Add a team member as a collaborator (`POST /contacts/{id}/collaborators`); optional `expectedRevision`, 409 `contact_changed` |
 | `conduyt_remove_contact_collaborator` | Remove a collaborator (`DELETE /contacts/{id}/collaborators`, body); optional `expectedRevision`, 409 `contact_changed`, 404 when not a collaborator |
 | `conduyt_add_tags` | Add tags to a contact |
@@ -110,7 +111,7 @@ MCP server for [Conduyt CRM](https://conduyt.app) — expose your CRM as AI-acce
 | `conduyt_whatsapp_templates` | The account's WhatsApp templates (Twilio Content) with Meta's approval verdict: sid, text with {{n}} placeholders, variables, approval |
 | `conduyt_send_sms` | Send SMS to a contact (max 1600 chars); transport twilio, project_blue, or whatsapp (an approved template by Content SID, or free-form within the 24-hour window) |
 | `conduyt_send_email` | Send a single email to a contact |
-| `conduyt_check_message` | Grade a draft text or email before sending (`POST /messages/check`): score, grade, verdict, flagged words with safer alternatives (Unicode code-point offsets), checks, a text's segment count. Educates, never blocks; nothing stored or sent. `context` template / first / conversation (pick from `hasOutboundSms`); `provider: "twilio"` (text only; the notices in Twilio's wording; an email with a provider is a 400) and `clean: true` (adds the cleaner's proposal); the answer carries `breakdown`, `notices`, `unicodeCulprits` and `engine.version` (2.1.2); 20 per minute per account; 400 / 403 / 413 / 429 surfaced verbatim, never retried |
+| `conduyt_check_message` | Grade a draft text or email before sending (`POST /messages/check`): score, grade, verdict, flagged words with safer alternatives (Unicode code-point offsets), checks, a text's segment count. Educates, never blocks; nothing stored or sent. `context` template / first / conversation (pick from `hasOutboundSms`); `provider: "twilio"` (text only; the notices in Twilio's wording; an email with a provider is a 400) and `clean: true` (adds the cleaner's proposal); the answer carries `breakdown`, `notices`, `unicodeCulprits`, `englishDictionary` (`loaded` / `not_loaded`: the final grade is only meaningful when it is `loaded`) and `engine.version` (2.2.1); 20 per minute per account; 400 / 403 / 413 / 429 surfaced verbatim, never retried |
 | `conduyt_list_sms_provider_options` | The workspace's active SMS providers, redacted (`GET /sms-providers/template-options`): `{ data: [{ id, name, color }] }`, nothing else. Needs `email_templates.view` or `settings.view` (scopes emails / sms / messages / settings); read-only |
 | `conduyt_get_message_check_minimum_grade` | The admin's Message check minimum grade to send (`settings.messageCheck.minimumGrade`): `enabled`, per-channel `sms` / `email` minimum (letter A-F, score 0-100 or null) and `adminOverride`. Groundwork: stored and read back, not enforced yet. Owner / admin only (anyone else gets `visible: false`); settings scope |
 | `conduyt_update_message_check_minimum_grade` | Change it (`PATCH /settings`): `enabled`, `smsMinimum`, `emailMinimum`, `adminOverride`; sends the whole block with the settings revision it read. `enabled: true` is refused 400 `minimum_grade_not_available_yet`; a non-owner / non-admin gets 403 `forbidden`; 422 for E, fractions, out-of-range scores; all verbatim, never retried |
@@ -387,6 +388,8 @@ object too large for the bound is left out and named in `_omitted`. Every HTTP r
 Conduyt API 503: Contact merge in progress [Retry-After: 5s] {"code":"merge_in_progress"}
 ```
 
+The contact merge route (`POST /contacts/merge`, tool `conduyt_merge_contacts`) answers a retryable 503 with `Retry-After` and the code `merge_contacts_busy` (a contact stayed busy for the whole lock budget) or `merge_budget_exhausted` (the request's time budget ran out), nothing changed. Any tool that reaches it surfaces the refusal in this grammar and never retries it (one API job per key); the caller retries after the stated seconds.
+
 ## Setup
 
 ```bash

package/dist/client.d.ts

@@ -37,6 +37,13 @@ export interface RequestOptions {
  * ALWAYS_WHOLE_KEYS; a nested object that does not fit is left out and named in `_omitted`. JSON is never cut mid-object.
  */
 export declare function renderErrorDetails(body: Record<string, unknown>): string;
+/**
+ * The ONE Retry-After parser. RFC 9110: delay-seconds (digits; a value too long for a number saturates at 2^31-1) or an
+ * HTTP-date in one of the three §5.6.7 forms, parsed explicitly and always as UTC (never the host timezone): IMF-fixdate,
+ * RFC 850 (two-digit year: more than 50 years ahead of `nowMs` means the previous century) and asctime. A date becomes the
+ * remaining seconds, floored at 0. Absent, blank or anything else (ISO timestamps, other zones, "-3") is null.
+ */
+export declare function parseRetryAfter(raw: string | null | undefined, nowMs?: number): number | null;
 export declare class ConduytClient {
     private baseUrl;
     private apiKey;

package/dist/client.js

@@ -104,6 +104,58 @@ export function renderErrorDetails(body) {
         out._omitted = omitted;
     return JSON.stringify(out);
 }
+const RA_MAX_SECONDS = 2_147_483_647; // delay-seconds is unbounded 1*DIGIT: a longer value saturates here instead of becoming null
+const RA_MONTHS = { Jan: 0, Feb: 1, Mar: 2, Apr: 3, May: 4, Jun: 5, Jul: 6, Aug: 7, Sep: 8, Oct: 9, Nov: 10, Dec: 11 };
+const RA_MON = "Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec";
+const RA_IMF = new RegExp(`^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun), (\\d{2}) (${RA_MON}) (\\d{4}) (\\d{2}):(\\d{2}):(\\d{2}) GMT$`);
+const RA_850 = new RegExp(`^(?:Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday), (\\d{2})-(${RA_MON})-(\\d{2}) (\\d{2}):(\\d{2}):(\\d{2}) GMT$`);
+const RA_ASC = new RegExp(`^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun) (${RA_MON}) ([ \\d]\\d) (\\d{2}):(\\d{2}):(\\d{2}) (\\d{4})$`);
+/** A UTC timestamp for the parts, or NaN when any part is out of range (31 Feb, 25:00, ...). */
+function raUtc(y, mo, d, h, mi, s) {
+    if (y < 1900 || h > 23 || mi > 59 || s > 60)
+        return NaN; // RFC 5322: years below 1900 are not dates
+    const t = Date.UTC(y, mo, d, h, mi, Math.min(s, 59));
+    const back = new Date(t);
+    return back.getUTCFullYear() === y && back.getUTCMonth() === mo && back.getUTCDate() === d ? t : NaN;
+}
+/**
+ * The ONE Retry-After parser. RFC 9110: delay-seconds (digits; a value too long for a number saturates at 2^31-1) or an
+ * HTTP-date in one of the three §5.6.7 forms, parsed explicitly and always as UTC (never the host timezone): IMF-fixdate,
+ * RFC 850 (two-digit year: more than 50 years ahead of `nowMs` means the previous century) and asctime. A date becomes the
+ * remaining seconds, floored at 0. Absent, blank or anything else (ISO timestamps, other zones, "-3") is null.
+ */
+export function parseRetryAfter(raw, nowMs = Date.now()) {
+    if (raw === null || raw === undefined)
+        return null;
+    const v = raw.trim();
+    if (v === "")
+        return null;
+    if (/^\d+(\.\d+)?$/.test(v)) {
+        const n = Number(v);
+        return Number.isNaN(n) ? null : Math.min(n, RA_MAX_SECONDS);
+    }
+    let t = NaN;
+    let m;
+    if ((m = RA_IMF.exec(v)))
+        t = raUtc(Number(m[3]), RA_MONTHS[m[2]], Number(m[1]), Number(m[4]), Number(m[5]), Number(m[6]));
+    else if ((m = RA_850.exec(v))) {
+        const century = Math.floor(new Date(nowMs).getUTCFullYear() / 100) * 100;
+        const mo = RA_MONTHS[m[2]], d = Number(m[1]), h = Number(m[4]), mi = Number(m[5]), sec = Number(m[6]);
+        t = raUtc(century + Number(m[3]), mo, d, h, mi, sec);
+        // RFC 9110: a timestamp more than 50 years in the future (the same instant 50 calendar years on, UTC) is the previous century
+        // (the day is clamped to the month's last day: 29 Feb + 50 years is 28 Feb, never 1 Mar)
+        const n = new Date(nowMs);
+        const ly = n.getUTCFullYear() + 50, lm = n.getUTCMonth();
+        const limit = Date.UTC(ly, lm, Math.min(n.getUTCDate(), new Date(Date.UTC(ly, lm + 1, 0)).getUTCDate()), n.getUTCHours(), n.getUTCMinutes(), n.getUTCSeconds(), n.getUTCMilliseconds());
+        if (!Number.isNaN(t) && t > limit)
+            t = raUtc(century - 100 + Number(m[3]), mo, d, h, mi, sec);
+    }
+    else if ((m = RA_ASC.exec(v)))
+        t = raUtc(Number(m[6]), RA_MONTHS[m[1]], Number(m[2].trim()), Number(m[3]), Number(m[4]), Number(m[5]));
+    if (Number.isNaN(t))
+        return null;
+    return Math.max(0, Math.ceil((t - nowMs) / 1000));
+}
 export class ConduytClient {
     baseUrl;
     apiKey;
@@ -240,9 +292,9 @@ export class ConduytClient {
      * until the rest of the text is valid JSON (a server message may itself contain a brace).
      */
     httpError(res, text) {
-        const retryAfterRaw = res.headers.get("retry-after");
-        const retryAfter = retryAfterRaw === null || retryAfterRaw.trim() === "" ? NaN : Number(retryAfterRaw);
-        const retryAfterOk = Number.isFinite(retryAfter) && retryAfter >= 0;
+        const retryAfterParsed = parseRetryAfter(res.headers.get("retry-after"));
+        const retryAfter = retryAfterParsed ?? NaN;
+        const retryAfterOk = retryAfterParsed !== null;
         const raTag = retryAfterOk ? ` [Retry-After: ${retryAfter}s]` : "";
         let msg = res.statusText;
         try {
@@ -275,8 +327,8 @@ export class ConduytClient {
         });
     }
     retryDelayMs(res, attemptIndex) {
-        const retryAfter = Number(res?.headers.get("retry-after"));
-        if (Number.isFinite(retryAfter) && retryAfter >= 0) {
+        const retryAfter = parseRetryAfter(res?.headers.get("retry-after") ?? null);
+        if (retryAfter !== null) {
             return Math.min(retryAfter * 1000, MAX_RETRY_AFTER_MS);
         }
         return Math.min(this.retryBaseMs * 2 ** attemptIndex, MAX_RETRY_AFTER_MS);

package/dist/tools/contacts.d.ts

@@ -4,4 +4,9 @@ import { ConduytClient } from "../client.js";
 export declare const CONTACT_REVISION_MAX = 2147483647;
 /** (#136, app 10-10) the refusals the contact writes answer for a number or a country the API cannot accept: surfaced verbatim, never retried */
 export declare const INVALID_NUMBER_REFUSALS = " An impossible US/Canada number (area code or exchange starting 0 or 1) is refused 400 phone_invalid and nothing is saved; a country is never null or blank (400 country_invalid on an update, 2-letter code, min 1 character). Both are surfaced verbatim and never retried.";
+/** the merge route's own budget is 45 s: the client's 30 s default could abort while the server commits (the call is then ambiguous) */
+export declare const MERGE_TIMEOUT_MS = 75000;
+export declare const LOSER_ORDER_NOTE = "losers are merged in the order given: for each field the survivor lacks, the first loser in this order with a value wins; reorder to change precedence; the dry run's filledFields shows which fields will be filled";
+export declare const MERGE_PREVIEW_MAX = 50;
+export declare const MERGE_PREVIEW_TTL_MS: number;
 export declare function registerContactTools(server: McpServer, client: ConduytClient): void;

package/dist/tools/contacts.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { formatResult } from "../client.js";
+import { formatResult, formatToolError } from "../client.js";
 import { strictInput } from "./strict.js";
 /** The contact save revision pin (catalog bounds: integer 0..2147483647). */
 export const CONTACT_REVISION_MAX = 2147483647;
@@ -22,7 +22,38 @@ function resolveCustomFields(camel, snake) {
 }
 /** (#136, app 10-10) the refusals the contact writes answer for a number or a country the API cannot accept: surfaced verbatim, never retried */
 export const INVALID_NUMBER_REFUSALS = " An impossible US/Canada number (area code or exchange starting 0 or 1) is refused 400 phone_invalid and nothing is saved; a country is never null or blank (400 country_invalid on an update, 2-letter code, min 1 character). Both are surfaced verbatim and never retried.";
+/** the merge route's own budget is 45 s: the client's 30 s default could abort while the server commits (the call is then ambiguous) */
+export const MERGE_TIMEOUT_MS = 75_000;
+export const LOSER_ORDER_NOTE = "losers are merged in the order given: for each field the survivor lacks, the first loser in this order with a value wins; reorder to change precedence; the dry run's filledFields shows which fields will be filled";
+export const MERGE_PREVIEW_MAX = 50;
+export const MERGE_PREVIEW_TTL_MS = 10 * 60_000;
+const stable = (v) => JSON.stringify(v, (_k, x) => (x && typeof x === "object" && !Array.isArray(x) ? Object.fromEntries(Object.entries(x).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))) : x));
+const mergePreviewKey = (primaryId, secondaryIds) => `${primaryId.toLowerCase()}|${secondaryIds.map((x) => x.toLowerCase()).join(",")}`;
+/** bounded, per-server (so per-account: one server holds one API key) record of the previews this tool returned; a confirm is sent only against one */
+function createMergePreviewStore() {
+    const rows = new Map();
+    return {
+        record(key, p) {
+            rows.delete(key);
+            rows.set(key, { ...p, at: Date.now() });
+            while (rows.size > MERGE_PREVIEW_MAX)
+                rows.delete(rows.keys().next().value);
+        },
+        get(key) {
+            const r = rows.get(key);
+            if (!r)
+                return undefined;
+            if (Date.now() - r.at > MERGE_PREVIEW_TTL_MS) {
+                rows.delete(key);
+                return undefined;
+            }
+            return r;
+        },
+        drop(key) { rows.delete(key); },
+    };
+}
 export function registerContactTools(server, client) {
+    const mergePreviews = createMergePreviewStore();
     server.tool("conduyt_list_contacts", "List and search contacts with filtering. Returns paginated results with name, email, phone, tags, source, and assignee. Each row carries `revision` (integer save revision; pass it back as expectedRevision on conduyt_update_contact or the collaborator tools).", {
         search: z.string().optional().describe("Search by name, email, or phone number"),
         tag: z.string().optional().describe("Filter by tag name"),
@@ -53,7 +84,7 @@ export function registerContactTools(server, client) {
         const result = await client.get(`/api/v1/contacts?${params}`);
         return formatResult(result);
     });
-    server.tool("conduyt_get_contact", "Get a single contact with full details — profile, tags, custom fields, timeline, deals, and activity history. Includes `revision` (integer save revision): pass it as expectedRevision on conduyt_update_contact or the collaborator tools so a newer change is never overwritten. Includes `hasOutboundSms` (boolean): true when this workspace has ever PROVABLY texted the contact (a proven send only: not a draft, a queued row or a pre-send failure); use it to pick the `context` for conduyt_check_message (false = 'first', true = 'conversation').", {
+    server.tool("conduyt_get_contact", "Get a single contact with full details — profile, tags, custom fields, timeline, deals, and activity history. Includes `revision` (integer save revision): pass it as expectedRevision on conduyt_update_contact or the collaborator tools so a newer change is never overwritten. Includes `hasOutboundSms` (boolean): true when this workspace has ever PROVABLY texted the contact (a proven send only: not a draft, a queued row or a pre-send failure); use it to pick the `context` for conduyt_check_message (false = 'first', true = 'conversation'). Also includes `hasOutboundEmail` (boolean): the same for email (true when at least one outbound email to the contact was proven sent, so a genuine \"Re:\" reply is a conversation and not flagged); use it to pick the `context` for an email check.", {
         id: z.string().describe("Contact UUID"),
     }, async ({ id }) => {
         const result = await client.get(`/api/v1/contacts/${id}`);
@@ -142,4 +173,43 @@ export function registerContactTools(server, client) {
         const result = await client.post("/api/v1/contacts/verify-line-type", params);
         return formatResult(result);
     });
+    strictInput(server.tool("conduyt_merge_contacts", "DESTRUCTIVE and not reversible through the API: merge duplicate contacts (POST /api/v1/contacts/merge; owner or admin). The survivor (`primaryId`) keeps its id and receives every related record of the losers (`secondaryIds`: tags, deals, messages, activities, tasks, appointments and so on) plus any field it lacks; each loser is then DELETED (soft-deleted, gone from lists and searches, no undelete). A forgotten (anonymized) contact cannot be merged. TWO STEPS, always in this order. STEP 1, preview: call with only primaryId + secondaryIds (confirmImpact absent or false); nothing is changed and the answer is { data: { dryRun: true, primary, secondaries, counts, totalRecords, guardCounts, filledFields, identifierOverflow: { intoPrimary, intoSlots, unstored }, blockers: { outbox } } } (the standard envelope: read the fields inside `data`). Show the user (or decide on) what will move and what will be deleted; `unstored` lists emails or phones with nowhere to go (they would be lost); `blockers.outbox` lists queued sends that must drain first. STEP 2, apply: call again with confirmImpact: true and pass back EXACTLY what the preview answered: expectedCounts = data.counts, expectedGuardCounts = data.guardCounts (both required), and expectedIdentifiers = data.identifierOverflow (recommended: without it the merge refuses only when a value would be dropped). The tool binds the confirm to the preview it returned: a confirm whose values do not equal a preview this server returned for the same survivor and losers in the last 10 minutes is refused locally (\"run the dry run first (no matching preview)\") and nothing is sent. LOSER ORDER: losers are merged in the order given: for each field the survivor lacks, the first loser in this order with a value wins; reorder to change precedence; the dry run's filledFields shows which fields will be filled. WHAT IS PINNED: the server refuses if the record counts, guard counts or identifier plan moved; other field edits made after this preview (a loser's name, company, source, address) are not detected. The server re-counts inside the merge: if the counts, guard counts or identifier plan moved since the preview it answers 409 (for example \"Merge impact changed. Refresh duplicate scan and try again.\"); that text is surfaced verbatim and nothing was merged: preview again and decide again, never reuse the old numbers. Other refusals, surfaced verbatim and never retried: 400 (primaryId missing, secondaryIds empty, primaryId inside secondaryIds, malformed expected values), 404 (a contact not found or not yours), 409 (queued work on the contacts being merged, a drip or sequence send in flight, a deal publication in flight, a refused forgotten contact). 503 with `code` merge_contacts_busy (a contact stayed busy for the whole lock budget: a delivery in flight, another merge or an erasure of the same contact) or merge_budget_exhausted (the time budget ran out): everything was rolled back, nothing changed; the error text carries the code and `Retry-After: <N>s`. This tool NEVER retries (one API job per key): wait at least that many seconds, then run the preview again. The apply answers { data: the merged survivor contact plus identifierOverflow }.", {
+        primaryId: z.string().uuid().describe("The surviving contact UUID: it keeps its id and receives the losers' records"),
+        secondaryIds: z.array(z.string().uuid()).min(1).max(50).describe("The duplicate contact UUIDs to merge into the survivor and DELETE (not the survivor itself). Order matters: " + LOSER_ORDER_NOTE),
+        confirmImpact: z.boolean().optional().describe("Omit or false = STEP 1, the preview (nothing changes). true = STEP 2, apply the merge, with expectedCounts and expectedGuardCounts from the preview."),
+        expectedCounts: z.record(z.number().min(0)).optional().describe("The preview's `counts`, passed back unchanged (required when confirmImpact is true)"),
+        expectedGuardCounts: z.record(z.number().min(0)).optional().describe("The preview's `guardCounts`, passed back unchanged (required when confirmImpact is true)"),
+        expectedIdentifiers: z.object({
+            intoPrimary: z.object({ email: z.string().optional(), phone: z.string().optional() }).optional(),
+            intoSlots: z.record(z.string()),
+            unstored: z.array(z.object({ kind: z.string(), value: z.string() })),
+        }).optional().describe("The preview's `identifierOverflow` ({ intoPrimary, intoSlots, unstored }), passed back unchanged (recommended on apply)"),
+    }, async ({ primaryId, secondaryIds, confirmImpact, expectedCounts, expectedGuardCounts, expectedIdentifiers }) => {
+        const key = mergePreviewKey(primaryId, secondaryIds);
+        if (confirmImpact !== true) {
+            const preview = await client.post("/api/v1/contacts/merge", { primaryId, secondaryIds, dryRun: true }, { timeoutMs: MERGE_TIMEOUT_MS });
+            const d = (preview?.data ?? preview);
+            if (d && typeof d === "object" && d.counts && d.guardCounts) {
+                mergePreviews.record(key, { counts: d.counts, guardCounts: d.guardCounts, identifiers: d.identifierOverflow });
+            }
+            return formatResult(preview);
+        }
+        const seen = mergePreviews.get(key);
+        if (!seen) {
+            return formatToolError("Run the dry run first (no matching preview): this server holds no recent preview of this survivor and these losers (previews are kept for 10 minutes, the last 50). Call again WITHOUT confirmImpact, then confirm with exactly the values it answered. Nothing was sent.");
+        }
+        if (!expectedCounts || !expectedGuardCounts || stable(expectedCounts) !== stable(seen.counts) || stable(expectedGuardCounts) !== stable(seen.guardCounts) || (expectedIdentifiers !== undefined && stable(expectedIdentifiers) !== stable(seen.identifiers))) {
+            return formatToolError("Run the dry run first (no matching preview): expectedCounts, expectedGuardCounts and expectedIdentifiers must equal, unchanged, what the preview of this survivor and these losers answered (data.counts, data.guardCounts, data.identifierOverflow). Nothing was sent.");
+        }
+        const result = await client.post("/api/v1/contacts/merge", {
+            primaryId,
+            secondaryIds,
+            confirmImpact: true,
+            expectedCounts: seen.counts,
+            expectedGuardCounts: seen.guardCounts,
+            ...(seen.identifiers ? { expectedIdentifiers: seen.identifiers } : {}),
+        }, { timeoutMs: MERGE_TIMEOUT_MS });
+        mergePreviews.drop(key);
+        return formatResult(result);
+    }));
 }

package/dist/tools/messaging.js

@@ -19,7 +19,7 @@ export function checkMessageError(err) {
     throw err;
 }
 export function registerMessagingTools(server, client) {
-    strictInput(server.tool("conduyt_check_message", "Grade a DRAFT text or email before it is sent (POST /api/v1/messages/check): the same check the contact composers run as the rep types (the conduyt.com checker engine). Answers { data: { score 0-100, grade A-F, verdict (e.g. 'Good to send', 'Edit these words first', \"Don't send\"), vclass, hits[], subjectHits[] (email), checks[], sms (a text's chars / segments / unicode / perSeg; null for an email), context, notices[] (SMS; informational), breakdown[] (the score's bands, offsets in code points like the hits), unicodeCulprits[] (SMS; the characters that force Unicode, positions in code points), cleaned (only when clean is true), engine { version, updatedAt } } } (engine 2.1.2 today; any further field is additive). Each hit: { start, end, word, level (r likely blocked, a risky, y caution, n heads up), label, cat, why, alts[] (safer wording; some entries are advice rather than a swap), restricted (prohibited in US business texting: no rewording makes it deliverable), rule }. start/end are Unicode CODE-POINT offsets into the submitted text (the body for hits, the subject for subjectHits), end exclusive; an emoji counts as one, so [...text].slice(start, end) in JavaScript or text[start:end] in Python is the word (not a UTF-16 index). The check EDUCATES and never blocks: nothing is stored and nothing is sent, it only suggests; merge tokens such as {{contact.firstName}} are never flagged. context: 'template' (default) grades it as a reusable message, 'first' is the first text to a contact, 'conversation' is a reply in an existing thread (the next engine release skips the opt-out and business-name checks for first / conversation; today every context scores the same). To pick first vs conversation for a real contact read hasOutboundSms on conduyt_get_contact. subject is email only (a subject on a text is refused 400 invalid_body). provider: 'twilio' (text only) words the notices in Twilio's own wording, as the composers show them; an email check with a provider is refused 400 invalid_body, and so is any other provider value (list the workspace's SMS providers with conduyt_list_sms_provider_options; only 'twilio' is a check wording today). clean: true adds `cleaned` { text, subject (email), changes[], skipped[] } or null: the cleaner's PROPOSAL, never stored or applied. Limits: body 10,000 characters, subject 300, request 48 KB; 20 checks per minute per account. Refusals are surfaced verbatim and never retried: 400 invalid_body, 403 forbidden, 413 message_too_long / body_too_large, 429 rate_limited (with Retry-After). Requires " +
+    strictInput(server.tool("conduyt_check_message", "Grade a DRAFT text or email before it is sent (POST /api/v1/messages/check): the same check the contact composers run as the rep types (the conduyt.com checker engine). Answers { data: { score 0-100, grade A-F, verdict (e.g. 'Good to send', 'Edit these words first', \"Don't send\"), vclass, hits[], subjectHits[] (email), checks[], sms (a text's chars / segments / unicode / perSeg; null for an email), context, notices[] (SMS; informational), breakdown[] (the score's bands, offsets in code points like the hits), unicodeCulprits[] (SMS; the characters that force Unicode, positions in code points), cleaned (only when clean is true), englishDictionary ('loaded' | 'not_loaded', engine 2.2.1+), engine { version, updatedAt } } } (engine 2.2.1 today; any further field is additive). The final grade is only meaningful when englishDictionary is 'loaded' (the server embeds the dictionary, so it is): a result with any other value, or without the field, is provisional (the 'no recognizable English words' check did not run): show it as unavailable, never as a grade. Each hit: { start, end, word, level (r likely blocked, a risky, y caution, n heads up), label, cat, why, alts[] (safer wording; some entries are advice rather than a swap), restricted (prohibited in US business texting: no rewording makes it deliverable), rule }. start/end are Unicode CODE-POINT offsets into the submitted text (the body for hits, the subject for subjectHits), end exclusive; an emoji counts as one, so [...text].slice(start, end) in JavaScript or text[start:end] in Python is the word (not a UTF-16 index). The check EDUCATES and never blocks: nothing is stored and nothing is sent, it only suggests; merge tokens such as {{contact.firstName}} are never flagged. context: 'template' (default) grades it as a reusable message, 'first' is the first text to a contact, 'conversation' is a reply in an existing thread (engine 2.2.1: 'conversation' skips the SMS opt-out line and who-is-texting checks and the email fake \"Re:\" / \"Fwd:\" subject check, because a reply in an existing thread legitimately lacks them; 'template' and 'first' run all of them). To pick first vs conversation for a real contact read hasOutboundSms on conduyt_get_contact (hasOutboundEmail for an email). subject is email only (a subject on a text is refused 400 invalid_body). provider: 'twilio' (text only) words the notices in Twilio's own wording, as the composers show them; an email check with a provider is refused 400 invalid_body, and so is any other provider value (list the workspace's SMS providers with conduyt_list_sms_provider_options; only 'twilio' is a check wording today). clean: true adds `cleaned` { text, subject (email), changes[], skipped[] } or null: the cleaner's PROPOSAL, never stored or applied. Limits: body 10,000 characters, subject 300, request 48 KB; 20 checks per minute per account. Refusals are surfaced verbatim and never retried: 400 invalid_body, 403 forbidden, 413 message_too_long / body_too_large, 429 rate_limited (with Retry-After). Requires " +
         CHECK_MESSAGE_REQUIREMENT +
         ".", {
         channel: z.enum(["sms", "email"]).describe("sms = a text, email = an email"),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "conduyt-mcp",
-  "version": "4.83.0",
+  "version": "4.85.0",
   "mcpName": "com.conduyt/mcp",
   "description": "MCP server for Conduyt CRM — expose CRM operations as AI-accessible tools",
   "type": "module",

package/scripts/coverage-matrix.json

@@ -1,11 +1,11 @@
 {
-  "generatedAt": "2026-10-10T17:00:26.027Z",
-  "toolCount": 349,
+  "generatedAt": "2026-10-11T02:07:04.091Z",
+  "toolCount": 350,
   "totalEndpoints": 1077,
   "counts": {
-    "covered": 308,
+    "covered": 309,
     "excluded": 321,
-    "planned": 448,
+    "planned": 447,
     "uncategorized": 0
   },
   "matrix": {
@@ -1562,8 +1562,10 @@
       "reason": "contact subroutes beyond the core CRUD/search tools"
     },
     "POST /api/v1/contacts/merge": {
-      "status": "planned",
-      "reason": "contact subroutes beyond the core CRUD/search tools"
+      "status": "covered",
+      "tools": [
+        "conduyt_merge_contacts"
+      ]
     },
     "GET /api/v1/contacts/sources": {
       "status": "planned",