conduyt-mcp 4.105.5 → 4.105.7

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.
 
-## 387 Tools
+## 393 Tools
 
 ### Discovery
 | Tool | Description |
@@ -270,7 +270,19 @@ The Mailchimp OAuth connect and callback are browser-only: connect Mailchimp in
 
 The thread view (#684): `conduyt_list_chat_messages` takes `topLevel: true` (top-level messages with their reply chip `thread`, and the replies shown in the channel with `threadReply` `{ reason: aiFirstAnswer | alsoInChannel, root }`; never with `afterSeq`) and `conduyt_reply_chat_message` takes `alsoInChannel: true` ("Also send to #channel" on a person's reply). Both are sent only when true. They and the two thread tools work only while the workspace's switch is on (`conduyt_list_chat_channels` then carries `teamChatThreads: true`); while it is off each answers an error result with `code: team_chat_threads_off` and the sentence "The thread view is not switched on for this workspace (account setting teamChatThreads)." Against a server that predates the thread view: the two thread tools answer a 404 error result that says so, `topLevel` is reported as not applied (an error result, never a page of every reply), and an `alsoInChannel` reply is posted in the thread only, with a note saying so (never re-sent).
 
-AI teammate turns (#802, the app listener's #655 phase 1): a turn run through Codex (`conduyt agent listen --adapter codex`) carries the thread so far and, when the channel is linked, "This channel is linked to deal <id>" (read it with `conduyt_get_chat_linked_record`), and ends with exactly ONE of `conduyt_reply_chat_message` (with `idempotencyKey` + `claimToken`), `conduyt_react_chat_message` (with `claimToken`) or `conduyt_stay_silent`; a second, different one is refused 409 `turn_finished`. The inbox itself (`/chat/agents/me/*`: the event's `context.recent`, `channel.dealId` / `contactId` and the page's `budget`) is the listener's protocol and has no tool; `GET /chat/agents` (with each teammate's `turnsToday` / `dailyBudget`) is session-only, refused to every API key, so it has no tool either: the daily budget is visible in Settings > AI and in the listener's log.
+AI teammate turns (#802, the app listener's #655 phase 1): a turn run through Codex (`conduyt agent listen --adapter codex`) carries the thread so far and, when the channel is linked, "This channel is linked to deal <id>" (read it with `conduyt_get_chat_linked_record`), and ends with exactly ONE of `conduyt_reply_chat_message` (with `idempotencyKey` + `claimToken`), `conduyt_react_chat_message` (with `claimToken`) or `conduyt_stay_silent`; a second, different one is refused 409 `turn_finished`. The inbox itself (`/chat/agents/me/*`: the event's `context.recent`, `channel.dealId` / `contactId` and the page's `budget`) is the listener's protocol and has no tool; (#1153) `GET /chat/agents` answers an owner's or admin's key the teammate rows of `conduyt_list_ai_teammates` (no `turnsToday` / `dailyBudget`: those are the Settings session's): the daily budget is visible in Settings > AI and in the listener's log.
+
+### A Grok Bot as an AI teammate (#1140)
+| Tool | Description |
+|------|-------------|
+| `conduyt_list_ai_teammates` | (#1153) The workspace's AI teammates (`GET /chat/agents`, an owner's or admin's key, the read tier is enough): `[{ id, handle, name, provider, state, connected, connection, createdAt }]`, nothing secret. Name a teammate to the tools below by its id or its @handle |
+| `conduyt_connect_ai_teammate` | Step 1 (`POST /chat/agents/{id}/connect`): the message to paste into Grok Bot and the teammate's token, returned ONCE (`{ token, tokenPrefix, message, toolsUrl, agent }`); the token goes into Grok Bot's masked connector field, never into a chat. Every call revokes the earlier tokens. The calling key needs the write tier and the chat and deals scopes |
+| `conduyt_set_ai_teammate_webhook` | Step 3 (`PUT /chat/agents/{id}/webhook`): `paste` (the block Grok Bot shows) OR `address` + `key`; checked, stored (the key encrypted), tested at once: `{ stored, test, status }`. The key is write-only: never returned, and any returned text has it replaced by `[hidden]`. A test that was not accepted is an error result with its one sentence (`key_refused`, `routine_gone`, `unreachable`, `not_accepted`, `rate_limited`; `teammate_not_live` is a 409 before any test) |
+| `conduyt_test_ai_teammate_webhook` | The card's Test button (`POST /chat/agents/{id}/webhook/test`): the hello again to the stored routine; `{ test, status }` |
+| `conduyt_get_ai_teammate_webhook` | The status the card polls (`GET /chat/agents/{id}/webhook`): `state` not_connected / waiting_for_hello / listening / not_listening, `problem { code, message }`, the address masked; poll it after a test until listening |
+| `conduyt_disconnect_ai_teammate` | `DELETE /chat/agents/{id}/webhook`: tokens revoked, the routine's key cleared, pending deliveries cancelled; the teammate and its messages stay; never blocked by billing |
+
+Owners and admins, with a person's API key; an AI teammate's own key is refused. The teammate is named by its id (a UUID) or its @handle (`conduyt_list_ai_teammates` lists both; the server resolves the handle). Against a server without these routes (an HTML 404) each tool answers "This Conduyt server does not have the Grok Bot connection yet (it predates it); connect the teammate in Settings > AI instead."
 
 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.
 

package/dist/register-all.js

@@ -26,6 +26,7 @@ import { registerMailchimpTools } from "./tools/mailchimp.js";
 import { registerStatusMetadataTools } from "./tools/status-metadata.js";
 import { registerNotificationTools } from "./tools/notifications.js";
 import { registerChatTools } from "./tools/chat.js";
+import { registerAiTeammateConnectTools } from "./tools/ai-teammate-connect.js";
 import { registerCustomFieldTools } from "./tools/custom-fields.js";
 import { registerSmartListTools } from "./tools/smart-lists.js";
 import { registerUserTools } from "./tools/users.js";
@@ -90,6 +91,7 @@ export function registerAllTools(server, client) {
     registerStatusMetadataTools(server, client);
     registerNotificationTools(server, client);
     registerChatTools(server, client);
+    registerAiTeammateConnectTools(server, client);
     registerCustomFieldTools(server, client);
     registerSmartListTools(server, client);
     registerUserTools(server, client);

package/dist/tool-annotations.js

@@ -190,6 +190,15 @@ export const TOOL_ANNOTATIONS = {
     conduyt_get_chat_linked_record: ro("Get Chat Linked Record"),
     // (#684) the thread reads recover a first-use 403 through GET /chat/channels, which creates auto-channel memberships (as conduyt_list_chat_messages)
     conduyt_get_chat_thread: update("Get Chat Thread"),
+    // (#1140 A3) the Grok Bot teammate connect tools: connect mints a token and revokes the earlier ones on every call; set stores the
+    // routine key (replacing the last) and sends a test each call; test sends one; disconnect revokes the tokens
+    // (#1153) the teammate list: a read
+    conduyt_list_ai_teammates: ro("List AI Teammates"),
+    conduyt_connect_ai_teammate: row("Connect AI Teammate", false, true, false),
+    conduyt_set_ai_teammate_webhook: row("Set AI Teammate Webhook", false, false, false),
+    conduyt_test_ai_teammate_webhook: create("Test AI Teammate Webhook"),
+    conduyt_get_ai_teammate_webhook: ro("Get AI Teammate Webhook"),
+    conduyt_disconnect_ai_teammate: destroy("Disconnect AI Teammate"),
     conduyt_list_chat_thread_files: update("List Chat Thread Files"),
     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"),

package/dist/tools/ai-teammate-connect.d.ts

@@ -0,0 +1,28 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { ConduytApiError, ConduytClient } from "../client.js";
+export { hide } from "./routine-key-redaction.js";
+/**
+ * (#1140 lane A3) Connecting a Grok Bot routine as an AI teammate, the tri-surface twin of the Settings > AI card and of the CLI's
+ * `agent connect` / `agent webhook set|test|status` / `agent disconnect`. Built against conduyt-app lane A2b at 0c0088508
+ * (app/api/v1/chat/agents/[id]/connect, .../webhook, .../webhook/test; every sentence lives in lib/agent-webhook-connect.ts) and the
+ * concept page Cerebro domains/conduyt/wiki/concepts/grok-bot-teammate-webhook-and-remote-tools-2026-11-05.md (section S).
+ *
+ * The routine's key is WRITE-ONLY: it goes into the PUT body and nowhere else. The server never answers it, and every text these tools
+ * return (results and refusals) is passed through `hide`, which replaces it wherever it appears. Every refusal is an error result with
+ * ONE plain sentence: the server's own (the S.3 and input sentences are written for people) or ours where its text is not one (today's
+ * production answers these paths with an HTML 404; the switch answers "Not found").
+ */
+export declare const OLDER_SERVER_SENTENCE = "This Conduyt server does not have the Grok Bot connection yet (it predates it); connect the teammate in Settings > AI instead.";
+export declare const AI_OFF_SENTENCE = "AI teammates are switched off for this workspace; an owner or admin turns them on in Settings > AI.";
+export declare const NOT_FOUND_SENTENCE = "There is no AI teammate with that id or handle in this workspace (it may have been revoked); conduyt_list_ai_teammates lists them.";
+/** (#1153) GET /chat/agents on a server from before #1153 refuses every API key with its session-only sentence */
+export declare const OLDER_LIST_SENTENCE = "This Conduyt server does not let an API key read the AI teammate list yet (it predates it); see the teammates in Settings > AI.";
+export declare const TEAMMATE_KEY_SENTENCE = "This is an AI teammate's own key; connect a Grok Bot with a person's API key (an owner or admin).";
+export declare const NO_CREDENTIALS_SENTENCE = "Give the routine's address and key: paste (the block Grok Bot shows), or address and key.";
+/** the one sentence for a refused call, and its code when the API sent one */
+export declare function refusalOf(err: ConduytApiError): {
+    status: number | null;
+    code: string | null;
+    sentence: string;
+};
+export declare function registerAiTeammateConnectTools(server: McpServer, client: ConduytClient): void;

package/dist/tools/ai-teammate-connect.js

@@ -0,0 +1,139 @@
+import { z } from "zod";
+import { ConduytApiError, formatToolError } from "../client.js";
+import { strictInput } from "./strict.js";
+import { hide, secretsInPaste, secretsOfKey } from "./routine-key-redaction.js";
+export { hide } from "./routine-key-redaction.js";
+/**
+ * (#1140 lane A3) Connecting a Grok Bot routine as an AI teammate, the tri-surface twin of the Settings > AI card and of the CLI's
+ * `agent connect` / `agent webhook set|test|status` / `agent disconnect`. Built against conduyt-app lane A2b at 0c0088508
+ * (app/api/v1/chat/agents/[id]/connect, .../webhook, .../webhook/test; every sentence lives in lib/agent-webhook-connect.ts) and the
+ * concept page Cerebro domains/conduyt/wiki/concepts/grok-bot-teammate-webhook-and-remote-tools-2026-11-05.md (section S).
+ *
+ * The routine's key is WRITE-ONLY: it goes into the PUT body and nowhere else. The server never answers it, and every text these tools
+ * return (results and refusals) is passed through `hide`, which replaces it wherever it appears. Every refusal is an error result with
+ * ONE plain sentence: the server's own (the S.3 and input sentences are written for people) or ours where its text is not one (today's
+ * production answers these paths with an HTML 404; the switch answers "Not found").
+ */
+export const OLDER_SERVER_SENTENCE = "This Conduyt server does not have the Grok Bot connection yet (it predates it); connect the teammate in Settings > AI instead.";
+export const AI_OFF_SENTENCE = "AI teammates are switched off for this workspace; an owner or admin turns them on in Settings > AI.";
+export const NOT_FOUND_SENTENCE = "There is no AI teammate with that id or handle in this workspace (it may have been revoked); conduyt_list_ai_teammates lists them.";
+/** (#1153) GET /chat/agents on a server from before #1153 refuses every API key with its session-only sentence */
+export const OLDER_LIST_SENTENCE = "This Conduyt server does not let an API key read the AI teammate list yet (it predates it); see the teammates in Settings > AI.";
+export const TEAMMATE_KEY_SENTENCE = "This is an AI teammate's own key; connect a Grok Bot with a person's API key (an owner or admin).";
+export const NO_CREDENTIALS_SENTENCE = "Give the routine's address and key: paste (the block Grok Bot shows), or address and key.";
+function errorDetailsOf(message) {
+    for (let i = message.indexOf("{"); i !== -1; i = message.indexOf("{", i + 1)) {
+        try {
+            const v = JSON.parse(message.slice(i));
+            if (v && typeof v === "object" && !Array.isArray(v))
+                return v;
+        }
+        catch { /* not the details object */ }
+    }
+    return {};
+}
+/** the API's own error line (between "Conduyt API <status>: " and its Retry-After tag or details object) */
+function apiErrorText(message) {
+    const m = /^Conduyt API \d{3}: ([\s\S]*)$/.exec(message);
+    let t = m ? m[1] : message;
+    const brace = t.search(/ \[Retry-After: |\s\{/);
+    if (brace !== -1)
+        t = t.slice(0, brace);
+    return t.replace(/\s+/g, " ").trim();
+}
+/** the one sentence for a refused call, and its code when the API sent one */
+export function refusalOf(err) {
+    const details = errorDetailsOf(err.message);
+    const code = typeof details.code === "string" ? details.code : null;
+    const text = apiErrorText(err.message);
+    const status = err.status;
+    if (code === "ai_teammates_off")
+        return { status, code, sentence: AI_OFF_SENTENCE };
+    if (code === "agent_route_refused")
+        return { status, code, sentence: TEAMMATE_KEY_SENTENCE };
+    if (status === 404 && text === "Agent not found")
+        return { status, code, sentence: NOT_FOUND_SENTENCE };
+    // today's production: its HTML not-found page (404 text/html, before any auth); a 405: a route without this method
+    if (status === 404 || status === 405)
+        return { status, code, sentence: OLDER_SERVER_SENTENCE };
+    return { status, code, sentence: text.slice(0, 600) || `Conduyt answered ${status} without an explanation.` };
+}
+/** a structured, non-retried error result: { ok: false, status, code?, error: <one sentence>, ...extra } */
+function connectError(sentence, secrets, extra = {}) {
+    const base = formatToolError(hide(sentence, secrets));
+    return { ...base, content: [{ type: "text", text: hide(JSON.stringify({ ok: false, error: sentence, ...extra }, null, 2), secrets) }] };
+}
+/** a result whose text is redacted of the secrets */
+function connectResult(data, secrets) {
+    return { content: [{ type: "text", text: hide(JSON.stringify(data, null, 2), secrets) }] };
+}
+/** runs one call: an HTTP refusal becomes the one-sentence error result; any other failure is re-thrown with the secrets hidden */
+async function attempt(secrets, call, done) {
+    try {
+        return done(await call());
+    }
+    catch (err) {
+        if (err instanceof ConduytApiError && err.code === "http") {
+            const r = refusalOf(err);
+            return connectError(r.sentence, secrets, { status: r.status, ...(r.code ? { code: r.code } : {}) });
+        }
+        throw new Error(hide(err instanceof Error ? err.message : String(err), secrets));
+    }
+}
+const unwrap = (res) => (res && typeof res === "object" && "data" in res ? res.data : res);
+/** a test's answer: the data, or (the test was not accepted) an error result with the S.3 sentence and the whole answer beside it */
+function testOutcome(secrets) {
+    return (res) => {
+        const d = unwrap(res);
+        if (d?.test?.ok === true)
+            return connectResult(d, secrets);
+        const problem = d?.test?.problem;
+        return connectError(problem?.message ?? "Grok Bot did not accept the test.", secrets, { status: 200, ...(problem?.code ? { code: problem.code } : {}), answer: d });
+    };
+}
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/** the app's handle rule (lib/agent-auth.ts normalizeAgentHandle): a letter, then 1-31 letters, digits, _ or -, case-insensitive */
+const HANDLE_RE = /^@[a-z][a-z0-9_-]{1,31}$/i;
+/** (#1153) the teammate: its id (a UUID) or its @handle, lower-cased; the server resolves the handle (lib/agent-webhook-routes.ts
+ *  parseTeammateRef, the one place for every surface), so nothing here looks it up */
+const TEAMMATE_ID = z.string().trim().refine((v) => UUID_RE.test(v) || HANDLE_RE.test(v), { message: "teammateId must be the teammate's id (a UUID) or its @handle" })
+    .describe("The Grok Bot teammate: its id (a UUID) or its @handle, as conduyt_list_ai_teammates lists them (the agent.id of conduyt_connect_ai_teammate's answer and the senderId of its messages are the id too)");
+/** the path segment of a teammate: trimmed and lower-cased (handles and ids are case-insensitive), an @handle travels as %40handle */
+const seg = (teammateId) => encodeURIComponent(teammateId.trim().toLowerCase());
+const WHO = "Owners and admins, with a person's API key (the chat scope); an AI teammate's own key is refused (403 agent_route_refused). The teammate must have the provider Grok Bot (409 agent_not_webhook_provider otherwise). Answers 404 ai_teammates_off while AI teammates are switched off and 402 plan_required when the workspace is not entitled. Against a server that predates these routes (an HTML 404) the error says so.";
+export function registerAiTeammateConnectTools(server, client) {
+    // (#1153, tri-surface parity) the workspace's AI teammates, so an agent can find the one to connect by id or @handle
+    strictInput(server.tool("conduyt_list_ai_teammates", "List the workspace's live AI teammates (GET /api/v1/chat/agents; a removed teammate is not listed), oldest first: [{ id, handle, name, provider (claude_code, codex, grok), state (listening, replying, away), connected (a Grok Bot teammate: its connection is stored and live; any other: a listener runs now), connection (a Grok Bot teammate's not_connected, waiting_for_hello, listening or not_listening; null otherwise), createdAt }]. Nothing secret is listed. Name a teammate to the Grok Bot tools by its id or its @handle. Owners and admins, with a person's API key (the chat scope; reading is enough); a member's key is refused (403) and an AI teammate's own key too (403 agent_route_refused). Adding a teammate stays in Settings > AI. Answers 404 ai_teammates_off while AI teammates are switched off and 402 plan_required when the workspace is not entitled; a workspace with more than 200 live teammates is refused to an API key (413 agent_list_over_ceiling; Settings > AI lists them all).", {}, async () => {
+        try {
+            const res = await client.get("/api/v1/chat/agents");
+            return connectResult(unwrap(res), []);
+        }
+        catch (err) {
+            if (err instanceof ConduytApiError && err.code === "http") {
+                if (err.status === 403 && /interactive browser session/i.test(err.message))
+                    return connectError(OLDER_LIST_SENTENCE, [], { status: 403 });
+                const r = refusalOf(err);
+                return connectError(r.sentence, [], { status: r.status, ...(r.code ? { code: r.code } : {}) });
+            }
+            throw err;
+        }
+    }));
+    strictInput(server.tool("conduyt_connect_ai_teammate", `Step 1 of connecting a Grok Bot as an AI teammate (POST /api/v1/chat/agents/{id}/connect). Mints the teammate's token and returns it ONCE: { token, tokenPrefix, message, toolsUrl, agent }. Give the person the message to paste into Grok Bot and the token to paste into Grok Bot's masked connector field; NEVER post the token in Team Chat or any message, and never call this again just to read it: every call revokes the teammate's earlier tokens (the card's "Get a new token"). The calling key must hold the write tier and the chat and deals scopes (403 api_key_scope_insufficient otherwise). 409 agent_listener_webhook_conflict while the teammate's listener is running; 409 teammate_not_live when its owner lost access. Step 3 is conduyt_set_ai_teammate_webhook. ${WHO}`, { teammateId: TEAMMATE_ID }, async ({ teammateId }) => attempt([], () => client.post(`/api/v1/chat/agents/${seg(teammateId)}/connect`, {}), (res) => connectResult(unwrap(res), []))));
+    strictInput(server.tool("conduyt_set_ai_teammate_webhook", `Step 3 of connecting a Grok Bot (PUT /api/v1/chat/agents/{id}/webhook): the routine's address and key, as Grok Bot shows them. Send EITHER paste (the whole block the person copied: it must hold one https address and one key) OR address and key. Conduyt checks the address (https, a public host), stores both (the key encrypted), sends the test at once (10 s) and answers { stored, test: { ok, statusCode, runUuid, problem }, status }. The key is write-only: it is never returned, and any text this tool returns has it replaced by [hidden]. A test that was not accepted is an error result { ok: false, error: <its one sentence>, status: 200, code (key_refused, routine_gone, unreachable, not_accepted, rate_limited), answer: <the whole answer> }; an accepted test leaves status Waiting for Grok Bot to say hello: poll conduyt_get_ai_teammate_webhook (every few seconds, up to about 3 minutes) until state is listening or a problem is named. Refusals: 400 with the input codes (input_conflict, address_missing, address_invalid, address_ambiguous, key_missing, key_invalid, key_ambiguous), 422 address_invalid / unreachable, 409 agent_token_missing (run conduyt_connect_ai_teammate first), agent_listener_webhook_conflict, agent_webhook_contended, teammate_not_live, 429 after 20 tests per teammate in 10 minutes, 503 while a delivery is in flight. ${WHO}`, {
+        teammateId: TEAMMATE_ID,
+        paste: z.string().min(1).max(12_000).optional().describe("The block Grok Bot shows (address and key together); not with address or key"),
+        address: z.string().min(1).max(2_048).optional().describe("The routine's address (https://...)"),
+        key: z.string().min(1).max(600).optional().describe("The routine's key (write-only: never returned). The bare key or the \"Authorization: Bearer ...\" header value"),
+    }, async ({ teammateId, paste, address, key }) => {
+        // (r2, Codex grokA3-mcp-r1 P1) every form the server could take as the key (routine-key-redaction.ts: the server's rules ported,
+        // plus the floor of every token as typed), for each input that can carry it: the key field, the paste, an address box holding both
+        const secrets = [...(key !== undefined ? secretsOfKey(key) : []), ...(paste !== undefined ? secretsInPaste(paste) : []), ...(address !== undefined ? secretsInPaste(address) : [])];
+        if (paste === undefined && address === undefined)
+            return connectError(NO_CREDENTIALS_SENTENCE, secrets, { status: null, code: "address_missing" });
+        // the body as ONE literal: the contract gate reads the request fields (paste, address, key) from it
+        return attempt(secrets, () => client.put(`/api/v1/chat/agents/${seg(teammateId)}/webhook`, { ...(paste !== undefined ? { paste } : {}), ...(address !== undefined ? { address } : {}), ...(key !== undefined ? { key } : {}) }), testOutcome(secrets));
+    }));
+    strictInput(server.tool("conduyt_test_ai_teammate_webhook", `The card's Test button (POST /api/v1/chat/agents/{id}/webhook/test): sends the hello again to the stored routine (nothing is pasted); an accepted test turns a stored connection live. Answers { test, status } like conduyt_set_ai_teammate_webhook (a test that was not accepted is an error result with its sentence); then poll conduyt_get_ai_teammate_webhook for the hello. 409 agent_webhook_not_connected when nothing is stored; 429 after 20 tests per teammate in 10 minutes. ${WHO}`, { teammateId: TEAMMATE_ID }, async ({ teammateId }) => attempt([], () => client.post(`/api/v1/chat/agents/${seg(teammateId)}/webhook/test`, {}), testOutcome([]))));
+    strictInput(server.tool("conduyt_get_ai_teammate_webhook", `The Grok Bot connection's status (GET /api/v1/chat/agents/{id}/webhook), what the Settings card polls: { state (not_connected | waiting_for_hello | listening | not_listening), label, problem: { code, message } | null (the sentence of what to fix), waitingUntil, connected, address (masked), lastAttempt, tokenUsedAt, lastMessageAt }. Never carries the key. ${WHO}`, { teammateId: TEAMMATE_ID }, async ({ teammateId }) => attempt([], () => client.get(`/api/v1/chat/agents/${seg(teammateId)}/webhook`), (res) => connectResult(unwrap(res), []))));
+    strictInput(server.tool("conduyt_disconnect_ai_teammate", `Disconnect a Grok Bot teammate (DELETE /api/v1/chat/agents/{id}/webhook; never blocked by billing): its tokens are revoked, the routine's key is cleared and pending deliveries are cancelled; the teammate and its messages stay. Answers { disconnected, revokedKeys, webhook, cancelledDeliveries }. Safe to repeat. Connect it again with conduyt_connect_ai_teammate then conduyt_set_ai_teammate_webhook. ${WHO.replace(" and 402 plan_required when the workspace is not entitled", "")}`, { teammateId: TEAMMATE_ID }, async ({ teammateId }) => attempt([], () => client.del(`/api/v1/chat/agents/${seg(teammateId)}/webhook`), (res) => connectResult(unwrap(res), []))));
+}

package/dist/tools/routine-key-redaction.d.ts

@@ -0,0 +1,22 @@
+/**
+ * (#1140 lane A3 r2) What to redact so the Grok Bot routine key never leaves this program: every form the server could take as the
+ * key, plus a floor. THIS FILE IS IDENTICAL in conduyt-cli (src/routine-key-redaction.ts) and conduyt-mcp
+ * (src/tools/routine-key-redaction.ts), and so is its test (routine-key-redaction.test.ts beside it): the two repos cannot import from
+ * each other or from the app, so the same table runs against each copy and a drift fails a test. Findings it answers: Codex
+ * grokA3-cli-r1 P2 2 and grokA3-mcp-r1 P1.
+ */
+/** replaces every appearance of each secret (4 characters or more) in a text about to be printed or returned */
+export declare function hide(text: string, secrets: readonly string[]): string;
+/** :157-163 normalizeRoutineKey (the key field, and every candidate of a block at :191) */
+export declare function serverNormalizeKey(raw: string): string | null;
+/** :176-198 parseRoutineBlock's key extraction: the text without its addresses (:184), then crsr_ tokens (:186), the token after
+ *  "Bearer " (:187), the token after a line-leading "key:" / "key =" (:188), each with trailing punctuation cut and normalized (:191).
+ *  Returns EVERY normalized candidate (the server takes exactly one; all of them are hidden). */
+export declare function serverKeyCandidates(text: string): string[];
+/** the FLOOR: every whitespace-separated token of the input as typed (not an address) of 8 characters or more, in each shape a strip
+ *  of surrounding quotes or brackets, a leading label (key: / key= / Authorization: / Bearer) or trailing punctuation gives it */
+export declare function rawKeyTokens(text: string): string[];
+/** what to hide for a pasted block (the server's candidates, then the floor) */
+export declare function secretsInPaste(text: string): string[];
+/** what to hide for a key given on its own (:213 normalizes the key field; :210 reads an address-alone body as a block) */
+export declare function secretsOfKey(raw: string): string[];

package/dist/tools/routine-key-redaction.js

@@ -0,0 +1,88 @@
+/**
+ * (#1140 lane A3 r2) What to redact so the Grok Bot routine key never leaves this program: every form the server could take as the
+ * key, plus a floor. THIS FILE IS IDENTICAL in conduyt-cli (src/routine-key-redaction.ts) and conduyt-mcp
+ * (src/tools/routine-key-redaction.ts), and so is its test (routine-key-redaction.test.ts beside it): the two repos cannot import from
+ * each other or from the app, so the same table runs against each copy and a drift fails a test. Findings it answers: Codex
+ * grokA3-cli-r1 P2 2 and grokA3-mcp-r1 P1.
+ */
+/** replaces every appearance of each secret (4 characters or more) in a text about to be printed or returned */
+export function hide(text, secrets) {
+    let out = text;
+    // (r2) longest first: a shorter secret inside a longer one never leaves the longer one's tail behind
+    for (const s of [...secrets].sort((a, b) => b.length - a.length))
+        if (s && s.length >= 4)
+            out = out.split(s).join("[hidden]");
+    return out;
+}
+// A PORT of the server's extraction, conduyt-app lane A2b 0c0088508 lib/agent-webhook-connect.ts, rule for rule and in its order.
+// It is used ONLY to know what to hide, never to decide what is sent (the server parses the paste itself). Where the port and the
+// server could ever disagree, the floor (rawKeyTokens) still hides the key: every token of the input as typed, in every shape a
+// strip of quotes, labels and trailing punctuation can give it.
+/** lib/agent-webhook-connect.ts:146 KEY_RE */
+const SERVER_KEY_RE = /^[A-Za-z0-9._~+/=-]{8,512}$/;
+/** :147 URL_IN_TEXT_RE */
+const SERVER_URL_IN_TEXT_RE = /https?:\/\/[^\s"'`<>]+/gi;
+/** :148 TRAILING_PUNCT_RE */
+const SERVER_TRAILING_PUNCT_RE = /[.,;:!?)\]}]+$/;
+/** :150-154 unquote */
+function serverUnquote(raw) {
+    let out = raw.trim();
+    while (out.length >= 2 && /^["'`<]/.test(out) && /["'`>]$/.test(out))
+        out = out.slice(1, -1).trim();
+    return out;
+}
+/** :157-163 normalizeRoutineKey (the key field, and every candidate of a block at :191) */
+export function serverNormalizeKey(raw) {
+    let s = serverUnquote(raw);
+    s = s.replace(/^authorization\s*:\s*/i, "");
+    s = s.replace(/^bearer\s+/i, "");
+    s = serverUnquote(s);
+    return SERVER_KEY_RE.test(s) ? s : null;
+}
+/** :176-198 parseRoutineBlock's key extraction: the text without its addresses (:184), then crsr_ tokens (:186), the token after
+ *  "Bearer " (:187), the token after a line-leading "key:" / "key =" (:188), each with trailing punctuation cut and normalized (:191).
+ *  Returns EVERY normalized candidate (the server takes exactly one; all of them are hidden). */
+export function serverKeyCandidates(text) {
+    const rest = text.replace(SERVER_URL_IN_TEXT_RE, " ");
+    const found = [];
+    for (const m of rest.matchAll(/(?:^|[^A-Za-z0-9_])(crsr_[A-Za-z0-9_-]+)/g))
+        found.push(m[1]);
+    for (const m of rest.matchAll(/\bbearer\s+([^\s"'`]+)/gi))
+        found.push(m[1]);
+    for (const m of rest.matchAll(/^[ \t]*(?:the\s+)?key\s*[:=][ \t]*["'`]?([^\s"'`]+)/gim))
+        found.push(m[1]);
+    const out = [];
+    for (const c of found) {
+        const k = serverNormalizeKey(c.replace(SERVER_TRAILING_PUNCT_RE, ""));
+        if (k)
+            out.push(k);
+    }
+    return out;
+}
+/** the FLOOR: every whitespace-separated token of the input as typed (not an address) of 8 characters or more, in each shape a strip
+ *  of surrounding quotes or brackets, a leading label (key: / key= / Authorization: / Bearer) or trailing punctuation gives it */
+export function rawKeyTokens(text) {
+    const out = new Set();
+    const add = (t) => { if (t.length >= 8 && !/^https?:\/\//i.test(t))
+        out.add(t); };
+    for (const tok of text.split(/\s+/)) {
+        const shapes = [tok];
+        for (let i = 0; i < 3; i++) {
+            for (const t of [...shapes]) {
+                shapes.push(t.replace(/^["'`<(\[{]+|["'`>)\]}]+$/g, ""), t.replace(SERVER_TRAILING_PUNCT_RE, ""), t.replace(/^(?:key\s*[:=]|authorization\s*:|bearer\s*:?)/i, ""));
+            }
+        }
+        for (const t of shapes)
+            add(t);
+    }
+    return [...out];
+}
+/** what to hide for a pasted block (the server's candidates, then the floor) */
+export function secretsInPaste(text) {
+    return [...new Set([...serverKeyCandidates(text), ...rawKeyTokens(text)])];
+}
+/** what to hide for a key given on its own (:213 normalizes the key field; :210 reads an address-alone body as a block) */
+export function secretsOfKey(raw) {
+    const n = serverNormalizeKey(raw);
+    return [...new Set([raw, raw.trim(), ...(n ? [n] : []), ...rawKeyTokens(raw)])].filter((s) => s.length >= 4);
+}

package/package.json

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

package/scripts/coverage-manifest.json

@@ -153,7 +153,7 @@
     {
       "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"
+      "reason": "(#599) creating, removing and pairing an AI teammate are session-only (assertSessionOnly): an admin manages them in Settings > AI; every API key is refused. (#1153) GET /chat/agents is covered by conduyt_list_ai_teammates and the Grok Bot connect routes by their five tools (a covered endpoint is never matched here)"
     },
     {
       "match": "/api/v1/chat",

package/scripts/coverage-matrix.json

@@ -1,11 +1,11 @@
 {
-  "generatedAt": "2026-11-06T12:12:53.647Z",
-  "toolCount": 387,
-  "totalEndpoints": 1152,
+  "generatedAt": "2026-11-06T22:13:20.826Z",
+  "toolCount": 393,
+  "totalEndpoints": 1162,
   "counts": {
-    "covered": 341,
-    "excluded": 353,
-    "planned": 458,
+    "covered": 347,
+    "excluded": 355,
+    "planned": 460,
     "uncategorized": 0
   },
   "matrix": {
@@ -1312,24 +1312,56 @@
       ]
     },
     "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"
+      "status": "covered",
+      "tools": [
+        "conduyt_list_ai_teammates"
+      ]
     },
     "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"
+      "reason": "(#599) creating, removing and pairing an AI teammate are session-only (assertSessionOnly): an admin manages them in Settings > AI; every API key is refused. (#1153) GET /chat/agents is covered by conduyt_list_ai_teammates and the Grok Bot connect routes by their five tools (a covered endpoint is never matched here)"
     },
     "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"
+      "reason": "(#599) creating, removing and pairing an AI teammate are session-only (assertSessionOnly): an admin manages them in Settings > AI; every API key is refused. (#1153) GET /chat/agents is covered by conduyt_list_ai_teammates and the Grok Bot connect routes by their five tools (a covered endpoint is never matched here)"
     },
     "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"
+      "reason": "(#599) creating, removing and pairing an AI teammate are session-only (assertSessionOnly): an admin manages them in Settings > AI; every API key is refused. (#1153) GET /chat/agents is covered by conduyt_list_ai_teammates and the Grok Bot connect routes by their five tools (a covered endpoint is never matched here)"
+    },
+    "POST /api/v1/chat/agents/:id/connect": {
+      "status": "covered",
+      "tools": [
+        "conduyt_connect_ai_teammate"
+      ]
     },
     "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"
+      "reason": "(#599) creating, removing and pairing an AI teammate are session-only (assertSessionOnly): an admin manages them in Settings > AI; every API key is refused. (#1153) GET /chat/agents is covered by conduyt_list_ai_teammates and the Grok Bot connect routes by their five tools (a covered endpoint is never matched here)"
+    },
+    "GET /api/v1/chat/agents/:id/webhook": {
+      "status": "covered",
+      "tools": [
+        "conduyt_get_ai_teammate_webhook"
+      ]
+    },
+    "PUT /api/v1/chat/agents/:id/webhook": {
+      "status": "covered",
+      "tools": [
+        "conduyt_set_ai_teammate_webhook"
+      ]
+    },
+    "DELETE /api/v1/chat/agents/:id/webhook": {
+      "status": "covered",
+      "tools": [
+        "conduyt_disconnect_ai_teammate"
+      ]
+    },
+    "POST /api/v1/chat/agents/:id/webhook/test": {
+      "status": "covered",
+      "tools": [
+        "conduyt_test_ai_teammate_webhook"
+      ]
     },
     "POST /api/v1/chat/agents/me/heartbeat": {
       "status": "excluded",
@@ -1349,6 +1381,18 @@
         "conduyt_stay_silent"
       ]
     },
+    "GET /api/v1/chat/agents/me/mcp": {
+      "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/mcp": {
+      "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"
+    },
+    "DELETE /api/v1/chat/agents/me/mcp": {
+      "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"
@@ -1425,6 +1469,14 @@
         "conduyt_list_chat_thread_files"
       ]
     },
+    "PUT /api/v1/chat/channels/:id/messages/:messageId/follow": {
+      "status": "planned",
+      "reason": "team chat read/post for agents"
+    },
+    "DELETE /api/v1/chat/channels/:id/messages/:messageId/follow": {
+      "status": "planned",
+      "reason": "team chat read/post for agents"
+    },
     "POST /api/v1/chat/channels/:id/messages/:messageId/handoff": {
       "status": "planned",
       "reason": "team chat read/post for agents"