@sellable/mcp 0.1.0

package/dist/tools/senders.d.ts

@@ -0,0 +1,44 @@
+export type SenderListItem = {
+    id: string;
+    unipileAccountId: string;
+    timeZone: string;
+    displayName: string;
+    linkedinProfileUrl: string | null;
+};
+export type ListSendersResponse = {
+    senders: SenderListItem[];
+};
+export type GetSenderInput = {
+    senderId: string;
+};
+export type SenderDetailResponse = {
+    sender: any;
+};
+export declare const senderToolDefinitions: ({
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            senderId?: undefined;
+        };
+        required: never[];
+        additionalProperties: boolean;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            senderId: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+})[];
+export declare function listSenders(): Promise<ListSendersResponse>;
+export declare function getSender(input: GetSenderInput): Promise<SenderDetailResponse>;

package/dist/tools/senders.js

@@ -0,0 +1,69 @@
+import { getApi } from "../api.js";
+function pickString(...values) {
+    for (const value of values) {
+        if (typeof value !== "string")
+            continue;
+        const trimmed = value.trim();
+        if (trimmed)
+            return trimmed;
+    }
+    return null;
+}
+function computeDisplayName(sender) {
+    const profile = sender?.unipileAccount?.profileData;
+    const name = pickString(profile?.name);
+    if (name)
+        return name;
+    const first = pickString(profile?.first_name, profile?.firstName);
+    const last = pickString(profile?.last_name, profile?.lastName);
+    const full = [first, last].filter(Boolean).join(" ").trim();
+    if (full)
+        return full;
+    return `Sender ${String(sender?.id ?? "").slice(0, 8) || "unknown"}`;
+}
+function computeLinkedinProfileUrl(sender) {
+    const profile = sender?.unipileAccount?.profileData;
+    return (pickString(profile?.linkedinProfileUrl, profile?.linkedin_url, profile?.publicProfileUrl) || null);
+}
+export const senderToolDefinitions = [
+    {
+        name: "list_senders",
+        description: "List outbound sender identities available in the active workspace. Use this instead of asking for a LinkedIn URL.",
+        inputSchema: {
+            type: "object",
+            properties: {},
+            required: [],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "get_sender",
+        description: "Get a specific outbound sender identity by senderId (workspace-scoped).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                senderId: { type: "string", description: "Outbound sender ID" },
+            },
+            required: ["senderId"],
+            additionalProperties: false,
+        },
+    },
+];
+export async function listSenders() {
+    const api = getApi();
+    const senders = await api.get("/api/v1/outbound-sender-identities");
+    return {
+        senders: (senders || []).map((s) => ({
+            id: String(s?.id || ""),
+            unipileAccountId: String(s?.unipileAccountId || ""),
+            timeZone: String(s?.timeZone || ""),
+            displayName: computeDisplayName(s),
+            linkedinProfileUrl: computeLinkedinProfileUrl(s),
+        })),
+    };
+}
+export async function getSender(input) {
+    const api = getApi();
+    const sender = await api.get(`/api/v1/outbound-sender-identities/${encodeURIComponent(input.senderId)}`);
+    return { sender };
+}

package/dist/tools/sequencer.d.ts

