@trylighthouse/mcp-server 0.2.17 → 0.2.20

package/README.md

@@ -205,6 +205,20 @@ Webhook subscriptions are created and deleted with the REST API or the SDKs, wit
 | `lighthouse_reports_share_dashboard_with_teams` | Share a dashboard with teams |
 | `lighthouse_reports_revoke_dashboard_from_teams` | Revoke team access to a dashboard |
 
+### Sequences
+
+People only: the add, update and remove tools take CRM person IDs. Everyone added lands in the sequence's Review, and nothing is sent until a member adds them from there in the app. Sequences are created and edited in the app.
+
+| Tool | Description |
+|------|-------------|
+| `lighthouse_sequences_list` | List the sequences you can open, or find one by its name |
+| `lighthouse_sequences_get` | Get a sequence with its steps, settings and sending accounts |
+| `lighthouse_sequences_list_people` | List the people in a sequence and where each one stands |
+| `lighthouse_sequences_add_people` | Add people to a sequence's Review |
+| `lighthouse_sequences_update_people` | Stop, pause or resume people in a sequence (stopping ends that sequence only) |
+| `lighthouse_sequences_remove_people` | Remove people from a sequence, deleting their history in it |
+| `lighthouse_crm_list_record_sequences` | List the sequences a person, company or deal is in |
+
 ## Rate limits
 
 A `429` with the code `rate_limit_exceeded` is retried for you, up to 4 times, before the tool reports the `429` exactly as the API sent it. Before each retry the server waits at least the seconds in the `Retry-After` header (1 second if there is none, at most 30). Each retry also draws a random wait that can grow with every attempt: up to 2 seconds before the first retry, then up to 4, 8 and 16 (never more than 30), and the server waits the longer of the two. Calls refused at the same moment therefore spread out instead of all coming back together and being refused again. It never starts a retry more than 40 seconds after the first attempt, so the API still has time to answer within the 60 seconds many MCP clients allow for a tool call. When the next wait would end past those 40 seconds, the tool reports the `429` straight away. A tool call your client cancels stops waiting and is not sent again. The API refuses such a request before running it, so a refused attempt changes nothing and only the attempt it accepts is applied. No other error is retried, `credit_limit_exceeded` included, and neither is a limit set by a connected email or LinkedIn account (`rate_limited`).

package/build/server.d.ts

@@ -1,5 +1,2 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-export interface CreateServerOptions {
-    privateEquity?: boolean;
-}
-export declare function createServer(apiKey?: string, options?: CreateServerOptions): McpServer;
+export declare function createServer(apiKey?: string): McpServer;

package/build/server.js

@@ -57,6 +57,9 @@ function textWithImage(res, image, declaredType) {
     const mimeType = IMAGE_CONTENT_TYPES.has(image.contentType) ? image.contentType : declaredType;
     return { ...base, content: [...base.content, { type: "image", data: image.bytes.toString("base64"), mimeType }] };
 }
+const FILE_BLOCKED_TOOL_RULE = "A file whose blocked_reason is threat_detected cannot be read or downloaded.";
+const FILE_BLOCKED_KEYS = "A file a threat was found in also carries blocked_at and blocked_reason.";
+const FILE_BLOCKED_ANSWER = "Reading or downloading such a file answers 409 file_blocked (\"This file could not be read: a threat was detected in it.\").";
 const FILE_CONTENT_RULES = "kind is pdf, document, spreadsheet, presentation, html, csv, markdown, text or image (null for a kind that cannot be read); pages_total is a PDF's pages or a presentation's slides. " +
     "A spreadsheet reads as one \"Sheet: <name>\" block per sheet, a row per line with its cells tab separated (a date shows as its stored serial number); a presentation as one \"Slide <n>\" block per slide. " +
     `A long file comes back in windows of max_chars (default ${FILE_CONTENT_WINDOW_CHARS}): meta.has_more true means the file continues, so pass meta.next_offset_chars as offset_chars to read on, and never treat a window with has_more as the end of the file. ` +
