@sellable/mcp 0.1.0

package/dist/tools/one-off.js

@@ -0,0 +1,273 @@
+import { getApi } from "../api.js";
+const SIMPLE_LINEAR_TEMPLATE = {
+    version: 2,
+    name: "Simple Linear Sequence",
+    description: "Basic connection request followed by DM",
+    entryNodeId: "send_invite",
+    nodes: [
+        {
+            id: "send_invite",
+            type: "action",
+            actionType: "INVITE",
+            waitForEvent: {
+                event: "connection_accept",
+                timeoutDays: 7,
+            },
+            position: { x: 400, y: 50 },
+        },
+        {
+            id: "send_dm",
+            type: "action",
+            actionType: "DM",
+            waitForEvent: {
+                event: "reply",
+                timeoutDays: 5,
+            },
+            position: { x: 400, y: 210 },
+        },
+    ],
+    branches: [
+        {
+            id: "b1",
+            fromNodeId: "send_invite",
+            condition: "accepted",
+            toNodeId: "send_dm",
+        },
+    ],
+};
+export const onDemandToolDefinitions = [
+    {
+        name: "create_on_demand_table",
+        description: "Create an on-demand campaign table backed by a lightweight CampaignOffer. Returns tableId + campaignOfferId.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: {
+                    type: "string",
+                    description: "Table name",
+                },
+                senderIds: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Optional sender IDs to attach to table config",
+                },
+                clientProspectId: {
+                    type: "string",
+                    description: "Client prospect ID for CampaignOffer (use enrich_sender to obtain it)",
+                },
+                offerPositioning: {
+                    type: "object",
+                    description: "Optional offer positioning JSON for CampaignOffer",
+                },
+                campaignBrief: {
+                    description: "Optional campaign brief content (markdown or JSON)",
+                },
+            },
+            required: ["name", "clientProspectId"],
+        },
+    },
+    {
+        name: "create_on_demand_campaign",
+        description: "Create a lightweight CampaignOffer + workflow table, set senders, and initialize sequence columns. Auto-selects template by sender tiers unless provided.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: {
+                    type: "string",
+                    description: "Campaign name",
+                },
+                clientProspectId: {
+                    type: "string",
+                    description: "Client prospect ID from enrich_sender",
+                },
+                senderIds: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Outbound sender IDs to attach before sequence init",
+                },
+                campaignBrief: {
+                    description: "Optional campaign brief content (markdown or JSON)",
+                },
+                offerPositioning: {
+                    type: "object",
+                    description: "Optional offer positioning JSON for CampaignOffer",
+                },
+                sequenceTemplate: {
+                    type: "object",
+                    description: "Optional sequence template override (otherwise auto-selected by sender tiers)",
+                },
+                confirmed: {
+                    type: "boolean",
+                    description: "Set true to overwrite existing sequence columns",
+                },
+            },
+            required: ["name", "clientProspectId", "senderIds"],
+        },
+    },
+    {
+        name: "add_on_demand_leads",
+        description: "Add leads to an on-demand campaign table by LinkedIn URL (dedupes by default).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                tableId: {
+                    type: "string",
+                    description: "Workflow table ID",
+                },
+                leads: {
+                    type: "array",
+                    description: "Lead entries with LinkedIn URLs",
+                    items: {
+                        type: "object",
+                        properties: {
+                            linkedinUrl: { type: "string" },
+                            name: { type: "string" },
+                            title: { type: "string" },
+                            companyWebsite: { type: "string" },
+                            location: { type: "string" },
+                        },
+                        required: ["linkedinUrl"],
+                    },
+                },
+                skipDuplicates: {
+                    type: "boolean",
+                    description: "Skip leads already in table (default true)",
+                },
+            },
+            required: ["tableId", "leads"],
+        },
+    },
+    {
+        name: "start_on_demand_campaign",
+        description: "Start an on-demand campaign table (set campaignStatus ACTIVE).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                tableId: { type: "string" },
+            },
+            required: ["tableId"],
+        },
+    },
+    {
+        name: "pause_on_demand_campaign",
+        description: "Pause an on-demand campaign table (set campaignStatus PAUSED).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                tableId: { type: "string" },
+            },
+            required: ["tableId"],
+        },
+    },
+    {
+        name: "init_on_demand_sequence",
+        description: "Initialize sequence columns for an on-demand table. Uses a default template if none provided.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                tableId: { type: "string" },
+                template: {
+                    type: "object",
+                    description: "Optional sequence template object",
+                },
+                confirmed: {
+                    type: "boolean",
+                    description: "Set true to overwrite existing sequence columns",
+                },
+            },
+            required: ["tableId"],
+        },
+    },
+];
+export async function createOnDemandTable(input) {
+    const api = getApi();
+    return api.post("/api/v3/on-demand-campaigns", input);
+}
+export async function addOnDemandLeads(input) {
+    const api = getApi();
+    const { tableId, leads, skipDuplicates } = input;
+    return api.post(`/api/v3/on-demand-campaigns/${tableId}/leads`, {
+        leads,
+        skipDuplicates,
+    });
+}
+export async function startOnDemandCampaign(input) {
+    const api = getApi();
+    return api.post(`/api/v3/on-demand-campaigns/${input.tableId}/start`, {});
+}
+export async function pauseOnDemandCampaign(input) {
+    const api = getApi();
+    return api.post(`/api/v3/on-demand-campaigns/${input.tableId}/pause`, {});
+}
+export async function initOnDemandSequence(input) {
+    const api = getApi();
+    const { tableId, template, confirmed } = input;
+    return api.put(`/api/v3/workflow-tables/${tableId}/sequence`, {
+        template: template || SIMPLE_LINEAR_TEMPLATE,
+        confirmed,
+    });
+}
+async function initCampaignSequence(input) {
+    const api = getApi();
+    const payload = {};
+    if (input.template)
+        payload.template = input.template;
+    if (input.autoSelectFromSenders !== undefined) {
+        payload.autoSelectFromSenders = input.autoSelectFromSenders;
+    }
+    if (input.confirmed !== undefined) {
+        payload.confirmed = input.confirmed;
+    }
+    return api.put(`/api/v3/campaigns/${input.campaignOfferId}/sequence`, payload);
+}
+export async function createOnDemandCampaign(input) {
+    if (!Array.isArray(input.senderIds) || input.senderIds.length === 0) {
+        throw new Error("senderIds must be a non-empty array");
+    }
+    const campaign = await createOnDemandTable({
+        name: input.name,
+        senderIds: input.senderIds,
+        clientProspectId: input.clientProspectId,
+        offerPositioning: input.offerPositioning,
+        campaignBrief: input.campaignBrief,
+    });
+    const campaignOfferId = campaign.campaignOfferId;
+    const tableId = campaign.tableId;
+    if (!campaignOfferId || !tableId) {
+        throw new Error("create_on_demand_table did not return campaignOfferId/tableId");
+    }
+    const confirmed = input.confirmed !== undefined ? input.confirmed : false;
+    const autoSelectFromSenders = !input.sequenceTemplate;
+    try {
+        await initCampaignSequence({
+            campaignOfferId,
+            template: input.sequenceTemplate,
+            autoSelectFromSenders,
+            confirmed,
+        });
+    }
+    catch (error) {
+        if (!confirmed && error instanceof Error) {
+            if (error.message.includes("API error 409")) {
+                await initCampaignSequence({
+                    campaignOfferId,
+                    template: input.sequenceTemplate,
+                    autoSelectFromSenders,
+                    confirmed: true,
+                });
+            }
+            else {
+                throw error;
+            }
+        }
+        else {
+            throw error;
+        }
+    }
+    return {
+        tableId,
+        campaignOfferId,
+        senderIds: input.senderIds,
+        sequenceInitialized: true,
+    };
+}