@@ -0,0 +1,127 @@
+export type CreateWorkflowTableInput = {
+    name: string;
+    senderId: string;
+    clientProspectId?: string;
+    sequenceActions?: string[];
+};
+export type CreateWorkflowTableResponse = {
+    tableId: string;
+    campaignOfferId: string;
+    tableName: string;
+    columns: Array<{
+        key: string;
+        name: string;
+        columnType: string;
+    }>;
+    requirements: Record<string, unknown>;
+    created: boolean;
+};
+export type AttachSequenceInput = {
+    tableId: string;
+    template: Record<string, unknown>;
+    confirmed?: boolean;
+};
+export type AttachSequenceResponse = {
+    success: boolean;
+    version: number;
+    _perf?: Record<string, number>;
+};
+export type AttachRecommendedSequenceInput = {
+    campaignId: string;
+    confirmed?: boolean;
+};
+export type AttachRecommendedSequenceResponse = {
+    success: boolean;
+    version: number;
+    template?: {
+        name?: string;
+        entryNodeId?: string;
+        nodes?: Array<Record<string, unknown>>;
+    };
+    _perf?: Record<string, number>;
+};
+export declare const sequencerToolDefinitions: ({
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            name: {
+                type: string;
+                description: string;
+            };
+            senderId: {
+                type: string;
+                description: string;
+            };
+            clientProspectId: {
+                type: string;
+                description: string;
+            };
+            sequenceActions: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+            tableId?: undefined;
+            template?: undefined;
+            confirmed?: undefined;
+            campaignId?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            tableId: {
+                type: string;
+                description: string;
+            };
+            template: {
+                type: string;
+                description: string;
+            };
+            confirmed: {
+                type: string;
+                description: string;
+            };
+            name?: undefined;
+            senderId?: undefined;
+            clientProspectId?: undefined;
+            sequenceActions?: undefined;
+            campaignId?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            campaignId: {
+                type: string;
+                description: string;
+            };
+            confirmed: {
+                type: string;
+                description: string;
+            };
+            name?: undefined;
+            senderId?: undefined;
+            clientProspectId?: undefined;
+            sequenceActions?: undefined;
+            tableId?: undefined;
+            template?: undefined;
+        };
+        required: string[];
+    };
+})[];
+export declare function createWorkflowTable(input: CreateWorkflowTableInput): Promise<CreateWorkflowTableResponse>;
+export declare function attachSequence(input: AttachSequenceInput): Promise<AttachSequenceResponse>;
+export declare function attachRecommendedSequence(input: AttachRecommendedSequenceInput): Promise<AttachRecommendedSequenceResponse>;

package/dist/tools/sequencer.js