@@ -85,11 +88,11 @@ const READ_ONLY = { readOnlyHint: true, destructiveHint: false, idempotentHint:
 const CREATES = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
 const ADDS_IF_MISSING = { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false };
 const DESTRUCTIVE = { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false };
-export function createServer(apiKey, options = {}) {
+export function createServer(apiKey) {
     const api = new LighthouseAPI(apiKey);
     const server = new McpServer({
         name: "lighthouse",
-        version: "0.2.17",
+        version: "0.2.20",
     });
     const originalRegister = server.registerTool.bind(server);
     server.registerTool = (name, schemaOrConfig, handler) => {
@@ -422,7 +425,7 @@ export function createServer(apiKey, options = {}) {
     server.registerTool("lighthouse_crm_list_options", {
         title: "List CRM Field Options",
         annotations: READ_ONLY,
-        description: "Get the allowed values for a CRM select / multi_select field. Each row is { value, label, color, priority, is_default, enabled }, the same object the options[] of an attribute carries; a built-in value the workspace switched off is listed with enabled: false rather than left out, so do not offer it when setting a field. " +
+        description: "Get the allowed values for a CRM select / multi_select field. Each row is { value, label, color, priority, is_default, enabled }, the same object the options[] of an attribute carries; a built-in value the workspace switched off is not listed, and a write naming it is refused. " +
             "Call this when lighthouse_crm_list_attributes shows has_options=true for a field and you need its values before filtering or setting it. " +
             "Results are paginated (max 100 per page): use `search` to narrow by label, and `limit` / `offset` to page through a field with many options. " +
             "For custom objects, use the object's permalink as record_type.",
@@ -448,7 +451,7 @@ export function createServer(apiKey, options = {}) {
         annotations: CREATES,
         description: "Add a new option to a select/multi_select field. The option value is auto-generated from the label. " +
             "Re-creating a system default option that was previously removed restores it (its original color and label are kept). " +
-            "Returns the updated list of ALL options for the field, each row { value, label, color, priority, is_default, enabled }, with a switched-off built-in value listed as enabled: false, plus meta.total. The list comes back in the order the field offers its options, so do not read the first row as the option you just created: find it by the label you sent. " +
+            "Returns the updated list of ALL options for the field, each row { value, label, color, priority, is_default, enabled }, without a built-in value the workspace switched off, plus meta.total. The list comes back in the order the field offers its options, so do not read the first row as the option you just created: find it by the label you sent. " +
             "For custom objects, use the object's permalink as record_type. " +
             "Options can only be created on company, person, deal, and custom objects.",
         inputSchema: {
@@ -1536,7 +1539,8 @@ export function createServer(apiKey, options = {}) {
             "Each row includes my_role ('owner' | 'editor' | 'viewer'), is_owner, " +
             "owner (the member who owns it: { id, first_name, last_name, full_name, avatar_url, email }), " +
             "sharing ('private' or 'workspace'), linked_records_count, and " +
-            "shared_with_teams[] (each entry has { team_id, team_name, role, granted_at }).",
+            "shared_with_teams[] (each entry has { team_id, team_name, role, granted_at }). " +
+            `${FILE_BLOCKED_KEYS} ${FILE_BLOCKED_TOOL_RULE}`,
         inputSchema: {
             folder_id: z.string().uuid().optional().describe("Folder UUID to list contents of (omit for workspace root)"),
             limit: z.number().int().min(1).max(500).optional().describe("Rows per sub-list (folders, files). Default 200, max 500"),
@@ -1707,7 +1711,8 @@ export function createServer(apiKey, options = {}) {
     server.registerTool("lighthouse_documents_get_file", {
         title: "Get File",
         annotations: READ_ONLY,
-        description: "Get file metadata. Response includes my_role ('owner' | 'editor' | 'viewer'), is_owner, owner (the member who owns it: { id, first_name, last_name, full_name, avatar_url, email }), sharing ('private' or 'workspace'), linked_records_count, linked_records[] and shared_with_teams[] (each entry has { team_id, team_name, role, granted_at }). Pass download_url=true to also receive a short-lived signed read URL (expires in 15 minutes). To read what the file SAYS, use lighthouse_documents_get_file_content.",
+        description: "Get file metadata. Response includes my_role ('owner' | 'editor' | 'viewer'), is_owner, owner (the member who owns it: { id, first_name, last_name, full_name, avatar_url, email }), sharing ('private' or 'workspace'), linked_records_count, linked_records[] and shared_with_teams[] (each entry has { team_id, team_name, role, granted_at }). Pass download_url=true to also receive a short-lived signed read URL (expires in 15 minutes). To read what the file SAYS, use lighthouse_documents_get_file_content. " +
+            `${FILE_BLOCKED_KEYS} ${FILE_BLOCKED_TOOL_RULE} ${FILE_BLOCKED_ANSWER}`,
         inputSchema: {
             file_id: z.string().uuid().describe("File UUID"),
             download_url: z.boolean().optional().describe("Include a short-lived signed download URL"),
@@ -1730,7 +1735,8 @@ export function createServer(apiKey, options = {}) {
             "Take the file id from lighthouse_documents_list or lighthouse_documents_list_for_record. " +
             "Returns the file's row (the one lighthouse_documents_get_file returns: id, name, folder_id, size_bytes, content_type, sharing, owner, ...) followed by kind, pages_total, text, reason and note. " +
             FILE_CONTENT_RULES +
-            " A file the user may not open answers forbidden, one that does not exist not found.",
+            " A file the user may not open answers forbidden, one that does not exist not found. " +
+            `${FILE_BLOCKED_TOOL_RULE} ${FILE_BLOCKED_ANSWER}`,
         inputSchema: {
             file_id: z.string().uuid().optional().describe("File UUID. The name every other file tool takes."),
             id: z.string().uuid().optional().describe("Same as file_id. Send either one."),
@@ -1761,7 +1767,8 @@ export function createServer(apiKey, options = {}) {
         annotations: DESTRUCTIVE,
         description: "Rename, move, or change sharing on a file. Editors can rename and delete it. Only the owner can move it (into another folder or to the root), change sharing, or grant team access, with one exception: the owner of the folder the file is in can also move it down into a sub-folder of that folder, when they own that sub-folder and every folder in between. " +
             "team_ids replaces the current set when supplied. " +
-            "Returns the file row: owner, is_owner, my_role, sharing, shared_with_teams[] (each { team_id, team_name, role, granted_at }), linked_records_count, size_bytes, content_type, created_at, updated_at.",
+            "Returns the file row: owner, is_owner, my_role, sharing, shared_with_teams[] (each { team_id, team_name, role, granted_at }), linked_records_count, size_bytes, content_type, created_at, updated_at. " +
+            FILE_BLOCKED_TOOL_RULE,
         inputSchema: {
             file_id: z.string().uuid().describe("File UUID, the file being changed"),
             name: z.string().optional().describe("New name"),
@@ -1785,7 +1792,7 @@ export function createServer(apiKey, options = {}) {
     server.registerTool("lighthouse_documents_delete_file", {
         title: "Delete File",
         annotations: DESTRUCTIVE,
-        description: "Owner or editor (file-level editor OR editor-on-parent-folder) can delete, provided they also have the files.delete workspace permission. Permanently deletes the file and purges the underlying object from storage. Irreversible.",
+        description: "Owner or editor (file-level editor OR editor-on-parent-folder) can delete, provided they also have the files.delete workspace permission. Permanently deletes the file and purges the underlying object from storage. Irreversible. " + FILE_BLOCKED_TOOL_RULE,
         inputSchema: {
             file_id: z.string().uuid().describe("File UUID"),
         },
@@ -1801,7 +1808,7 @@ export function createServer(apiKey, options = {}) {
     server.registerTool("lighthouse_documents_link_file_to_record", {
         title: "Link File to Record",
         annotations: ADDS_IF_MISSING,
-        description: "Make a file appear on a CRM record's Files tab. Answers THE FILE itself, the same row lighthouse_documents_get_file returns, with its links as they are after the call.",
+        description: "Make a file appear on a CRM record's Files tab. Answers THE FILE itself, the same row lighthouse_documents_get_file returns, with its links as they are after the call. " + FILE_BLOCKED_TOOL_RULE,
         inputSchema: {
             file_id: z.string().uuid().describe("File UUID"),
             record_type: z.string().describe("company, person, deal, or a custom object permalink"),
@@ -1820,7 +1827,7 @@ export function createServer(apiKey, options = {}) {
     server.registerTool("lighthouse_documents_unlink_file_from_record", {
         title: "Unlink File from Record",
         annotations: DESTRUCTIVE,
-        description: "Remove a file→record link. Answers THE FILE itself, the same row lighthouse_documents_get_file returns, with its links as they are after the call.",
+        description: "Remove a file→record link. Answers THE FILE itself, the same row lighthouse_documents_get_file returns, with its links as they are after the call. " + FILE_BLOCKED_TOOL_RULE,
         inputSchema: {
             file_id: z.string().uuid().describe("File UUID"),
             record_type: z.string().describe("company, person, deal, or a custom object permalink"),
@@ -1841,7 +1848,8 @@ export function createServer(apiKey, options = {}) {
         annotations: READ_ONLY,
         description: "List folders and files linked to a CRM record. Returns { folders, files }. `files` are files linked DIRECTLY to the record; files that live inside a linked folder are NOT flattened into `files`. To read a linked folder's contents, list that folder by its id with lighthouse_documents_list. " +
             "Each row includes my_role ('owner' | 'editor' | 'viewer'), is_owner, owner (the member who owns it: { id, first_name, last_name, full_name, avatar_url, email }), sharing ('private' or 'workspace'), linked_records_count, linked_at, and shared_with_teams[] (each entry has { team_id, team_name, role, granted_at }). " +
-            "Cursor-based pagination via meta.folders_next_cursor / meta.files_next_cursor; pass them back as folders_cursor / files_cursor to fetch the next page.",
+            "Cursor-based pagination via meta.folders_next_cursor / meta.files_next_cursor; pass them back as folders_cursor / files_cursor to fetch the next page. " +
+            `${FILE_BLOCKED_KEYS} ${FILE_BLOCKED_TOOL_RULE}`,
         inputSchema: {
             record_type: z.string().describe("company, person, deal, or a custom object permalink"),
             record_id: z.string().uuid().describe("Record UUID"),
@@ -3039,6 +3047,186 @@ export function createServer(apiKey, options = {}) {
             return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
         }
     });
+    const SEQUENCE_PEOPLE_PER_CALL_MAX = 100;
+    const SEQUENCE_FINISHED_ELSEWHERE_DAYS = 30;
+    const SEQUENCE_END_REASONS = "finished (went through every step), replied (their reply ended the run, or they replied after its last step), colleague_replied (someone else from their company replied), wrote_first (they wrote in before this sequence contacted them; not a reply), accepted_invitation, already_connected, not_accepted (did not accept the LinkedIn invitation), stopped_manually, unsubscribed, bounced, failed or stopped";
+    const SEQUENCE_PERSON_STATUS = "status is the person's own place in the sequence, never the sequence's: in_review (waiting in the sequence's Review for a member to add them), ready (added from Review, waiting to start), active, paused and account_disconnected (waiting for its sending account, or for a check of any reply sent while it was disconnected) are still going; completed, stopped, failed, bounced and unsubscribed have ended. " +
+        "end_reason only says why a run ENDED: a reply the sequence's rules let it carry on through shows only in outcome, so for everyone who replied read outcome too.";
+    const SEQUENCE_STOPPABLE_RUNS = "ready, active, paused, or waiting for an account that can send or for a check of their replies";
+    const SEQUENCE_RESUME_CHECK_RULE = "once any check of the replies they sent while an account was disconnected is done; a check that could not be made is ended, so they go on without it";
+    const SEQUENCE_MEMBER = "{ id, first_name, last_name, full_name, avatar_url, email }";
+    const SEQUENCE_PERSON_KEYS = "id (this person's run in the sequence), crm_person { id, first_name, last_name, avatar_url } (the CRM person: its id is what lighthouse_sequences_add_people, lighthouse_sequences_update_people and lighthouse_sequences_remove_people take, and what lighthouse_crm_get_record reads), " +
+        "email (the address the run sends to), company { id, name, avatar_url, is_deleted } (the company its messages name, null when none), status, step_status (what the current step is doing, null when nothing), current_step { number (from 1), type } (null before the first step), " +
+        "outcome (how their reply reads: positive, negative, neutral or automated; null with no reply), outcome_source (ai or manual), stop_reason, stopped_by { id, first_name, last_name } (the person from their company whose reply stopped this run; id is that colleague's own run in this sequence, not a CRM person id), " +
+        "end_reason (why the run ended: " + SEQUENCE_END_REASONS + "; null while it is still going), ended_by (the member who ended it by hand, " + SEQUENCE_MEMBER + "; null when the sequence or the person ended it), last_error_code, " +
+        "added_via (manual, csv, list, find_leads, crm_action, api, workflow or assistant), started_at, ended_at, created_at";
+    const SEQUENCE_NOT_FOUND_RULE = "A sequence the API key's user cannot open answers 'Sequence not found', the same as one that does not exist.";
+    server.registerTool("lighthouse_sequences_list", {
+        title: "List Sequences",
+        annotations: READ_ONLY,
+        description: "List the outbound sequences the API key's user can open (their own, and those shared with the workspace or with one of their teams), newest first. A sequence sends each person in it a series of steps (emails, LinkedIn connection requests and LinkedIn messages) from connected accounts. " +
+            "Each row: id, name, status (draft, active or paused), sharing (private or workspace), shared_with_teams [{ team_id, team_name, granted_at }], is_owner (true when the API key's user owns it), has_unpublished_changes (the app holds an edit not published yet; what is read here is the published sequence, what runs), owner (the member who created it, " + SEQUENCE_MEMBER + "), step_count, stats, created_at and updated_at. " +
+            "stats counts its people: people (everyone, ended runs included), in_review (waiting in the sequence's Review), not_started (added from Review, waiting to start), active, ended, errors, contacted (sent at least one message or connection request, or wrote back), responded (wrote back; an out-of-office or a delivery notice never counts) and positive_responses. The response rate is responded / contacted. " +
+            "WHEN TO USE: \"which sequences do we have\", \"how is our outreach doing\", or to find a sequence someone names: pass query with part of its name and read the id off the matching row instead of paging through all of them. meta.total counts the sequences that matched. " +
+            "For one sequence's steps, settings and sending accounts use lighthouse_sequences_get; for who is in it, lighthouse_sequences_list_people. Whether a given person, company or deal is in a sequence is lighthouse_crm_list_record_sequences (a person's record also carries a sequences field), never a walk through every sequence. " +
+            "Creating a sequence, editing its steps or settings, sharing it and turning it on or off are done in the app: no tool does them.",
+        inputSchema: {
+            query: z.string().optional().describe("Part of the sequence's name, in any case"),
+            search: z.string().optional().describe("Same as query. Either name works; query wins when both are sent."),
+            status: z.enum(["draft", "active", "paused"]).optional().describe("Only the sequences with this status. All of them when omitted"),
+            limit: z.number().min(1).max(100).default(25).describe("Sequences per page (max 100)"),
+            offset: z.number().min(0).default(0).describe("Sequences to skip; meta.total and meta.has_more say whether more remain"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.get("/sequences", params);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_sequences_get", {
+        title: "Get Sequence",
+        annotations: READ_ONLY,
+        description: "One sequence in full, by id: every key of a lighthouse_sequences_list row plus settings, people_not_started (people added from Review and still waiting to start), steps and senders. The steps and settings are the PUBLISHED sequence, what runs; has_unpublished_changes says the app holds an edit not published yet. " +
+            "steps, in order, each { id, number (from 1), type (email, linkedin_connection_request or linkedin_message), channel (email or linkedin), delay { amount, unit (hours, days or weeks) } (the wait before the step, counted from when a person reaches it; null when it runs right away), message_mode (shared: one message for everyone, per_person: a draft written for each person, or ai: each person's message written by AI when they are added), subject (email steps only), message (the shared text, or a connection request's note; null when none, and on a per_person or ai step), include_signature (null on a connection request), sender_id (the sending account this step always uses, null when the sequence chooses), if_accepted and if_not_accepted (a connection request's rules, null on other steps), people_at_step, errors_at_step, drafts_written }. " +
+            "senders, the accounts it sends from, each { id (what a step's sender_id points at), channel, account { id, name, email, is_owner }, owner (the member, " + SEQUENCE_MEMBER + "), is_connected, can_send (false: the people it would send to wait), daily_limit (this sequence's own, null when the account's applies), account_daily_limit, account_sent_today, sequence_sent_today }. " +
+            "settings: schedule { days (ISO weekdays, 1 = Monday), window_start, window_end (HH:MM), timezone }, enrollment { daily_starts, prioritise_new_people }, senders { email, linkedin: { mode (rotate or fixed), fixed_sender_id } }, email_min_gap_minutes, linkedin_min_gap_minutes, stop_on_bounce, include_unsubscribe_link, unsubscribe_link_text and step_defaults (the rules every step follows); a value that is null was never changed, so the product default applies. " +
+            "WHEN TO USE: what a sequence does (its steps in order, the wait before each, its messages, when it sends and from which accounts), or why its people are waiting (a sender that cannot send). For who is in it use lighthouse_sequences_list_people. " + SEQUENCE_NOT_FOUND_RULE,
+        inputSchema: {
+            id: z.string().uuid().describe("Sequence ID, from lighthouse_sequences_list or the sequence of a lighthouse_crm_list_record_sequences row"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.get(`/sequences/${params.id}`);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_sequences_list_people", {
+        title: "List Sequence People",
+        annotations: READ_ONLY,
+        description: "The people in ONE sequence, newest added first, one page at a time. Each row: " + SEQUENCE_PERSON_KEYS + ", linkedin (the LinkedIn handle the run uses) and sender (the member currently assigned to send to this person, null until one is picked and once that member has left the workspace). " +
+            SEQUENCE_PERSON_STATUS + " " +
+            "meta.counts { running, ended, by_reason { <end_reason>: n } } follows query but never state or end_reason, so one call says how many there are of each. " +
+            "WHEN TO USE: \"who is in this sequence\", \"who is still going\" (state running), \"who replied\" (end_reason replied, then outcome on the others), \"who bounced\", or finding one person in it by name or address (query). " +
+            "Whether one person, company or deal is in any sequence is lighthouse_crm_list_record_sequences. Needs a role that may view both sequences and people. " + SEQUENCE_NOT_FOUND_RULE,
+        inputSchema: {
+            sequence_id: z.string().uuid().describe("Sequence ID, from lighthouse_sequences_list"),
+            query: z.string().optional().describe("Part of the person's name or of the address the sequence sends to, in any case"),
+            search: z.string().optional().describe("Same as query. Either name works; query wins when both are sent."),
+            state: z.enum(["running", "ended"]).optional().describe("running: their run is still going (Review included); ended: it is over. Both when omitted"),
+            end_reason: z.string().optional().describe("Only the people whose run ended this way (implies ended, so state must be ended or left out): " + SEQUENCE_END_REASONS),
+            limit: z.number().min(1).max(100).default(25).describe("People per page (max 100)"),
+            offset: z.number().min(0).default(0).describe("People to skip; meta.total and meta.has_more say whether more remain"),
+        },
+    }, async (params) => {
+        try {
+            const { sequence_id, ...rest } = params;
+            const res = await api.get(`/sequences/${sequence_id}/people`, rest);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_sequences_add_people", {
+        title: "Add People to Sequence",
+        annotations: ADDS_IF_MISSING,
+        description: `Add CRM PEOPLE to a sequence, up to ${SEQUENCE_PEOPLE_PER_CALL_MAX} per call: crm_person_ids are person record ids, never companies, deals or lists. ` +
+            "Everyone added lands in the sequence's Review, exactly like an add made in the app, and NOTHING IS SENT until a member opens the sequence in the app and adds them from Review; no tool starts anyone right away, so tell the user the people are waiting in Review, not contacted. " +
+            "When the sequence has a step written by AI (message_mode ai), each person added has their message on it written straight away, while they wait in Review. That uses the workspace's AI credits, shown as Sequence messages on the Credits page, unless the step writes on one of the workspace's own models; a step with no model chosen writes on the workspace's default model when it has one, which uses none. " +
+            "Answers { added, counts, results, other_sequences, other_sequences_hidden }: results has one { crm_person_id, result } per id sent, in order (a repeated id is answered once), and counts carries every result word, 0 when none. " +
+            "result is added (now in the sequence's Review), already_in_sequence (a person is in a sequence at most once, ever: an ended run is not restarted), in_other_sequence (still going or in Review in another sequence; send include_in_other_sequences true to add them anyway), duplicate_email or duplicate_linkedin (someone else in this sequence is reached at the same address or LinkedIn profile), unsubscribed (opted out, or their address bounced and the sequence has no LinkedIn step), finished_other_sequence (only with skip_finished_elsewhere) or crm_person_not_found (no person with that id in the workspace: a company or deal id, or a deleted person). " +
+            "other_sequences names the sequences ({ id, name }) holding the people skipped as in_other_sequence that the API key's user can open; other_sequences_hidden counts the others. " +
+            "WHEN TO USE: the user asks to put people into a sequence (\"add these founders to our outreach\"). Find the sequence with lighthouse_sequences_list and the people with lighthouse_crm_search_records first. Adding the same people again changes nothing (already_in_sequence). Needs a role that may edit sequences and view people. " + SEQUENCE_NOT_FOUND_RULE,
+        inputSchema: {
+            sequence_id: z.string().uuid().describe("Sequence ID, from lighthouse_sequences_list"),
+            crm_person_ids: z.array(z.string().uuid()).min(1).max(SEQUENCE_PEOPLE_PER_CALL_MAX).describe(`CRM person record IDs to add (max ${SEQUENCE_PEOPLE_PER_CALL_MAX}). People only: a company or deal id comes back as crm_person_not_found`),
+            include_in_other_sequences: z.boolean().optional().describe("true also adds the people still going or waiting in Review in another sequence. Default false: they are skipped as in_other_sequence"),
+            skip_finished_elsewhere: z.boolean().optional().describe(`true leaves out the people who were contacted in another sequence and whose run there ended in the last ${SEQUENCE_FINISHED_ELSEWHERE_DAYS} days (result finished_other_sequence); with include_in_other_sequences also true, someone still live in another sequence is added all the same. Default false`),
+        },
+    }, async (params) => {
+        try {
+            const { sequence_id, ...body } = params;
+            const res = await api.post(`/sequences/${sequence_id}/people`, body);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_sequences_update_people", {
+        title: "Update People in Sequence",
+        annotations: DESTRUCTIVE,
+        description: `Stop, pause or resume CRM people in a sequence, up to ${SEQUENCE_PEOPLE_PER_CALL_MAX} per call, by their CRM person ids (a person is in a sequence at most once, so the id names their run). ` +
+            "stop: a run still going (" + SEQUENCE_STOPPABLE_RUNS + ") ends, stopped by the API key's user, and keeps its history. It ends THIS sequence only: the person's runs in other sequences go on. pause: a run that is ready or active holds where it is. resume: a paused run goes on " + SEQUENCE_RESUME_CHECK_RULE + ". " +
+            "Answers { action, changed, results }: results has one { crm_person_id, result, status } per id sent, in order; result is stopped, paused or resumed when their run changed, not_in_sequence when they have no run in it, or not_applicable when their run does not take the action (a person still in Review stopped, an ended run paused, a run that is not paused resumed); status is their run's status now (null when they have none); changed counts the runs that changed. " +
+            "WHEN TO USE: \"stop the sequence for Jane\", \"pause everyone at Acme\", \"resume the people I paused\". To take someone out entirely, history included, or out of Review before anyone is contacted, use lighthouse_sequences_remove_people. Needs a role that may edit sequences and view people. " + SEQUENCE_NOT_FOUND_RULE,
+        inputSchema: {
+            sequence_id: z.string().uuid().describe("Sequence ID, from lighthouse_sequences_list"),
+            crm_person_ids: z.array(z.string().uuid()).min(1).max(SEQUENCE_PEOPLE_PER_CALL_MAX).describe(`CRM person record IDs (max ${SEQUENCE_PEOPLE_PER_CALL_MAX})`),
+            action: z.enum(["stop", "pause", "resume"]).describe("stop ends their run in this sequence only (its history kept), pause holds it, resume continues a paused run " + SEQUENCE_RESUME_CHECK_RULE),
+        },
+    }, async (params) => {
+        try {
+            const { sequence_id, ...body } = params;
+            const res = await api.patch(`/sequences/${sequence_id}/people`, body);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_sequences_remove_people", {
+        title: "Remove People from Sequence",
+        annotations: DESTRUCTIVE,
+        description: `Remove CRM people from a sequence, up to ${SEQUENCE_PEOPLE_PER_CALL_MAX} per call, by their CRM person ids: their run in it is DELETED together with its history, at any stage, Review included, and cannot be brought back. ` +
+            "To end a run and keep its history, use lighthouse_sequences_update_people with action stop instead. " +
+            "Answers { deleted: true, removed, results }: results has one { crm_person_id, result } per id sent, in order, result being removed or not_in_sequence; removed counts the runs deleted. " +
+            "WHEN TO USE: the user asks to take someone out of a sequence altogether, to clear people out of its Review before anyone is contacted, or to undo an add. Needs a role that may edit sequences and view people. " + SEQUENCE_NOT_FOUND_RULE,
+        inputSchema: {
+            sequence_id: z.string().uuid().describe("Sequence ID, from lighthouse_sequences_list"),
+            crm_person_ids: z.array(z.string().uuid()).min(1).max(SEQUENCE_PEOPLE_PER_CALL_MAX).describe(`CRM person record IDs to remove (max ${SEQUENCE_PEOPLE_PER_CALL_MAX})`),
+        },
+    }, async (params) => {
+        try {
+            const { sequence_id, ...body } = params;
+            const res = await api.delete(`/sequences/${sequence_id}/people`, body);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_list_record_sequences", {
+        title: "List Record Sequences",
+        annotations: READ_ONLY,
+        description: "The sequence runs ONE CRM person, company or deal reaches (the record's Sequences tab), runs still going first, then the latest activity: a person's own runs; for a company, the runs that name it as the person's company and the runs of the people on its current team; for a deal, its people's runs and the runs of its companies. A custom object reaches no sequence. " +
+            "Each run: " + SEQUENCE_PERSON_KEYS + ", sequence { id, name, status }, step_count, reached_through (how the record reaches the run: any of person, company, team, deal and deal_company), at_company_now (on a company: whether the person is still on its current team; null on a person or a deal), last_sent_at (the last message or invitation that went out), last_reply_at (their last reply; an out-of-office or a delivery notice never counts) and added_by (the member who added them). Who and when only, never a message. " +
+            SEQUENCE_PERSON_STATUS + " " +
+            "meta.counts { live, ended } counts both groups whatever group asks. " +
+            "WHEN TO USE: \"which sequences is Jane in\", \"is anyone at Acme being contacted\", \"when did we last write to them\", \"who added them\". For a quick yes or no on one person, the sequences field of lighthouse_crm_get_record already lists theirs; for a SET of records (everyone in a sequence, the companies whose team is in one) use one lighthouse_crm_search_records call with a sequences condition (associated_people.sequences on companies and deals) rather than reading records one by one. " +
+            "Only the sequences the API key's user can open are read: a run in any other sequence is left out and not counted, so an empty answer means none they can see. A person can have more than one CRM record: check each. Needs a role that may view sequences, people and the record's type. A record that does not exist answers 'Record not found'.",
+        inputSchema: {
+            record_type: z.enum(["person", "company", "deal"]).describe("person, company or deal (a custom object reaches no sequence)"),
+            record_id: z.string().uuid().describe("The record's ID"),
+            group: z.enum(["live", "ended"]).optional().describe("live: still going (Review included); ended: over. Both when omitted"),
+            limit: z.number().min(1).max(100).default(25).describe("Runs per page (max 100)"),
+            offset: z.number().min(0).default(0).describe("Runs to skip; meta.total and meta.has_more say whether more remain"),
+        },
+    }, async ({ record_type, record_id, group, limit, offset }) => {
+        try {
+            const res = await api.get(`/records/${record_type}/${record_id}/sequences`, { group, limit, offset });
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
     server.registerTool("lighthouse_inbox_email_accounts", {
         title: "List Email Accounts",
         annotations: READ_ONLY,
@@ -3402,7 +3590,7 @@ export function createServer(apiKey, options = {}) {
     server.registerTool("lighthouse_inbox_calendar_meeting_notes", {
         title: "Get Meeting Notes",
         annotations: READ_ONLY,
-        description: "The meeting notes written from one recorded meeting, by meeting_key (" + MEETING_KEY_SOURCES + "): the note in the same shape as lighthouse_crm_get_note (type 'meeting', with the meeting object and the records it is linked to that you can view), plus content_markdown (what was generated: Meeting Context first, then the sections) and is_edited (true when a member changed the note since, in which case content is the version to trust). " +
+        description: "The meeting notes written from one recorded meeting, by meeting_key (" + MEETING_KEY_SOURCES + "): the note in the same shape as lighthouse_crm_get_note (type 'meeting', with the meeting object and the records it is linked to that you can view), plus content_markdown (what was generated: Meeting Context first, then the sections, then Next steps last) and is_edited (true when a member changed the note since, in which case content is the version to trust). " +
             "WHEN TO USE: the user asks what was discussed, decided or agreed in a specific meeting, the next steps from a call, or who attended. Lighter than the transcript: prefer it unless the answer depends on exactly what was said. " +
             "Not found when the meeting has no notes yet (see has_notes on the meeting) or the API key's user may not read them; for a recurring meeting the newest occurrence the user may read is returned. " + MEETING_ACCESS_RULE,
         inputSchema: {
@@ -3438,71 +3626,5 @@ export function createServer(apiKey, options = {}) {
             return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
         }
     });
-    if (options.privateEquity !== true)
-        return server;
-    server.registerTool("lighthouse_private_equity_list_saved_searches", {
-        title: "List Private Equity Saved Searches",
-        annotations: READ_ONLY,
-        description: "List the Private Equity saved searches the user can see in this workspace (their own, the ones shared with the workspace, and the ones shared with one of their teams), ordered by name. " +
-            "Each search carries id, name, sharing (private | workspace), shared_with_teams, is_owner, owner, created_at, updated_at, last_run_at and last_run: the stored run its results come from ({ id, created_at, last_fetched_at, result_count, match_count, created_by }, where result_count is how many companies are stored and match_count how many the search matched in the company database, or null), or null when it never ran. The search's filters are not returned. " +
-            "READ ONLY: this reads what the workspace already stored. It never runs a search, never fetches new companies and never spends credits; a Private Equity search is run, and paid for, only in the Lighthouse app. " +
-            "WHEN TO USE: the user asks which Private Equity searches exist, or names one whose results they want; pass its id to lighthouse_private_equity_list_saved_search_results. " +
-            "These are separate from the Discovery saved searches (lighthouse_discovery_list_saved_searches), which search a different database.",
-        inputSchema: {
-            offset: z.number().int().min(0).optional().describe("Number of saved searches to skip (default 0)"),
-            limit: z.number().int().min(1).max(100).optional().describe("Saved searches per page, 1 to 100 (default 25)"),
-        },
-    }, async ({ offset, limit }) => {
-        try {
-            const res = await api.get("/private-equity/saved-searches", { offset, limit });
-            return text(res);
-        }
-        catch (e) {
-            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
-        }
-    });
-    server.registerTool("lighthouse_private_equity_list_saved_search_results", {
-        title: "List Private Equity Saved Search Results",
-        annotations: READ_ONLY,
-        description: "Read one page of the companies a Private Equity saved search's LAST run stored, in the order that run returned them. " +
-            "Each row is a stored company: id, name, domain, website_url, linkedin_url, short_description, avatar_url, hq ({ country, country_code, region, city }) and hq_label, industry, category, sector, naics ({ code, label }), business_models, employees and revenue_usd ({ value, estimated }), founded_year, company_type, num_locations, crm_id (the id of this workspace's CRM company for it, or null), lighthouse_company (the matching company in Lighthouse's own data, or null), from_lighthouse (the keys whose value was filled from Lighthouse's own data), fetched_at, profile_updated_at, and match ({ snippets, headline }: why a keyword or product search matched it, or null). " +
-            "meta carries total, limit, offset, has_more, has_results and run (the stored run the page is read from). A search that never ran, or whose last run is no longer stored, answers an empty page with meta.has_results false. " +
-            "READ ONLY: the rows are exactly what the search stored when someone last ran it in the app, even if its filters were edited since. This never runs the search again, never fetches more companies and never spends credits; for newer results, ask the user to run the search in the Lighthouse app. " +
-            "WHEN TO USE: the user asks what a Private Equity search found. Page with offset while meta.has_more is true. For one company's full stored profile use lighthouse_private_equity_get_company; when crm_id is set, lighthouse_crm_get_record (record_type 'company') opens the CRM company. " +
-            "Not found when the saved search does not exist or the user cannot see it.",
-        inputSchema: {
-            search_id: z.string().uuid().describe("Private Equity saved search ID (from lighthouse_private_equity_list_saved_searches)"),
-            offset: z.number().int().min(0).optional().describe("Number of companies to skip (default 0)"),
-            limit: z.number().int().min(1).max(100).optional().describe("Companies per page, 1 to 100 (default 25)"),
-        },
-    }, async ({ search_id, offset, limit }) => {
-        try {
-            const res = await api.get(`/private-equity/saved-searches/${encodeURIComponent(search_id)}/results`, { offset, limit });
-            return text(res);
-        }
-        catch (e) {
-            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
-        }
-    });
-    server.registerTool("lighthouse_private_equity_get_company", {
-        title: "Get Private Equity Company",
-        annotations: READ_ONLY,
-        description: "Read one company's stored Private Equity profile by company_id: the id of a row returned by lighthouse_private_equity_list_saved_search_results (a text id, not a UUID, and not a Discovery or CRM id). " +
-            "Returns the keys of a results row (without match) plus the full profile: legal_names, commercial_names, long_description, long_description_extracted, locations, classification ({ naics_secondary, nace, sic, isic }), target_markets, core_offerings, technology_focus, certification_focus, supply_chain_focus, business_tags, technologies and technologies_total, contact ({ primary_phone, phone_numbers, primary_email, emails }), socials, website_language, profile_created_at, is_fresh and run_count. " +
-            "READ ONLY: the profile as a Private Equity search of this workspace stored it, never refreshed. It never fetches the company again and never spends credits. " +
-            "WHEN TO USE: the user asks for details on one company from a Private Equity search's results. When crm_id is set, lighthouse_crm_get_record (record_type 'company') opens the CRM company. " +
-            "Not found when none of this workspace's Private Equity searches returned that company.",
-        inputSchema: {
-            company_id: z.string().min(1).describe("The company's id, as a row of lighthouse_private_equity_list_saved_search_results gives it"),
-        },
-    }, async ({ company_id }) => {
-        try {
-            const res = await api.get(`/private-equity/companies/${encodeURIComponent(company_id)}`);
-            return text(res);
-        }
-        catch (e) {
-            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
-        }
-    });
     return server;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trylighthouse/mcp-server",
-  "version": "0.2.17",
+  "version": "0.2.20",
   "description": "MCP server for the Lighthouse CRM API",
   "homepage": "https://trylighthouse.vc",
   "type": "module",