conduyt-mcp 4.103.0 → 4.105.0

package/README.md

@@ -2,7 +2,7 @@
 
 MCP server for [Conduyt CRM](https://conduyt.app) — expose your CRM as AI-accessible tools. Covers the core CRM surface (contacts, deals, pipelines, custom fields, automations, messaging, and more); use `conduyt_api_catalog` to discover the full set of 600+ REST endpoints.
 
-## 373 Tools
+## 378 Tools
 
 ### Discovery
 | Tool | Description |
@@ -73,6 +73,7 @@ MCP server for [Conduyt CRM](https://conduyt.app) — expose your CRM as AI-acce
 | Tool | Description |
 |------|-------------|
 | `conduyt_list_activities` | List recent CRM activities |
+| `conduyt_export_activities_csv` | Export the activities a filter matches (`type`, `search`, `contactId`, `dealId`, `fromDate`, `toDate`) to a CSV FILE at `out_path` (`GET /activity/export.csv`; absolute path; an existing file is refused unless `overwrite: true`). Writes the file on the machine running this server and returns only `{ path, rows, bytes, parts }`, never the CSV. The server streams the export in parts of up to 55 s; the tool follows each part's `continue` trailer by itself (same filters plus the cursor, no repeated header) and commits the file only on `complete`. All or nothing: 413 `export_too_large` (more than 100,000 rows; error, code and hint surfaced), a `too_large` trailer (50 MB), 400 `cursor_invalid`, or a part still cut after 3 attempts leaves no file; a 503 `export_count_timeout` is retried once after its Retry-After. For small reads use `conduyt_list_activities` |
 | `conduyt_create_activity` | Log a call, meeting, or note |
 
 ### AI
@@ -151,7 +152,8 @@ No tool carries call audio. Fetch it with `GET {API base}/api/v1/dialer/call/{id
 | Tool | Description |
 |------|-------------|
 | `conduyt_list_companies` | List and search companies (`count_mode: none` skips the total: `meta.total` null, `meta.has_more` exact) |
-| `conduyt_get_company` | Get company with contacts and deals |
+| `conduyt_get_company` | Get company with the first page of its contacts (100), deals (50) and child accounts (25), each with its total and next cursor |
+| `conduyt_list_company_related` | The next pages of a company's contacts, deals or child accounts (`GET /companies/{id}/related`; `company_id`, `kind` contacts / deals / children, `cursor`): answers `{ kind, rows, total, nextCursor }`; pass `nextCursor` back until it is null. A caller who may not read deals gets an empty deals list with total 0 |
 | `conduyt_create_company` | Create a new company record |
 | `conduyt_update_company` | Update company details |
 
@@ -244,6 +246,9 @@ The Mailchimp OAuth connect and callback are browser-only: connect Mailchimp in
 | `conduyt_list_chat_channels` | `GET /chat/channels`: your channels; also CREATES your memberships in the auto channels the first time |
 | `conduyt_get_chat_unread` | `GET /chat/unread`: per channel `{ channelId, unread, soundUnread, newestSeq, latestSeq }`; may list an auto channel you have not opened yet (no membership row) |
 | `conduyt_list_chat_messages` | List a channel's messages, newest first; every message carries `seq` (commit-ordered position in the channel); does not move the read marker; on a 403 "Not a member of this channel" it calls `GET /chat/channels` once and retries once |
+| `conduyt_send_chat_message` | Send a message through the canonical audited Team Chat writer; agent keys receive the six-turn human-handoff guard |
+| `conduyt_reply_chat_message` | Reply to a top-level message in its thread through the same audited writer; an agent passes `idempotencyKey` (`reply:<source message id>`) so a retried turn returns the first reply (200, `idempotentReplay: true`) instead of posting twice |
+| `conduyt_react_chat_message` | React to a Team Chat message as the authenticated user/agent |
 | `conduyt_mark_chat_read` | Acknowledge read up to one message (`readUpTo` = message UUID; the marker only moves forward, an older or foreign message is a no-op; same one-retry membership bootstrap) |
 | `conduyt_get_chat_realtime_token` | `GET /realtime/token`: a signed Ably token request for the realtime pipe (`channelIds` up to 10, sent as repeated `channel=`); `{ enabled: false, reason }` when the account switch is off; returns `accountId` / `userId` |
 | `conduyt_get_chat_notifications` | `GET /chat/channels/{id}/notifications`: your level `{ level, isDefault, notify, updatedAt, membershipId, membershipSince, membershipSeq }` |
@@ -252,7 +257,7 @@ The Mailchimp OAuth connect and callback are browser-only: connect Mailchimp in
 
 `conduyt_list_chat_messages` also takes `afterSeq` (messages committed after that seq; once, a whole number, never with `cursor`) and every message carries `version` (a counter bumped on each update). `conduyt_get_chat_unread` rows carry `mentions`, `notify`, `updatedAt`, `membershipId` (null = no membership), `membershipSince`, `membershipSeq`, and the response `teamChatRealtime` and `membershipSeqHigh`; `conduyt_list_chat_channels` rows carry `mentionCount` and the same membership fields.
 
-The rest of team chat (sending, edit/delete, reactions, pins, claim/handoff, typing, presence, uploads) is not wrapped yet. `GET /chat/messages/{messageId}/location` is a UI deep-link helper and deliberately not wrapped. `GET /cron/team-chat-digest` is a CRON_SECRET-gated job and not key-callable.
+The remaining Team Chat mutations (edit/delete, pins, claim/handoff and typing/presence writes) are not wrapped yet; sends, thread replies, reactions and direct uploads are wrapped. `GET /chat/messages/{messageId}/location` is a UI deep-link helper and deliberately not wrapped. `GET /cron/team-chat-digest` is a CRON_SECRET-gated job and not key-callable.
 
 #### What the API publishes (realtime events, not tools)
 
@@ -399,7 +404,7 @@ A refused call (HTTP 4xx/5xx) fails the tool with this text, stable across tools
 Conduyt API <status>: <server message>[ [Retry-After: <N>s]][ <details>]
 ```
 
-`[Retry-After: Ns]` appears only when the server sent the header (shown, never acted on: a mutation is never retried; the one exception is the finalize POST of the upload convenience tools `conduyt_upload_local_file` and `conduyt_upload_chat_attachment`: on a 409 `upload_in_progress` only, at most 4 total attempts, the Retry-After is honoured (capped at 10 s, 5 s when absent or unreadable); finalize is idempotent on the server for the same upload id, so a repeat cannot double-finalize).
+`[Retry-After: Ns]` appears only when the server sent the header (shown, never acted on: a mutation is never retried; the one exception is the finalize POST of the upload convenience tools `conduyt_upload_local_file` and `conduyt_upload_chat_attachment`: on a 409 `upload_in_progress` only, at most 4 total attempts, the Retry-After is honoured (capped at 10 s, 5 s when absent or unreadable); finalize is idempotent on the server for the same upload id, so a repeat cannot double-finalize; the other is `conduyt_export_activities_csv`, a read: on a 503 `export_count_timeout` it waits the Retry-After (capped at 30 s, 5 s when absent) and asks once more).
 `<details>` appears only when the body had more than `error`: it is ONE JSON object and the FINAL token. To extract it, try
 each `{` from the left until the rest of the text parses as JSON (a server message may itself contain a brace). The object
 carries scalars first (`code`, revision), then nested objects whole; `HealthFixRefusal.row` is always whole, any other nested

package/dist/client.d.ts

@@ -76,6 +76,15 @@ export declare class ConduytClient {
     request(method: string, path: string, body?: unknown, opts?: RequestOptions): Promise<unknown>;
     requestText(method: string, path: string, body?: unknown, opts?: RequestOptions): Promise<string>;
     get(path: string, opts?: RequestOptions): Promise<unknown>;
+    /**
+     * (#624) A GET whose 2xx body is handed back UNREAD as a stream (the activity CSV export, text/csv): sent once, never retried, never
+     * buffered and never parsed as JSON. The deadline covers the body as well. A non-2xx is read and thrown through the shared error
+     * grammar (status, code, Retry-After and the details object intact).
+     */
+    getStream(path: string, opts?: {
+        timeoutMs?: number;
+        accept?: string;
+    }): Promise<Response>;
     /** Multipart upload (call-flow greeting audio): same auth, timeouts and
      *  response bounds as JSON calls; the body is a FormData the caller built. */
     postMultipart(path: string, form: FormData, opts?: RequestOptions): Promise<unknown>;

package/dist/client.js

@@ -391,6 +391,33 @@ export class ConduytClient {
     get(path, opts) {
         return this.request("GET", path, undefined, opts);
     }
+    /**
+     * (#624) A GET whose 2xx body is handed back UNREAD as a stream (the activity CSV export, text/csv): sent once, never retried, never
+     * buffered and never parsed as JSON. The deadline covers the body as well. A non-2xx is read and thrown through the shared error
+     * grammar (status, code, Retry-After and the details object intact).
+     */
+    async getStream(path, opts = {}) {
+        const timeoutMs = opts.timeoutMs ?? this.timeoutMs;
+        let res;
+        try {
+            res = await fetch(`${this.baseUrl}${path}`, {
+                method: "GET",
+                headers: { Authorization: `Bearer ${this.apiKey}`, Accept: opts.accept ?? "text/csv" },
+                signal: AbortSignal.timeout(timeoutMs),
+            });
+        }
+        catch (err) {
+            throw new ConduytApiError({
+                message: isAbort(err) ? `Conduyt API timeout: no response within ${timeoutMs}ms for GET ${path}` : `Conduyt API network error for GET ${path}: ${err?.message ?? String(err)}`,
+                code: isAbort(err) ? "timeout" : "network",
+                retryable: true,
+                cause: err,
+            });
+        }
+        if (!res.ok)
+            throw this.httpError(res, (await res.text().catch(() => "")).slice(0, this.maxResponseBytes));
+        return res;
+    }
     /** Multipart upload (call-flow greeting audio): same auth, timeouts and
      *  response bounds as JSON calls; the body is a FormData the caller built. */
     async postMultipart(path, form, opts = {}) {

package/dist/tool-annotations.js

@@ -55,6 +55,7 @@ export const TOOL_ANNOTATIONS = {
     conduyt_reorder_stages: update("Reorder Stages"),
     conduyt_delete_stage: destroy("Delete Stage"),
     conduyt_list_activities: ro("List Activities"),
+    conduyt_export_activities_csv: row("Export Activities to CSV File", false, true, false), // writes a LOCAL file, so not read-only; destructive because overwrite: true replaces an existing regular file (MCP: destructiveHint false is additive-only); a repeat writes a new export, so not idempotent
     conduyt_create_activity: create("Create Activity"),
     conduyt_ai_insights: create("Query AI Insights"),
     conduyt_list_automations: ro("List Automations"),
@@ -112,6 +113,7 @@ export const TOOL_ANNOTATIONS = {
     conduyt_update_call_recording_settings: update("Update Call Recording Settings"),
     conduyt_list_companies: ro("List Companies"),
     conduyt_get_company: ro("Get Company"),
+    conduyt_list_company_related: ro("List Company Related Records"),
     conduyt_create_company: create("Create Company"),
     conduyt_update_company: row("Update Company", false, false, false), // every identical PATCH creates a new company_updated Activity and re-dispatches the update fan-out (companies/[id]/route.ts:362-375)
     conduyt_list_tags: ro("List Tags"),
@@ -174,6 +176,9 @@ export const TOOL_ANNOTATIONS = {
     conduyt_list_chat_channels: update("List Chat Channels"),
     conduyt_get_chat_unread: ro("Get Chat Unread Counts"),
     conduyt_list_chat_messages: update("List Chat Messages"),
+    conduyt_send_chat_message: create("Send Chat Message"),
+    conduyt_reply_chat_message: create("Reply to Chat Message"),
+    conduyt_react_chat_message: update("React to Chat Message"),
     conduyt_mark_chat_read: row("Mark Chat Read", false, false, false), // every call re-announces the read receipt to the reader's other tabs and devices, even when the marker did not move (chat/channels/[id]/messages/route.ts:126)
     conduyt_get_chat_realtime_token: ro("Get Chat Realtime Token"),
     conduyt_get_chat_notifications: update("Get Chat Notifications"),

package/dist/tools/activities.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
-import { formatResult } from "../client.js";
+import { formatResult, formatToolError } from "../client.js";
+import { EXPORT_PART_TIMEOUT_MS, runActivityExport } from "./activity-export.js";
 export function registerActivityTools(server, client) {
     server.tool("conduyt_list_activities", "List recent activities across the CRM — calls, emails, notes, meetings, deal changes, and system events.", {
         type: z.string().optional().describe("Filter by activity type (e.g. 'call', 'email', 'note', 'meeting', 'deal_stage_changed')"),
@@ -25,6 +26,47 @@ export function registerActivityTools(server, client) {
         const result = await client.get(`/api/v1/activities?${params}`);
         return formatResult(result);
     });
+    server.tool("conduyt_export_activities_csv", "Export the activities a filter matches to a CSV FILE on this machine (GET /activity/export.csv, permission activities.view): the same rows and columns as the Activity page's Export (id, type, description, user, contact, deal, timestamp), newest first. Writes `out_path` (an absolute path; an existing file is refused unless `overwrite: true`) and returns only { path, rows, bytes, parts }: the CSV content is NEVER returned to you (it can be 50 MB). For a small read use conduyt_list_activities instead. The server streams the export in parts of up to 55 s; this tool follows each part's continue trailer by itself (same filters plus the cursor) and commits the file only when the last part says complete: a refusal, a too_large trailer or a part that stays cut leaves no file. Limits: 100,000 rows and 50 MB (413 export_too_large before any row, with maxRows, maxBytes, matchedAtLeast and a hint to narrow the date range or filters). A 503 export_count_timeout is retried once after its Retry-After.", {
+        out_path: z.string().describe("Absolute path of the CSV file to write on the machine running this MCP server (a relative path is refused)"),
+        overwrite: z.boolean().optional().describe("Replace an existing file at out_path (default false: an existing file is refused before any request)"),
+        type: z.string().optional().describe("Filter by activity type, as conduyt_list_activities"),
+        search: z.string().optional().describe("Search activity titles/descriptions"),
+        contactId: z.string().uuid().optional().describe("Only this contact's activities (UUID)"),
+        dealId: z.string().uuid().optional().describe("Only this deal's activities (UUID)"),
+        fromDate: z.string().optional().describe("From this day, YYYY-MM-DD in the account's time zone"),
+        toDate: z.string().optional().describe("Up to this day, YYYY-MM-DD in the account's time zone"),
+    }, async ({ out_path, overwrite, type, search, contactId, dealId, fromDate, toDate }) => {
+        const params = new URLSearchParams();
+        if (type)
+            params.set("type", type);
+        if (search)
+            params.set("search", search);
+        if (contactId)
+            params.set("contact_id", contactId);
+        if (dealId)
+            params.set("deal_id", dealId);
+        if (fromDate)
+            params.set("fromDate", fromDate);
+        if (toDate)
+            params.set("toDate", toDate);
+        try {
+            const result = await runActivityExport({
+                outPath: out_path,
+                overwrite: overwrite === true,
+                // every part carries the SAME filters; a resumed part adds the cursor of the previous part's continue trailer
+                fetchPart: (cursor) => {
+                    const qs = new URLSearchParams(params);
+                    if (cursor !== null)
+                        qs.set("cursor", cursor);
+                    return client.getStream(`/api/v1/activity/export.csv?${qs}`, { timeoutMs: EXPORT_PART_TIMEOUT_MS, accept: "text/csv" });
+                },
+            });
+            return formatResult(result);
+        }
+        catch (err) {
+            return formatToolError(err instanceof Error ? err.message : String(err));
+        }
+    });
     server.tool("conduyt_create_activity", "Log a new activity — a call, meeting, note, or custom event. Can be linked to a contact.", {
         type: z.string().describe("Activity type: 'call', 'email', 'note', 'meeting', or custom"),
         title: z.string().describe("Activity title/summary"),

package/dist/tools/activity-export.d.ts

@@ -0,0 +1,62 @@
+import { type FileHandle } from "node:fs/promises";
+/**
+ * (#624) The part loop of GET /api/v1/activity/export.csv, the same protocol as the app's browser download (lib/activity-export.ts
+ * downloadActivityExport): request a part, stream it, read its LAST CSV record as the trailer, and on `continue` request the next part with the
+ * SAME filters plus the cursor (a resumed part has no header). All or nothing: the rows go to a temporary file next to out_path, which is
+ * committed only on `complete`; any refusal, a too_large trailer, a part that is still cut after 3 attempts, or more bytes than the cap
+ * leaves no file. The CSV is never returned and never held whole in memory: only the part's final CSV RECORD is held back until the part ends
+ * (it can span physical lines inside quotes; it is bounded by the remaining 50 MB budget plus the trailer room).
+ */
+export declare const EXPORT_TRAILER: RegExp;
+/** the app's ceiling (lib/activity-export.ts ACTIVITY_EXPORT_MAX_BYTES; 100,000 rows are counted by the server) */
+export declare const ACTIVITY_EXPORT_MAX_BYTES: number;
+/** the app's part bound (downloadActivityExport maxParts) */
+export declare const EXPORT_MAX_PARTS = 200;
+/** one part runs at most 55 s on the server (maxDuration 60); the client allows 120 s for the whole part, body included */
+export declare const EXPORT_PART_TIMEOUT_MS = 120000;
+/** a 200 part without a trailer (a cut stream) is requested again from the same cursor: this many attempts in all */
+export declare const EXPORT_CUT_ATTEMPTS = 3;
+/** the one 503 export_count_timeout retry waits its Retry-After (5 s from the route), capped here; `sleep` is module state for tests */
+export declare const exportRetry: {
+    maxWaitMs: number;
+    defaultWaitMs: number;
+    sleep: (ms: number) => Promise<unknown>;
+};
+export type ActivityExportResult = {
+    path: string;
+    rows: number;
+    bytes: number;
+    parts: number;
+};
+type PartEnd = {
+    kind: "complete" | "continue" | "too_large";
+    value: string;
+    end: number;
+} | {
+    cut: true;
+} | {
+    over: true;
+};
+/** (r4) a write that made no progress: the export fails (never retried as a cut part, never published) */
+export declare class ExportWriteError extends Error {
+}
+/**
+ * Write all `length` bytes of `buf` from `offset` at file position `position`: FileHandle.write may write fewer bytes than asked (a short
+ * write), so loop with offset and position advanced by each bytesWritten; an iteration that writes 0 bytes throws ExportWriteError naming
+ * the part and the position. Answers the bytes written (always `length` when it returns).
+ */
+export declare function writeAll(fh: Pick<FileHandle, "write">, buf: Buffer, offset: number, length: number, position: number, part: number): Promise<number>;
+/**
+ * Stream one part's body into the file from `start`; the trailer is never written. RFC 4180 quote state is tracked across chunks (a double
+ * quote toggles in-quote, so the escaped "" inside a quoted field toggles twice), and only a newline OUTSIDE quotes ends a record. The
+ * trailer must be the whole LAST record, starting at a record boundary and ending the body outside quotes: a marker line inside a quoted
+ * multi-line description is field text, never a trailer, and a body that ends inside quotes was cut.
+ */
+export declare function readPart(res: Response, fh: Pick<FileHandle, "write">, start: number, room: number, part?: number): Promise<PartEnd>;
+export declare function runActivityExport(o: {
+    outPath: string;
+    overwrite: boolean;
+    fetchPart: (cursor: string | null) => Promise<Response>;
+    maxBytes?: number;
+}): Promise<ActivityExportResult>;
+export {};

package/dist/tools/activity-export.js

@@ -0,0 +1,216 @@
+import { randomBytes } from "node:crypto";
+import { linkSync, lstatSync, renameSync, unlinkSync } from "node:fs";
+import { open } from "node:fs/promises";
+import { basename, dirname, isAbsolute, join } from "node:path";
+import { ConduytApiError } from "../client.js";
+/**
+ * (#624) The part loop of GET /api/v1/activity/export.csv, the same protocol as the app's browser download (lib/activity-export.ts
+ * downloadActivityExport): request a part, stream it, read its LAST CSV record as the trailer, and on `continue` request the next part with the
+ * SAME filters plus the cursor (a resumed part has no header). All or nothing: the rows go to a temporary file next to out_path, which is
+ * committed only on `complete`; any refusal, a too_large trailer, a part that is still cut after 3 attempts, or more bytes than the cap
+ * leaves no file. The CSV is never returned and never held whole in memory: only the part's final CSV RECORD is held back until the part ends
+ * (it can span physical lines inside quotes; it is bounded by the remaining 50 MB budget plus the trailer room).
+ */
+export const EXPORT_TRAILER = /^#conduyt-export,(complete|continue|too_large),([^,"\r\n]*)$/;
+/** the app's ceiling (lib/activity-export.ts ACTIVITY_EXPORT_MAX_BYTES; 100,000 rows are counted by the server) */
+export const ACTIVITY_EXPORT_MAX_BYTES = 50 * 1024 * 1024;
+/** a trailer line's bytes at most (the app's TRAILER_ROOM; a signed cursor is ~200 bytes) */
+const TRAILER_ROOM = 1024;
+/** the app's part bound (downloadActivityExport maxParts) */
+export const EXPORT_MAX_PARTS = 200;
+/** one part runs at most 55 s on the server (maxDuration 60); the client allows 120 s for the whole part, body included */
+export const EXPORT_PART_TIMEOUT_MS = 120_000;
+/** a 200 part without a trailer (a cut stream) is requested again from the same cursor: this many attempts in all */
+export const EXPORT_CUT_ATTEMPTS = 3;
+/** the one 503 export_count_timeout retry waits its Retry-After (5 s from the route), capped here; `sleep` is module state for tests */
+export const exportRetry = { maxWaitMs: 30_000, defaultWaitMs: 5_000, sleep: (ms) => new Promise((r) => setTimeout(r, ms)) };
+const LIMIT_COPY = "An export holds up to 100,000 activities and 50 MB: narrow the date range or filters. No file was made.";
+/** (r4) a write that made no progress: the export fails (never retried as a cut part, never published) */
+export class ExportWriteError extends Error {
+}
+/**
+ * Write all `length` bytes of `buf` from `offset` at file position `position`: FileHandle.write may write fewer bytes than asked (a short
+ * write), so loop with offset and position advanced by each bytesWritten; an iteration that writes 0 bytes throws ExportWriteError naming
+ * the part and the position. Answers the bytes written (always `length` when it returns).
+ */
+export async function writeAll(fh, buf, offset, length, position, part) {
+    let done = 0;
+    while (done < length) {
+        const { bytesWritten } = await fh.write(buf, offset + done, length - done, position + done);
+        if (!bytesWritten)
+            throw new ExportWriteError(`Writing part ${part} of the export made no progress at byte ${position + done} of the temporary file (${length - done} bytes left). No file was made.`);
+        done += bytesWritten;
+    }
+    return done;
+}
+/**
+ * Stream one part's body into the file from `start`; the trailer is never written. RFC 4180 quote state is tracked across chunks (a double
+ * quote toggles in-quote, so the escaped "" inside a quoted field toggles twice), and only a newline OUTSIDE quotes ends a record. The
+ * trailer must be the whole LAST record, starting at a record boundary and ending the body outside quotes: a marker line inside a quoted
+ * multi-line description is field text, never a trailer, and a body that ends inside quotes was cut.
+ */
+export async function readPart(res, fh, start, room, part = 1) {
+    let pos = start;
+    let read = 0;
+    let pending = Buffer.alloc(0);
+    let inQuote = false;
+    // record starts inside `pending`: lastB = after the latest unquoted newline, prevB = the one before (0 = pending starts a record)
+    let lastB = 0, prevB = 0;
+    const take = async (chunk) => {
+        const from = pending.length;
+        pending = from ? Buffer.concat([pending, chunk]) : chunk;
+        for (let i = from; i < pending.length; i++) {
+            const c = pending[i];
+            if (c === 0x22)
+                inQuote = !inQuote;
+            else if (c === 0x0a && !inQuote) {
+                prevB = lastB;
+                lastB = i + 1;
+            }
+        }
+        // hold back the last record: the complete one when the bytes end on a boundary, else the unfinished tail
+        const k = lastB === pending.length ? prevB : lastB;
+        if (k > 0) {
+            pos += await writeAll(fh, pending, 0, k, pos, part);
+            pending = pending.subarray(k);
+            lastB -= k;
+            prevB = Math.max(0, prevB - k);
+        }
+    };
+    const reader = res.body?.getReader();
+    try {
+        if (!reader) {
+            const all = Buffer.from(await res.text(), "utf8");
+            if (all.length > room)
+                return { over: true };
+            await take(all);
+        }
+        else {
+            for (;;) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                read += value.byteLength;
+                if (read > room) {
+                    await reader.cancel().catch(() => { });
+                    return { over: true };
+                }
+                await take(Buffer.from(value));
+            }
+        }
+    }
+    catch (err) {
+        if (err instanceof ExportWriteError)
+            throw err;
+        return { cut: true };
+    }
+    if (inQuote)
+        return { cut: true };
+    // `pending` is now exactly the last record (one final newline at most): it is the trailer or the part was cut
+    const text = pending.toString("utf8");
+    const m = EXPORT_TRAILER.exec(text.endsWith("\n") ? text.slice(0, -1) : text);
+    if (!m)
+        return { cut: true };
+    return { kind: m[1], value: m[2], end: pos };
+}
+const isCountTimeout = (err) => err instanceof ConduytApiError && err.status === 503 && /export_count_timeout/.test(err.message);
+export async function runActivityExport(o) {
+    const maxBytes = o.maxBytes ?? ACTIVITY_EXPORT_MAX_BYTES;
+    if (!isAbsolute(o.outPath))
+        throw new Error(`out_path must be an absolute path (got "${o.outPath}"). Nothing was requested.`);
+    // lstat (never follows a link): a symlink (dangling or not) or a directory is refused whatever overwrite says; a regular file needs overwrite
+    let existing = null;
+    try {
+        existing = lstatSync(o.outPath);
+    }
+    catch (err) {
+        if (err.code !== "ENOENT")
+            throw err;
+    }
+    if (existing?.isSymbolicLink())
+        throw new Error(`${o.outPath} is a symbolic link; out_path must name a regular file. Nothing was requested.`);
+    if (existing?.isDirectory())
+        throw new Error(`${o.outPath} is a directory; out_path must name a file. Nothing was requested.`);
+    if (existing && !existing.isFile())
+        throw new Error(`${o.outPath} is not a regular file. Nothing was requested.`);
+    if (existing && !o.overwrite)
+        throw new Error(`${o.outPath} already exists; pass overwrite: true to replace it, or another out_path. Nothing was requested.`);
+    const tmp = join(dirname(o.outPath), `.${basename(o.outPath)}.${process.pid}.${randomBytes(6).toString("hex")}.part`);
+    let fh = await open(tmp, "wx", 0o600);
+    const drop = async () => {
+        if (fh) {
+            await fh.close().catch(() => { });
+            fh = null;
+        }
+        try {
+            unlinkSync(tmp);
+        }
+        catch { /* already gone */ }
+    };
+    try {
+        let cursor = null;
+        // every cursor this export has requested: any repeat (A, A or A, B, A) would append pages already written
+        const seenCursors = new Set();
+        let committed = 0;
+        let countRetried = false;
+        for (let part = 1; part <= EXPORT_MAX_PARTS; part++) {
+            let end = null;
+            for (let attempt = 1;;) {
+                let res;
+                try {
+                    res = await o.fetchPart(cursor);
+                }
+                catch (err) {
+                    // 503 export_count_timeout: wait its Retry-After and ask ONCE more; every other refusal ends the export as the server said it
+                    if (isCountTimeout(err) && !countRetried) {
+                        countRetried = true;
+                        const ra = err.retryAfterSeconds;
+                        await exportRetry.sleep(Math.min(ra !== null ? ra * 1000 : exportRetry.defaultWaitMs, exportRetry.maxWaitMs));
+                        continue;
+                    }
+                    throw err;
+                }
+                end = await readPart(res, fh, committed, maxBytes - committed + TRAILER_ROOM, part);
+                if (!("cut" in end))
+                    break;
+                // a cut part: drop what it wrote and ask for THAT part again from the same cursor
+                await fh.truncate(committed);
+                if (++attempt > EXPORT_CUT_ATTEMPTS)
+                    throw new Error(`Part ${part} of the export was cut before its end ${EXPORT_CUT_ATTEMPTS} times (no trailer). No file was made.`);
+            }
+            if ("over" in end || ("kind" in end && end.end > maxBytes))
+                throw new Error(`The export passed 50 MB. ${LIMIT_COPY}`);
+            if (end.kind === "too_large")
+                throw new Error(`The export reached its ${end.value === "bytes" ? "50 MB" : "100,000 row"} limit while streaming (too_large,${end.value}). ${LIMIT_COPY}`);
+            if (end.kind === "complete") {
+                await fh.sync();
+                await fh.close();
+                fh = null;
+                if (o.overwrite)
+                    renameSync(tmp, o.outPath);
+                else {
+                    try {
+                        linkSync(tmp, o.outPath);
+                    }
+                    catch (err) {
+                        if (err.code === "EEXIST")
+                            throw new Error(`${o.outPath} appeared while the export ran; it was not replaced. No file was made.`);
+                        throw err;
+                    }
+                    unlinkSync(tmp);
+                }
+                return { path: o.outPath, rows: Number(end.value), bytes: end.end, parts: part };
+            }
+            if (!end.value || seenCursors.has(end.value))
+                throw new Error("The export did not advance (the continue trailer repeated a cursor already used). No file was made.");
+            seenCursors.add(end.value);
+            cursor = end.value;
+            committed = end.end;
+        }
+        throw new Error(`The export did not complete within ${EXPORT_MAX_PARTS} parts. No file was made.`);
+    }
+    catch (err) {
+        await drop();
+        throw err;
+    }
+}

package/dist/tools/chat.js

@@ -43,7 +43,7 @@ async function withMembershipBootstrap(client, read) {
 }
 /** Team chat read side (app 10-09, live sha 3869c79ba): the unread vector, messages carrying `seq`, and the read acknowledgement. */
 export function registerChatTools(server, client) {
-    strictInput(server.tool("conduyt_list_chat_channels", "List the team chat channels the API key's user belongs to (GET /api/v1/chat/channels): id, name, kind, members, last message, counts. Each row also carries the Team Chat 2.0 fields mentionCount (unread @mentions of you), notify (your stored notification level: all, mentions, mute, or null = the kind's default), updatedAt (when notify last changed, null = never), membershipId (your member row; changes after a removal and re-add), membershipSince (when this membership began) and membershipSeq (strictly increasing incarnation number). SIDE EFFECT: it also creates the caller's memberships in the account's AUTO channels (needs-a-hand, new-leads, wins) the first time, so a user who never opened Team Chat can read them. conduyt_list_chat_messages and conduyt_mark_chat_read already do this once for you when a channel listed by conduyt_get_chat_unread answers 403 'Not a member of this channel'; call this tool directly to discover channel ids.", {}, async () => {
+    strictInput(server.tool("conduyt_list_chat_channels", "List the team chat channels the API key's user belongs to (GET /api/v1/chat/channels): id, name, kind, members, last message, counts. Each row also carries the Team Chat 2.0 fields mentionCount (unread @mentions of you), notify (your stored notification level: all, mentions, mute, or null = the kind's default), updatedAt (when notify last changed, null = never), membershipId (your member row; changes after a removal and re-add), membershipSince (when this membership began) and membershipSeq (strictly increasing incarnation number). Each row also carries agentsRespond (boolean, #613 lane A: false = an admin muted AI teammates in that channel) and, ONLY while the account's AI teammates switch is on, aiTeammates: [{ userId, lastHeartbeatAt, replying }] (the paired AI teammates that are members of the channel; lastHeartbeatAt is their last listener heartbeat or null, replying is true while one is working a turn in that channel; derive the state like the app: heartbeat within 60 seconds = Listening, listening and replying = Replying, otherwise Away). The aiTeammates key is absent when the switch is off. SIDE EFFECT: it also creates the caller's memberships in the account's AUTO channels (needs-a-hand, new-leads, wins) the first time, so a user who never opened Team Chat can read them. conduyt_list_chat_messages and conduyt_mark_chat_read already do this once for you when a channel listed by conduyt_get_chat_unread answers 403 'Not a member of this channel'; call this tool directly to discover channel ids.", {}, async () => {
         const result = await client.get("/api/v1/chat/channels");
         return formatResult(result);
     }));
@@ -69,6 +69,36 @@ export function registerChatTools(server, client) {
         const result = await withMembershipBootstrap(client, () => client.get(`/api/v1/chat/channels/${channelId}/messages?${params}`));
         return formatResult(result);
     }));
+    strictInput(server.tool("conduyt_send_chat_message", "Send a Team Chat message as the API key's user (POST /api/v1/chat/channels/{id}/messages). The caller must be a channel member and have the communications:create permission. AI-agent keys are subject to the server's six-consecutive-agent-turn cap; a 409 agent_human_required means no message was sent (markerCreated: true on the refusal that inserted the one human-handoff line, false while the thread stays paused). A 409 agents_muted_in_channel means an admin turned \"agents respond here\" off for this channel: the post was refused, nothing was written, and it must not be retried (same shape as agent_human_required). body is plain Team Chat text (1-10,000 characters).", {
+        channelId: z.string().uuid().describe("Channel UUID"),
+        body: z.string().trim().min(1).max(10_000).describe("Message text"),
+        idempotencyKey: z.string().regex(/^[A-Za-z0-9:_.-]{1,128}$/).optional().describe("Paired AI agent keys only: a key unique per agent and source turn (the listener uses reply:<source message id>). The same key returns the reply already created (200, idempotentReplay: true) instead of posting a second one; a key used in another channel is a 409 idempotency_key_reused. A person's key gets 400."),
+    }, async ({ channelId, body, idempotencyKey }) => {
+        const result = await client.post(`/api/v1/chat/channels/${channelId}/messages`, { body, ...(idempotencyKey ? { idempotencyKey } : {}) });
+        return formatResult(result);
+    }));
+    strictInput(server.tool("conduyt_reply_chat_message", "Reply in a Team Chat thread as the API key's user (POST /api/v1/chat/channels/{id}/messages with parentId). parentId must name a live top-level message in that channel. The caller must be a member with communications:create. AI-agent keys are subject to the same six-consecutive-agent-turn cap as a top-level send, and to the same 409 agent_human_required / agents_muted_in_channel refusals (nothing written, do not retry; agents_muted_in_channel = an admin turned \"agents respond here\" off for the channel).", {
+        channelId: z.string().uuid().describe("Channel UUID"),
+        parentId: z.string().uuid().describe("Top-level message UUID to reply to"),
+        body: z.string().trim().min(1).max(10_000).describe("Reply text"),
+        idempotencyKey: z.string().regex(/^[A-Za-z0-9:_.-]{1,128}$/).optional().describe("Paired AI agent keys only: a key unique per agent and source turn (the listener uses reply:<source message id>). The same key returns the reply already created (200, idempotentReplay: true) instead of posting a second one; a key used in another channel is a 409 idempotency_key_reused. A person's key gets 400."),
+        claimToken: z.string().regex(/^[1-9][0-9]{0,8}:[A-Za-z0-9:_.-]{8,128}$/).optional().describe("Paired AI agent keys only; REQUIRED with idempotencyKey reply:<source message id> (refused otherwise, nothing posted): the listener's claim token <generation>:<listener id> from the turn prompt. The reply completes that turn only when posted in the source's channel and thread with the current generation's token; a reply:<source> reply anywhere else, or with a stale token, is refused 409 (reply_wrong_channel / reply_wrong_thread / reply_stale_claim) with nothing posted, so a corrected retry still completes the turn."),
+    }, async ({ channelId, parentId, body, idempotencyKey, claimToken }) => {
+        // (#599 r7) a reply to an inbox turn (idempotencyKey reply:<source message id>) always names its claim
+        if (!claimToken && typeof idempotencyKey === "string" && /^reply:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(idempotencyKey)) {
+            throw new Error("claimToken is required with an idempotencyKey reply:<source message id> (the turn prompt's reply claim token); nothing was posted");
+        }
+        const result = await client.post(`/api/v1/chat/channels/${channelId}/messages`, { body, parentId, ...(idempotencyKey ? { idempotencyKey } : {}), ...(claimToken ? { claimToken } : {}) });
+        return formatResult(result);
+    }));
+    strictInput(server.tool("conduyt_react_chat_message", "Add a reaction to a Team Chat message as the API key's user (POST /api/v1/chat/channels/{id}/messages/{messageId}/reactions). The server accepts only its Team Chat reaction set and returns the fully hydrated message. Repeating the same reaction is safe and leaves one reaction from this user.", {
+        channelId: z.string().uuid().describe("Channel UUID"),
+        messageId: z.string().uuid().describe("Message UUID"),
+        emoji: z.string().min(1).max(16).describe("One allowed Team Chat emoji"),
+    }, async ({ channelId, messageId, emoji }) => {
+        const result = await client.post(`/api/v1/chat/channels/${channelId}/messages/${messageId}/reactions`, { emoji });
+        return formatResult(result);
+    }));
     strictInput(server.tool("conduyt_mark_chat_read", "Acknowledge team chat as read up to one message (GET /api/v1/chat/channels/{id}/messages?readUpTo=<messageId>&limit=1; the API takes the acknowledgement as a query on the message list). readUpTo is the UUID of a message you were served (its seq becomes your read marker); take it from conduyt_list_chat_messages. The marker only moves FORWARD, never to 'now': an older (stale) message is a no-op, and a message that is not in this channel moves nothing (the call still succeeds, so re-check conduyt_get_chat_unread). A malformed id is a 400. On a 403 'Not a member of this channel' it calls GET /chat/channels once (creating the caller's auto-channel memberships) and retries ONCE; a second refusal, or a 403 for any other reason, is returned as is. The response is the newest message of the channel (limit 1), not a confirmation of the move.", {
         channelId: z.string().uuid().describe("Channel UUID"),
         readUpTo: z.string().uuid().describe("UUID of the newest message you have seen in this channel"),

package/dist/tools/companies.js

@@ -31,12 +31,24 @@ export function registerCompanyTools(server, client) {
         const result = await client.get(`/api/v1/companies?${params}`);
         return formatResult(result);
     });
-    server.tool("conduyt_get_company", "Get a single company with full details — contacts (up to 100), deals (up to 50), and aggregated deal value.", {
+    server.tool("conduyt_get_company", "Get a single company with full details and aggregated deal value. Carries the FIRST page of each related list: contacts (100, total contactCount, contactsNextCursor), deals (50, dealsNextCursor) and child accounts (childCompanies, 25, total childCount, childNextCursor). A non-null next cursor means more rows: read them with conduyt_list_company_related.", {
         id: z.string().describe("Company UUID"),
     }, async ({ id }) => {
         const result = await client.get(`/api/v1/companies/${id}`);
         return formatResult(result);
     });
+    server.tool("conduyt_list_company_related", "List the NEXT pages of a company's related records (GET /companies/{id}/related, permission companies.view). `conduyt_get_company` already carries the FIRST page of each kind (contacts, deals, children) with its total and next cursor (contactsNextCursor, dealsNextCursor, childNextCursor): pass that cursor here as `cursor` with the same `kind`, then pass each answer's `nextCursor` back until it is null (keyset: strictly after the last row shown, none repeated or skipped). Answers { kind, rows, total, nextCursor }. kind contacts = the company's own and associated contacts, newest first; deals = newest first; children = child accounts oldest first (by creation time, then id). A caller who may not read deals (or a key without the deals scope) gets an empty deals list with total 0. 400 for an unknown kind or a cursor this list did not issue; 404 for an unknown company.", {
+        company_id: z.string().uuid().describe("Company UUID"),
+        kind: z.enum(["contacts", "deals", "children"]).describe("Which related list: contacts, deals or children (child accounts)"),
+        cursor: z.string().optional().describe("The nextCursor of the previous page (from conduyt_get_company or this tool), passed back unchanged; omit it to read the first page"),
+    }, async ({ company_id, kind, cursor }) => {
+        const params = new URLSearchParams();
+        params.set("kind", kind);
+        if (cursor !== undefined)
+            params.set("cursor", cursor);
+        const result = await client.get(`/api/v1/companies/${encodeURIComponent(company_id)}/related?${params}`);
+        return formatResult(result);
+    });
     server.tool("conduyt_create_company", "Create a new company record with business details.", {
         name: z.string().describe("Company name (required)"),
         domain: z.string().optional().describe("Company domain (e.g. 'acme.com')"),

package/package.json

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

package/scripts/coverage-manifest.json

@@ -130,11 +130,36 @@
       "status": "excluded",
       "reason": "UI-only deep-link helper (resolves a message to its channel/position for the app's router); not an agent surface"
     },
+    {
+      "match": "/api/v1/chat/agents/me/",
+      "status": "excluded",
+      "reason": "(#599) the listener protocol of a paired agent key (long poll, per-event ack, heartbeat): served by the npm CLI `conduyt agent listen`, not a request/response MCP tool"
+    },
+    {
+      "match": "POST /api/v1/chat/agents/pair",
+      "status": "excluded",
+      "reason": "(#599) the single-use pair-code exchange that MINTS the agent's key: the listener's first call (npm CLI `conduyt agent pair` / `listen --pair-code`), never made with an existing key"
+    },
+    {
+      "match": "PATCH /api/v1/chat/channels/:id/agents",
+      "status": "excluded",
+      "reason": "(#599) session-only (assertSessionOnly): a channel's agents-respond mode is an admin setting; every API key is refused"
+    },
+    {
+      "match": "/api/v1/chat/agents",
+      "status": "excluded",
+      "reason": "(#599) session-only (assertSessionOnly): an admin manages AI teammates in Settings > AI; every API key is refused"
+    },
     {
       "match": "/api/v1/chat",
       "status": "planned",
       "reason": "team chat read/post for agents"
     },
+    {
+      "match": "/api/v1/settings/ai-teammates",
+      "status": "excluded",
+      "reason": "(#614) session-only (assertSessionOnly): an admin turns AI teammates on or off in Settings > AI (Professional and above, the trial, comp); every API key is refused"
+    },
     {
       "match": "/api/v1/settings",
       "status": "planned",

package/scripts/coverage-matrix.json

@@ -1,11 +1,11 @@
 {
-  "generatedAt": "2026-10-29T23:02:33.248Z",
-  "toolCount": 373,
-  "totalEndpoints": 1118,
+  "generatedAt": "2026-10-30T13:37:28.694Z",
+  "toolCount": 378,
+  "totalEndpoints": 1134,
   "counts": {
-    "covered": 327,
-    "excluded": 336,
-    "planned": 455,
+    "covered": 331,
+    "excluded": 350,
+    "planned": 453,
     "uncategorized": 0
   },
   "matrix": {
@@ -301,6 +301,12 @@
       "status": "planned",
       "reason": "activity detail reads beyond the log tools"
     },
+    "GET /api/v1/activity/export.csv": {
+      "status": "covered",
+      "tools": [
+        "conduyt_export_activities_csv"
+      ]
+    },
     "GET /api/v1/admin/accounts": {
       "status": "excluded",
       "reason": "super-admin platform operations (Conduyt staff only)"
@@ -1269,6 +1275,46 @@
         "conduyt_voice_drop"
       ]
     },
+    "GET /api/v1/chat/agents": {
+      "status": "excluded",
+      "reason": "(#599) session-only (assertSessionOnly): an admin manages AI teammates in Settings > AI; every API key is refused"
+    },
+    "POST /api/v1/chat/agents": {
+      "status": "excluded",
+      "reason": "(#599) session-only (assertSessionOnly): an admin manages AI teammates in Settings > AI; every API key is refused"
+    },
+    "PATCH /api/v1/chat/agents/:id": {
+      "status": "excluded",
+      "reason": "(#599) session-only (assertSessionOnly): an admin manages AI teammates in Settings > AI; every API key is refused"
+    },
+    "DELETE /api/v1/chat/agents/:id": {
+      "status": "excluded",
+      "reason": "(#599) session-only (assertSessionOnly): an admin manages AI teammates in Settings > AI; every API key is refused"
+    },
+    "POST /api/v1/chat/agents/:id/pair-code": {
+      "status": "excluded",
+      "reason": "(#599) session-only (assertSessionOnly): an admin manages AI teammates in Settings > AI; every API key is refused"
+    },
+    "POST /api/v1/chat/agents/me/heartbeat": {
+      "status": "excluded",
+      "reason": "(#599) the listener protocol of a paired agent key (long poll, per-event ack, heartbeat): served by the npm CLI `conduyt agent listen`, not a request/response MCP tool"
+    },
+    "GET /api/v1/chat/agents/me/inbox": {
+      "status": "excluded",
+      "reason": "(#599) the listener protocol of a paired agent key (long poll, per-event ack, heartbeat): served by the npm CLI `conduyt agent listen`, not a request/response MCP tool"
+    },
+    "POST /api/v1/chat/agents/me/inbox/ack": {
+      "status": "excluded",
+      "reason": "(#599) the listener protocol of a paired agent key (long poll, per-event ack, heartbeat): served by the npm CLI `conduyt agent listen`, not a request/response MCP tool"
+    },
+    "POST /api/v1/chat/agents/me/inbox/claim": {
+      "status": "excluded",
+      "reason": "(#599) the listener protocol of a paired agent key (long poll, per-event ack, heartbeat): served by the npm CLI `conduyt agent listen`, not a request/response MCP tool"
+    },
+    "POST /api/v1/chat/agents/pair": {
+      "status": "excluded",
+      "reason": "(#599) the single-use pair-code exchange that MINTS the agent's key: the listener's first call (npm CLI `conduyt agent pair` / `listen --pair-code`), never made with an existing key"
+    },
     "POST /api/v1/chat/ask": {
       "status": "planned",
       "reason": "team chat read/post for agents"
@@ -1287,6 +1333,10 @@
       "status": "planned",
       "reason": "team chat read/post for agents"
     },
+    "PATCH /api/v1/chat/channels/:id/agents": {
+      "status": "excluded",
+      "reason": "(#599) session-only (assertSessionOnly): a channel's agents-respond mode is an admin setting; every API key is refused"
+    },
     "POST /api/v1/chat/channels/:id/members": {
       "status": "planned",
       "reason": "team chat read/post for agents"
@@ -1303,8 +1353,11 @@
       ]
     },
     "POST /api/v1/chat/channels/:id/messages": {
-      "status": "planned",
-      "reason": "team chat read/post for agents"
+      "status": "covered",
+      "tools": [
+        "conduyt_send_chat_message",
+        "conduyt_reply_chat_message"
+      ]
     },
     "GET /api/v1/chat/channels/:id/messages/:messageId": {
       "status": "planned",
@@ -1331,8 +1384,10 @@
       "reason": "team chat read/post for agents"
     },
     "POST /api/v1/chat/channels/:id/messages/:messageId/reactions": {
-      "status": "planned",
-      "reason": "team chat read/post for agents"
+      "status": "covered",
+      "tools": [
+        "conduyt_react_chat_message"
+      ]
     },
     "DELETE /api/v1/chat/channels/:id/messages/:messageId/reactions": {
       "status": "planned",
@@ -1440,6 +1495,12 @@
       "status": "planned",
       "reason": "company subroutes beyond core CRUD"
     },
+    "GET /api/v1/companies/:id/related": {
+      "status": "covered",
+      "tools": [
+        "conduyt_list_company_related"
+      ]
+    },
     "GET /api/v1/companies/:id/tags": {
       "status": "planned",
       "reason": "company subroutes beyond core CRUD"
@@ -1755,6 +1816,10 @@
       "status": "excluded",
       "reason": "CRON_SECRET-gated infrastructure jobs; never key-callable"
     },
+    "GET /api/v1/cron/chat-webhooks": {
+      "status": "excluded",
+      "reason": "CRON_SECRET-gated infrastructure jobs; never key-callable"
+    },
     "GET /api/v1/cron/cleanup-audit-logs": {
       "status": "excluded",
       "reason": "CRON_SECRET-gated infrastructure jobs; never key-callable"
@@ -4240,6 +4305,14 @@
       "status": "planned",
       "reason": "account settings read/update surfaces"
     },
+    "GET /api/v1/settings/ai-teammates": {
+      "status": "excluded",
+      "reason": "(#614) session-only (assertSessionOnly): an admin turns AI teammates on or off in Settings > AI (Professional and above, the trial, comp); every API key is refused"
+    },
+    "PATCH /api/v1/settings/ai-teammates": {
+      "status": "excluded",
+      "reason": "(#614) session-only (assertSessionOnly): an admin turns AI teammates on or off in Settings > AI (Professional and above, the trial, comp); every API key is refused"
+    },
     "PUT /api/v1/settings/ai/byo": {
       "status": "planned",
       "reason": "account settings read/update surfaces"