@@ -0,0 +1,194 @@
+import { getApi, SellableApiError } from "../api.js";
+export const sequencerToolDefinitions = [
+    {
+        name: "create_workflow_table",
+        description: "Create a campaign-backed workflow table with a lightweight CampaignOffer shell and minimal config columns optionally derived from sequence action types. " +
+            "Returns tableId, campaignOfferId, column list, and derived requirements.\n\n" +
+            "All tables include LinkedIn URL, Name, and Approved. " +
+            "Additional columns depend on the planned actions: INVITE/DM -> Message, " +
+            "INMAIL_* -> Subject + Message, COMMENT -> Post URL + Comment + Reaction Type. " +
+            "Campaign brief, rubrics, positioning, and prospect linkage remain optional follow-on metadata.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: {
+                    type: "string",
+                    description: "Campaign or table name (1-200 chars)",
+                },
+                senderId: {
+                    type: "string",
+                    description: "Outbound sender ID (from list_senders)",
+                },
+                clientProspectId: {
+                    type: "string",
+                    description: "Optional client prospect ID (from enrich_sender)",
+                },
+                sequenceActions: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Optional action types: INVITE, DM, INMAIL_OPEN, INMAIL_CLOSED, VIEW_PROFILE, COMMENT",
+                },
+            },
+            required: ["name", "senderId"],
+        },
+    },
+    {
+        name: "attach_sequence",
+        description: "Attach a sequence template to an existing workflow table. " +
+            "This works for direct campaign tables and for type-agnostic tables created with create_workflow_table. " +
+            "The tool pre-validates template structure and surfaces 409 conflicts clearly when sequence columns already exist.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                tableId: {
+                    type: "string",
+                    description: "Workflow table ID from create_workflow_table or list_tables",
+                },
+                template: {
+                    type: "object",
+                    description: "Sequence template object with version, entryNodeId, nodes, and branches",
+                },
+                confirmed: {
+                    type: "boolean",
+                    description: "Set true to overwrite existing sequence columns if the table already has them",
+                },
+            },
+            required: ["tableId", "template"],
+        },
+    },
+    {
+        name: "attach_recommended_sequence",
+        description: "Attach the tier-recommended sequence template to a campaign. " +
+            "Delegates template selection to the backend's existing tier-aware selector " +
+            "(selectTemplateForTiers), which picks `If Open Profile -> INMAIL_OPEN, else INVITE` " +
+            "for premium/Sales Nav senders and `INVITE -> accepted -> DM` otherwise. " +
+            "Prefer this over attach_sequence during the create-campaign-v2 autonomous tail — " +
+            "it removes the risk of hand-authoring an invalid template mid-long-context. " +
+            "Use attach_sequence directly only when the caller needs a custom non-recommended cadence.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                campaignId: {
+                    type: "string",
+                    description: "CampaignOffer ID from create_campaign",
+                },
+                confirmed: {
+                    type: "boolean",
+                    description: "Set true to overwrite existing sequence columns if the campaign already has a sequence attached",
+                },
+            },
+            required: ["campaignId"],
+        },
+    },
+];
+export async function createWorkflowTable(input) {
+    const api = getApi();
+    return api.post("/api/v3/sequencer-tables", {
+        name: input.name,
+        senderId: input.senderId,
+        clientProspectId: input.clientProspectId,
+        ...(input.sequenceActions
+            ? { sequenceActions: input.sequenceActions }
+            : {}),
+    });
+}
+export async function attachSequence(input) {
+    const api = getApi();
+    const template = input.template;
+    const preValidationErrors = [];
+    if (!Array.isArray(template.nodes) || template.nodes.length === 0) {
+        preValidationErrors.push("Template must have a non-empty 'nodes' array.");
+    }
+    if (typeof template.entryNodeId !== "string" ||
+        template.entryNodeId.trim().length === 0) {
+        preValidationErrors.push("Template must have an 'entryNodeId' string.");
+    }
+    if (template.version !== 2) {
+        preValidationErrors.push("Template version must be 2.");
+    }
+    if (Array.isArray(template.nodes) &&
+        typeof template.entryNodeId === "string") {
+        const nodeIds = new Set(template.nodes
+            .map((node) => node && typeof node === "object"
+            ? node.id
+            : null)
+            .filter((nodeId) => typeof nodeId === "string"));
+        if (template.entryNodeId && !nodeIds.has(template.entryNodeId)) {
+            preValidationErrors.push(`entryNodeId "${template.entryNodeId}" does not match any node id. Available node ids: ${Array.from(nodeIds).join(", ")}`);
+        }
+    }
+    if (preValidationErrors.length > 0) {
+        throw new Error("INVALID_TEMPLATE: Template has structural issues:\n" +
+            preValidationErrors.map((issue) => `  - ${issue}`).join("\n") +
+            "\n\nFix these issues and retry.");
+    }
+    // Campaign-backed tables route to the campaigns endpoint so the MCP
+    // tool persists the sequence to the same place the UI does
+    // (`CampaignOffer.sequenceTemplate`). The workflow-tables endpoint
+    // writes to `WorkflowTable.config.sequenceTemplate`, which the UI
+    // doesn't read — hitting it on a campaign table is silently wrong.
+    let campaignOfferId = null;
+    try {
+        const tableMeta = await api.get(`/api/v3/workflow-tables/${input.tableId}?mode=meta`);
+        const rawCampaignId = tableMeta?.table?.config?.campaignOfferId;
+        if (typeof rawCampaignId === "string" && rawCampaignId.length > 0) {
+            campaignOfferId = rawCampaignId;
+        }
+    }
+    catch {
+        // Fall back to workflow-tables path on meta-fetch failure —
+        // non-campaign tables won't have the field set anyway.
+    }
+    const endpoint = campaignOfferId
+        ? `/api/v3/campaigns/${campaignOfferId}/sequence`
+        : `/api/v3/workflow-tables/${input.tableId}/sequence`;
+    try {
+        return await api.put(endpoint, {
+            template: input.template,
+            confirmed: input.confirmed,
+        });
+    }
+    catch (error) {
+        if (error instanceof SellableApiError && error.status === 409) {
+            let columnInfo = "";
+            try {
+                const responseBody = JSON.parse(error.body);
+                if (typeof responseBody?.details?.columnCount === "number") {
+                    columnInfo = ` (${responseBody.details.columnCount} existing columns)`;
+                }
+            }
+            catch {
+                // Best effort only.
+            }
+            throw new Error(`SEQUENCE_EXISTS: This table already has sequence columns${columnInfo}. ` +
+                "Call attach_sequence again with confirmed: true to replace the existing sequence, or use a different table.");
+        }
+        throw error;
+    }
+}
+export async function attachRecommendedSequence(input) {
+    const api = getApi();
+    try {
+        return await api.put(`/api/v3/campaigns/${input.campaignId}/sequence`, {
+            autoSelectFromSenders: true,
+            confirmed: input.confirmed,
+        });
+    }
+    catch (error) {
+        if (error instanceof SellableApiError && error.status === 409) {
+            let columnInfo = "";
+            try {
+                const responseBody = JSON.parse(error.body);
+                if (typeof responseBody?.details?.columnCount === "number") {
+                    columnInfo = ` (${responseBody.details.columnCount} existing columns)`;
+                }
+            }
+            catch {
+                // Best effort only.
+            }
+            throw new Error(`SEQUENCE_EXISTS: This campaign already has a sequence attached${columnInfo}. ` +
+                "Call attach_recommended_sequence again with confirmed: true to replace, or inspect the existing sequence via get_campaign.");
+        }
+        throw error;
+    }
+}