package/dist/tools/processing.d.ts

@@ -0,0 +1,70 @@
+export type RubricItem = {
+    id?: string;
+    description?: string;
+    reason?: string;
+    criterion?: string;
+    checkName?: string;
+    useCheckForScoring?: boolean;
+    isRequiredCheck?: boolean;
+    allowPartialCredit?: boolean;
+    strictMatching?: boolean;
+};
+export type UpsertRubricInput = {
+    campaignOfferId: string;
+    rubric: RubricItem[];
+    currentStep?: string | null;
+    enableICPFilters?: boolean;
+    deletedRubricIds?: string[];
+};
+export declare const processingToolDefinitions: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            campaignOfferId: {
+                type: string;
+                description: string;
+            };
+            rubric: {
+                type: string;
+                description: string;
+                items: {
+                    type: string;
+                };
+            };
+            currentStep: {
+                type: string[];
+                description: string;
+            };
+            enableICPFilters: {
+                type: string;
+                description: string;
+            };
+            deletedRubricIds: {
+                type: string;
+                description: string;
+                items: {
+                    type: string;
+                };
+            };
+        };
+        required: string[];
+    };
+}[];
+export declare function upsertRubric(input: UpsertRubricInput): Promise<{
+    leadScoringRubrics?: RubricItem[];
+}>;
+export type CampaignRubricsResponse = {
+    campaignOfferId: string;
+    enableICPFilters: boolean | null;
+    workflowTableId: string | null;
+    rubrics: RubricItem[];
+};
+export declare function fetchCampaignRubrics(campaignOfferId: string): Promise<CampaignRubricsResponse>;
+export type UpsertRubricV3Input = {
+    campaignOfferId: string;
+    upsert: RubricItem[];
+    deleteIds?: string[];
+};
+export declare function upsertRubricV3(input: UpsertRubricV3Input): Promise<CampaignRubricsResponse>;

