conduyt-mcp 4.104.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.
 
-## 376 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 |
 
@@ -402,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"),

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/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.104.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

@@ -480,11 +480,6 @@
       "status": "planned",
       "reason": "account readiness/onboarding surfaces"
     },
-    {
-      "match": "GET /api/v1/activity/export.csv",
-      "status": "planned",
-      "reason": "activity-log CSV export (small586, landed on app main after the 4.103.0 pin); a CSV download, tool deferred; classified here so the 4.104.0 snapshot refresh passes the coverage gate"
-    },
     {
       "match": "/api/v1/activities",
       "status": "planned",

package/scripts/coverage-matrix.json

@@ -1,11 +1,11 @@
 {
   "generatedAt": "2026-10-30T13:37:28.694Z",
-  "toolCount": 376,
+  "toolCount": 378,
   "totalEndpoints": 1134,
   "counts": {
-    "covered": 329,
+    "covered": 331,
     "excluded": 350,
-    "planned": 455,
+    "planned": 453,
     "uncategorized": 0
   },
   "matrix": {
@@ -302,8 +302,10 @@
       "reason": "activity detail reads beyond the log tools"
     },
     "GET /api/v1/activity/export.csv": {
-      "status": "planned",
-      "reason": "activity-log CSV export (small586, landed on app main after the 4.103.0 pin); a CSV download, tool deferred; classified here so the 4.104.0 snapshot refresh passes the coverage gate"
+      "status": "covered",
+      "tools": [
+        "conduyt_export_activities_csv"
+      ]
     },
     "GET /api/v1/admin/accounts": {
       "status": "excluded",
@@ -1494,8 +1496,10 @@
       "reason": "company subroutes beyond core CRUD"
     },
     "GET /api/v1/companies/:id/related": {
-      "status": "planned",
-      "reason": "company subroutes beyond core CRUD"
+      "status": "covered",
+      "tools": [
+        "conduyt_list_company_related"
+      ]
     },
     "GET /api/v1/companies/:id/tags": {
       "status": "planned",