package/dist/tools/tables.d.ts

@@ -0,0 +1,35 @@
+export interface WorkflowTableListItem {
+    id: string;
+    name: string;
+    type: string | null;
+    campaignOfferId: string | null;
+    campaignBacked: boolean;
+    hasSequence: boolean;
+    columns: number;
+    rows: number;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ListTablesInput {
+    limit?: number;
+    hasSequence?: boolean;
+}
+export declare const tableToolDefinitions: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            limit: {
+                type: string;
+                description: string;
+            };
+            hasSequence: {
+                type: string;
+                description: string;
+            };
+        };
+        required: never[];
+    };
+}[];
+export declare function listTables(input: ListTablesInput): Promise<WorkflowTableListItem[]>;

package/dist/tools/tables.js

@@ -0,0 +1,36 @@
+import { getApi } from "../api.js";
+export const tableToolDefinitions = [
+    {
+        name: "list_tables",
+        description: "List all workflow tables in the active workspace. Returns metadata including whether each table is campaign-backed and whether it has a sequence attached.\n\n" +
+            "Unlike get_campaigns, this lists every WorkflowTable regardless of how it was created, including create_workflow_table, create_on_demand_table, and UI-created tables.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                limit: {
+                    type: "number",
+                    description: "Number of tables to return (default 50, max 200)",
+                },
+                hasSequence: {
+                    type: "boolean",
+                    description: "Optional filter: true for sequence tables only, false for tables without sequences",
+                },
+            },
+            required: [],
+        },
+    },
+];
+export async function listTables(input) {
+    const api = getApi();
+    const params = new URLSearchParams();
+    if (input.limit) {
+        params.set("limit", String(input.limit));
+    }
+    if (input.hasSequence !== undefined) {
+        params.set("hasSequence", String(input.hasSequence));
+    }
+    const queryString = params.toString();
+    const path = `/api/v3/mcp/tables${queryString ? `?${queryString}` : ""}`;
+    const result = await api.get(path);
+    return result.tables;
+}

package/dist/tools/verify-row.d.ts

@@ -0,0 +1,36 @@
+export type VerifyTableRowInput = {
+    tableId: string;
+    rowId: string;
+    skipColumnIds?: string[];
+    forceRerun?: boolean;
+};
+export declare const verifyRowToolDefinitions: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            tableId: {
+                type: string;
+                description: string;
+            };
+            rowId: {
+                type: string;
+                description: string;
+            };
+            skipColumnIds: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+            forceRerun: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+}[];
+export declare function handleVerifyTableRow(input: VerifyTableRowInput): Promise<any>;

package/dist/tools/verify-row.js

@@ -0,0 +1,38 @@
+import { getApi } from "../api.js";
+export const verifyRowToolDefinitions = [
+    {
+        name: "verify_table_row",
+        description: "Run one workflow-table row through orchestrator-path columns and report per-column status. Sweeper-path sequence columns are reported as deferred_to_sweeper and are never executed by this tool.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                tableId: {
+                    type: "string",
+                    description: "Workflow table ID",
+                },
+                rowId: {
+                    type: "string",
+                    description: "Workflow table row ID to verify",
+                },
+                skipColumnIds: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Column IDs the caller intentionally wants to skip. No implicit skip heuristics are applied.",
+                },
+                forceRerun: {
+                    type: "boolean",
+                    description: "Defaults true. Bypasses cached/completed cells so verification actually re-executes.",
+                },
+            },
+            required: ["tableId", "rowId"],
+        },
+    },
+];
+export async function handleVerifyTableRow(input) {
+    const api = getApi();
+    return api.post(`/api/v3/workflow-tables/${input.tableId}/verify-row`, {
+        rowId: input.rowId,
+        skipColumnIds: input.skipColumnIds || [],
+        forceRerun: input.forceRerun ?? true,
+    });
+}