package/dist/tools/processing.js

@@ -0,0 +1,56 @@
+import { getApi } from "../api.js";
+export const processingToolDefinitions = [
+    {
+        name: "upsert_rubric",
+        description: "Upsert lead scoring rubrics for a campaign offer. Pass the full rubric array. Optionally enable ICP filters or delete rubric IDs.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                campaignOfferId: {
+                    type: "string",
+                    description: "Campaign offer ID",
+                },
+                rubric: {
+                    type: "array",
+                    description: "Rubric items to upsert",
+                    items: { type: "object" },
+                },
+                currentStep: {
+                    type: ["string", "null"],
+                    description: "Headless workflow step ID",
+                },
+                enableICPFilters: {
+                    type: "boolean",
+                    description: "Enable ICP filtering after rubric save (triggers table sync)",
+                },
+                deletedRubricIds: {
+                    type: "array",
+                    description: "Rubric IDs to delete from the campaign (optional cleanup)",
+                    items: { type: "string" },
+                },
+            },
+            required: ["campaignOfferId", "rubric"],
+        },
+    },
+];
+export async function upsertRubric(input) {
+    const api = getApi();
+    const { campaignOfferId, rubric, currentStep, enableICPFilters, deletedRubricIds, } = input;
+    return api.put(`/api/v2/campaign-offers/${campaignOfferId}`, {
+        rubric,
+        currentStep,
+        enableICPFilters,
+        deletedRubricIds,
+    });
+}
+export async function fetchCampaignRubrics(campaignOfferId) {
+    const api = getApi();
+    return api.get(`/api/v3/campaigns/${campaignOfferId}/rubrics`);
+}
+export async function upsertRubricV3(input) {
+    const api = getApi();
+    return api.post(`/api/v3/campaigns/${input.campaignOfferId}/rubrics`, {
+        upsert: input.upsert,
+        deleteIds: input.deleteIds,
+    });
+}

package/dist/tools/prompts.d.ts

@@ -0,0 +1,211 @@
+/**
+ * Response from the edit-message prompt endpoint.
+ * The prompt contains all 11 quality gates inline.
+ */
+export interface PromptResponse {
+    prompt: string;
+    metadata: {
+        framework: string;
+        author: string;
+        description: string;
+    };
+}
+export interface SubskillPromptResponse {
+    name: string;
+    description: string;
+    visibility: "public" | "internal";
+    prompt: string;
+    promptLength?: number;
+    offset?: number;
+    limit?: number;
+    hasMore?: boolean;
+    nextOffset?: number | null;
+}
+export interface ListSubskillPromptsResponse {
+    total: number;
+    matches: Array<{
+        name: string;
+        description: string;
+        visibility: "public" | "internal";
+    }>;
+}
+export interface SearchSubskillPromptsResponse {
+    query: string;
+    matches: Array<{
+        name: string;
+        description: string;
+        visibility: "public" | "internal";
+    }>;
+}
+export interface CompleteSenderResearchInput {
+    depth?: "minimal-verification" | "deep-proof";
+    proofItemsFound?: number;
+    caseStudyItemsFound?: number;
+    credibilitySignalsFound?: number;
+    notes?: string;
+}
+export declare const promptToolDefinitions: ({
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            limit?: undefined;
+            includePublic?: undefined;
+            includeInternal?: undefined;
+            subskillName?: undefined;
+            offset?: undefined;
+            query?: undefined;
+            depth?: undefined;
+            proofItemsFound?: undefined;
+            caseStudyItemsFound?: undefined;
+            credibilitySignalsFound?: undefined;
+            notes?: undefined;
+        };
+        required: never[];
+        additionalProperties?: undefined;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            limit: {
+                type: string;
+                description: string;
+            };
+            includePublic: {
+                type: string;
+                description: string;
+            };
+            includeInternal: {
+                type: string;
+                description: string;
+            };
+            subskillName?: undefined;
+            offset?: undefined;
+            query?: undefined;
+            depth?: undefined;
+            proofItemsFound?: undefined;
+            caseStudyItemsFound?: undefined;
+            credibilitySignalsFound?: undefined;
+            notes?: undefined;
+        };
+        required: never[];
+        additionalProperties: boolean;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            subskillName: {
+                type: string;
+                description: string;
+            };
+            offset: {
+                type: string;
+                description: string;
+            };
+            limit: {
+                type: string;
+                description: string;
+            };
+            includePublic?: undefined;
+            includeInternal?: undefined;
+            query?: undefined;
+            depth?: undefined;
+            proofItemsFound?: undefined;
+            caseStudyItemsFound?: undefined;
+            credibilitySignalsFound?: undefined;
+            notes?: undefined;
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            query: {
+                type: string;
+                description: string;
+            };
+            limit: {
+                type: string;
+                description: string;
+            };
+            includePublic: {
+                type: string;
+                description: string;
+            };
+            includeInternal: {
+                type: string;
+                description: string;
+            };
+            subskillName?: undefined;
+            offset?: undefined;
+            depth?: undefined;
+            proofItemsFound?: undefined;
+            caseStudyItemsFound?: undefined;
+            credibilitySignalsFound?: undefined;
+            notes?: undefined;
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            depth: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            proofItemsFound: {
+                type: string;
+                description: string;
+            };
+            caseStudyItemsFound: {
+                type: string;
+                description: string;
+            };
+            credibilitySignalsFound: {
+                type: string;
+                description: string;
+            };
+            notes: {
+                type: string;
+                description: string;
+            };
+            limit?: undefined;
+            includePublic?: undefined;
+            includeInternal?: undefined;
+            subskillName?: undefined;
+            offset?: undefined;
+            query?: undefined;
+        };
+        additionalProperties: boolean;
+        required?: undefined;
+    };
+})[];
+export declare function getMessagePrompt(): Promise<PromptResponse>;
+export declare function listSubskillPrompts(limit?: number, includePublic?: boolean, includeInternal?: boolean): ListSubskillPromptsResponse;
+export declare function getSubskillPrompt(subskillName: string, offset?: number, limit?: number): SubskillPromptResponse;
+export declare function completeSenderResearch(input?: CompleteSenderResearchInput): {
+    readonly completedAt: string;
+    readonly depth: "minimal-verification" | "deep-proof";
+    readonly proofItemsFound: number;
+    readonly caseStudyItemsFound: number;
+    readonly credibilitySignalsFound: number;
+    readonly notes?: string | null;
+    readonly ok: true;
+};
+export declare function searchSubskillPrompts(query: string, limit?: number, includePublic?: boolean, includeInternal?: boolean): SearchSubskillPromptsResponse;