@sellable/mcp 0.1.879 → 0.1.881

package/dist/tools/inbox.d.ts

@@ -45,6 +45,7 @@ export declare const inboxToolDefinitions: ({
                 type: string;
             };
             threadId?: undefined;
+            messageLimit?: undefined;
             versionId?: undefined;
             body?: undefined;
             approvedBody?: undefined;
@@ -69,6 +70,54 @@ export declare const inboxToolDefinitions: ({
         openWorldHint: boolean;
         idempotentHint?: undefined;
     };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            threadId: {
+                type: string;
+            };
+            messageLimit: {
+                type: string;
+                minimum: number;
+                maximum: number;
+                description: string;
+            };
+            limit?: undefined;
+            cursor?: undefined;
+            filter?: undefined;
+            status?: undefined;
+            senderId?: undefined;
+            classification?: undefined;
+            search?: undefined;
+            includeEnrichment?: undefined;
+            includeReplyEligibility?: undefined;
+            versionId?: undefined;
+            body?: undefined;
+            approvedBody?: undefined;
+            approvedBodyHash?: undefined;
+            approvedThreadSnapshot?: undefined;
+            idempotencyKey?: undefined;
+            approval?: undefined;
+            workspaceId?: undefined;
+            message?: undefined;
+            approvedMessageHash?: undefined;
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+    outputSchema: {
+        type: string;
+        additionalProperties: boolean;
+    };
+    annotations: {
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        openWorldHint: boolean;
+        idempotentHint?: undefined;
+    };
 } | {
     name: string;
     description: string;
@@ -87,6 +136,7 @@ export declare const inboxToolDefinitions: ({
             search?: undefined;
             includeEnrichment?: undefined;
             includeReplyEligibility?: undefined;
+            messageLimit?: undefined;
             versionId?: undefined;
             body?: undefined;
             approvedBody?: undefined;
@@ -135,6 +185,7 @@ export declare const inboxToolDefinitions: ({
             search?: undefined;
             includeEnrichment?: undefined;
             includeReplyEligibility?: undefined;
+            messageLimit?: undefined;
             approvedBody?: undefined;
             approvedBodyHash?: undefined;
             approvedThreadSnapshot?: undefined;
@@ -216,6 +267,7 @@ export declare const inboxToolDefinitions: ({
             search?: undefined;
             includeEnrichment?: undefined;
             includeReplyEligibility?: undefined;
+            messageLimit?: undefined;
             body?: undefined;
             message?: undefined;
             approvedMessageHash?: undefined;
@@ -289,6 +341,7 @@ export declare const inboxToolDefinitions: ({
             search?: undefined;
             includeEnrichment?: undefined;
             includeReplyEligibility?: undefined;
+            messageLimit?: undefined;
             versionId?: undefined;
             body?: undefined;
             approvedBody?: undefined;
@@ -309,7 +362,51 @@ export declare const inboxToolDefinitions: ({
     };
 })[];
 export declare function searchInboxThreads(input: Record<string, unknown>): Promise<ToolResult<{
+    ok: boolean;
+    error: string;
+    message: string;
+}> | ToolResult<{
     routeCalled: string;
+    threads: {
+        id: string | null;
+        leadName: string | null;
+        leadProfileUrl: string | null;
+        senderName: string | null;
+        senderProviderId: string | null;
+        chatType: string | null;
+        classification: string | null;
+        latestMessage: {
+            id: string | null;
+            direction: string | null;
+            timestamp: string | null;
+            preview: string | null;
+        } | null;
+        draft: {
+            id: string | null;
+            versionId: string | null;
+            status: string | null;
+            versionNumber: number | null;
+            createdAt: string | null;
+        } | null;
+        enrichment: Record<string, unknown> | null;
+        campaign: Record<string, unknown> | null;
+        latestMessageTimestamp: string | null;
+        updatedAt: string | null;
+        hasUnprocessedInbound: boolean | null;
+        lastInboundMessageAt: string | null;
+        followUpsSuppressed: boolean | null;
+        replyEligibility: {
+            canSendDraft: boolean | null;
+            canSendManual: boolean | null;
+            reasonCodes: (string | null)[];
+        } | null;
+    }[];
+    pagination: {} | null;
+    totalCount: {};
+    filters: {} | null;
+    status: {} | null;
+    filter: {} | null;
+    resultShape: string;
 }>>;
 export declare function getInboxThread(input: Record<string, unknown>): Promise<ToolResult<any>>;
 export declare function checkInboxReplyEligibility(input: Record<string, unknown>): Promise<ToolResult<any>>;

package/dist/tools/inbox.js

@@ -1,5 +1,8 @@
 import { createHash } from "node:crypto";
 import { getApi, SellableApiError } from "../api.js";
+const MAX_INBOX_TOOL_RESULT_BYTES = 128 * 1024;
+const MAX_INBOX_SEARCH_LIMIT = 25;
+const MAX_INBOX_DETAIL_MESSAGES = 50;
 const snapshotSchema = {
     type: "object",
     properties: {
@@ -17,11 +20,15 @@ const resultOutputSchema = {
 export const inboxToolDefinitions = [
     {
         name: "search_inbox_threads",
-        description: "Search LinkedIn inbox threads using the existing Sellable product inbox route. This calls GET /api/v3/inbox and returns thread summaries for the active workspace.",
+        description: "Search LinkedIn inbox threads using the existing Sellable product inbox route. Returns bounded compact summaries for the active workspace; use get_inbox_thread only for a relevant thread.",
         inputSchema: {
             type: "object",
             properties: {
-                limit: { type: "number", minimum: 1, maximum: 50 },
+                limit: {
+                    type: "number",
+                    minimum: 1,
+                    maximum: MAX_INBOX_SEARCH_LIMIT,
+                },
                 cursor: { type: "string" },
                 filter: { type: "string", enum: ["all", "drafts"] },
                 status: {
@@ -46,11 +53,17 @@ export const inboxToolDefinitions = [
     },
     {
         name: "get_inbox_thread",
-        description: "Fetch one LinkedIn inbox thread using the existing Sellable product route GET /api/v3/inbox/[threadId]. Returns the product payload plus a chronological transcript for MCP review.",
+        description: "Fetch one LinkedIn inbox thread using the existing Sellable product route GET /api/v3/inbox/[threadId]. Returns bounded thread detail plus a recent chronological transcript for MCP review.",
         inputSchema: {
             type: "object",
             properties: {
                 threadId: { type: "string" },
+                messageLimit: {
+                    type: "number",
+                    minimum: 1,
+                    maximum: MAX_INBOX_DETAIL_MESSAGES,
+                    description: "Maximum recent messages to return in chronological order (default 25, max 50).",
+                },
             },
             required: ["threadId"],
             additionalProperties: false,
@@ -187,6 +200,145 @@ function textResult(structuredContent, text, isError = false) {
 function errorResult(error, message, extra = {}) {
     return textResult({ ok: false, error, message, ...extra }, message, true);
 }
+function utf8Bytes(value) {
+    return Buffer.byteLength(JSON.stringify(value), "utf8");
+}
+function boundedString(value, maxChars) {
+    if (typeof value !== "string")
+        return null;
+    return value.length <= maxChars
+        ? value
+        : `${value.slice(0, Math.max(0, maxChars - 1))}…`;
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function compactRecord(value, fields) {
+    const source = asRecord(value);
+    if (!source)
+        return null;
+    const result = {};
+    for (const [field, maxChars] of fields) {
+        const fieldValue = source[field];
+        if (typeof fieldValue === "string") {
+            result[field] = boundedString(fieldValue, maxChars);
+        }
+        else if (typeof fieldValue === "number" ||
+            typeof fieldValue === "boolean" ||
+            fieldValue === null) {
+            result[field] = fieldValue;
+        }
+    }
+    return Object.keys(result).length > 0 ? result : null;
+}
+function compactThreadSummary(value) {
+    const thread = asRecord(value) ?? {};
+    const messages = Array.isArray(thread.messages) ? thread.messages : [];
+    const latestMessage = asRecord(messages[0]);
+    const draft = asRecord(thread.draft);
+    const replyEligibility = asRecord(thread.replyEligibility);
+    return {
+        id: boundedString(thread.id, 256),
+        leadName: boundedString(thread.leadName, 256),
+        leadProfileUrl: boundedString(thread.leadProfileUrl, 1_024),
+        senderName: boundedString(thread.senderName, 256),
+        senderProviderId: boundedString(thread.senderProviderId, 256),
+        chatType: boundedString(thread.chatType, 32),
+        classification: boundedString(thread.classification, 128),
+        latestMessage: latestMessage
+            ? {
+                id: boundedString(latestMessage.id, 256),
+                direction: boundedString(latestMessage.direction, 32),
+                timestamp: normalizeTimestamp(latestMessage.timestamp),
+                preview: boundedString(latestMessage.message ?? latestMessage.body, 500),
+            }
+            : null,
+        draft: draft
+            ? {
+                id: boundedString(draft.id, 256),
+                versionId: boundedString(draft.versionId, 256),
+                status: boundedString(draft.status, 64),
+                versionNumber: typeof draft.versionNumber === "number"
+                    ? draft.versionNumber
+                    : null,
+                createdAt: normalizeTimestamp(draft.createdAt),
+            }
+            : null,
+        enrichment: compactRecord(thread.enrichment, [
+            ["name", 256],
+            ["title", 256],
+            ["company", 256],
+            ["companyWebsiteUrl", 1_024],
+            ["location", 256],
+            ["linkedinUrl", 1_024],
+        ]),
+        campaign: compactRecord(thread.campaign, [
+            ["id", 256],
+            ["name", 256],
+        ]),
+        latestMessageTimestamp: normalizeTimestamp(thread.latestMessageTimestamp),
+        updatedAt: normalizeTimestamp(thread.updatedAt),
+        hasUnprocessedInbound: typeof thread.hasUnprocessedInbound === "boolean"
+            ? thread.hasUnprocessedInbound
+            : null,
+        lastInboundMessageAt: normalizeTimestamp(thread.lastInboundMessageAt),
+        followUpsSuppressed: typeof thread.followUpsSuppressed === "boolean"
+            ? thread.followUpsSuppressed
+            : null,
+        replyEligibility: replyEligibility
+            ? {
+                canSendDraft: typeof replyEligibility.canSendDraft === "boolean"
+                    ? replyEligibility.canSendDraft
+                    : null,
+                canSendManual: typeof replyEligibility.canSendManual === "boolean"
+                    ? replyEligibility.canSendManual
+                    : null,
+                reasonCodes: Array.isArray(replyEligibility.reasonCodes)
+                    ? replyEligibility.reasonCodes
+                        .slice(0, 20)
+                        .map((reason) => boundedString(reason, 128))
+                    : [],
+            }
+            : null,
+    };
+}
+function compactThreadDetail(thread) {
+    if (!thread)
+        return null;
+    const source = thread;
+    const draft = asRecord(source.draft);
+    return {
+        ...compactThreadSummary(source),
+        messageOrder: boundedString(source.messageOrder, 32),
+        draft: draft
+            ? {
+                id: boundedString(draft.id, 256),
+                versionId: boundedString(draft.versionId, 256),
+                draftId: boundedString(draft.draftId, 256),
+                body: boundedString(draft.body, 16_000),
+                subject: boundedString(draft.subject, 2_000),
+                status: boundedString(draft.status, 64),
+                versionNumber: typeof draft.versionNumber === "number"
+                    ? draft.versionNumber
+                    : null,
+                createdAt: normalizeTimestamp(draft.createdAt),
+            }
+            : null,
+    };
+}
+function compactTranscriptMessage(value) {
+    const message = asRecord(value) ?? {};
+    return {
+        id: boundedString(message.id, 256),
+        message: boundedString(message.message ?? message.body, 8_000),
+        subject: boundedString(message.subject, 2_000),
+        timestamp: normalizeTimestamp(message.timestamp),
+        direction: boundedString(message.direction, 32),
+        senderProviderId: boundedString(message.senderProviderId, 256),
+    };
+}
 function requireString(value, field) {
     if (typeof value !== "string" || value.trim() === "") {
         return errorResult("invalid_arguments", `${field} is required.`);
@@ -253,6 +405,39 @@ function chronologicalTranscript(thread) {
         return aTime - bTime;
     });
 }
+function boundedTranscriptResult(input) {
+    const chronological = chronologicalTranscript(input.thread);
+    const selected = chronological
+        .slice(-input.messageLimit)
+        .map(compactTranscriptMessage);
+    const compactThread = compactThreadDetail(input.thread);
+    const acceptedChronological = [];
+    for (const message of [...selected].reverse()) {
+        const candidate = [message, ...acceptedChronological];
+        const payload = {
+            routeCalled: input.routeCalled,
+            thread: compactThread,
+            messageOrder: "chronological",
+            chronologicalTranscript: candidate,
+            messagesAvailable: chronological.length,
+            messagesReturned: candidate.length,
+            transcriptTruncated: candidate.length < chronological.length,
+        };
+        if (utf8Bytes(payload) > MAX_INBOX_TOOL_RESULT_BYTES)
+            break;
+        acceptedChronological.unshift(message);
+    }
+    const transcript = acceptedChronological;
+    return {
+        routeCalled: input.routeCalled,
+        thread: compactThread,
+        messageOrder: "chronological",
+        chronologicalTranscript: transcript,
+        messagesAvailable: chronological.length,
+        messagesReturned: transcript.length,
+        transcriptTruncated: transcript.length < chronological.length,
+    };
+}
 function routeError(error, fallback) {
     if (error instanceof SellableApiError) {
         let parsed = null;
@@ -278,7 +463,7 @@ function appendParam(params, key, value) {
 export async function searchInboxThreads(input) {
     const params = new URLSearchParams();
     const limit = typeof input.limit === "number" && Number.isFinite(input.limit)
-        ? Math.max(1, Math.min(Math.trunc(input.limit), 50))
+        ? Math.max(1, Math.min(Math.trunc(input.limit), MAX_INBOX_SEARCH_LIMIT))
         : undefined;
     appendParam(params, "limit", limit);
     appendParam(params, "cursor", input.cursor);
@@ -296,11 +481,23 @@ export async function searchInboxThreads(input) {
     const query = params.toString();
     const routeCalled = `/api/v3/inbox${query ? `?${query}` : ""}`;
     const response = await getApi().get(routeCalled);
-    const threads = Array.isArray(response.threads) ? response.threads : [];
-    return textResult({
+    const threads = Array.isArray(response.threads)
+        ? response.threads.map(compactThreadSummary)
+        : [];
+    const structuredContent = {
         routeCalled,
-        ...response,
-    }, `${threads.length} inbox thread${threads.length === 1 ? "" : "s"} returned.`);
+        threads,
+        pagination: response.pagination ?? null,
+        totalCount: response.totalCount ?? threads.length,
+        filters: response.filters ?? null,
+        status: response.status ?? null,
+        filter: response.filter ?? null,
+        resultShape: "compact_thread_summaries",
+    };
+    if (utf8Bytes(structuredContent) > MAX_INBOX_TOOL_RESULT_BYTES) {
+        return errorResult("inbox_search_result_too_large", "Inbox summaries exceeded the MCP response budget. Narrow the filters or page size.", { routeCalled, returnedCount: threads.length });
+    }
+    return textResult(structuredContent, `${threads.length} inbox thread${threads.length === 1 ? "" : "s"} returned.`);
 }
 export async function getInboxThread(input) {
     const required = requireStrings(input, ["threadId"]);
@@ -310,12 +507,16 @@ export async function getInboxThread(input) {
     const routeCalled = `/api/v3/inbox/${encodeURIComponent(threadId)}`;
     const response = await getApi().get(routeCalled);
     const thread = getThread(response);
-    return textResult({
+    const messageLimit = typeof input.messageLimit === "number" &&
+        Number.isFinite(input.messageLimit)
+        ? Math.max(1, Math.min(Math.trunc(input.messageLimit), MAX_INBOX_DETAIL_MESSAGES))
+        : 25;
+    const structuredContent = boundedTranscriptResult({
         routeCalled,
         thread,
-        messageOrder: thread?.messageOrder ?? "route_order",
-        chronologicalTranscript: chronologicalTranscript(thread),
-    }, thread
+        messageLimit,
+    });
+    return textResult(structuredContent, thread
         ? `Loaded inbox thread ${thread.id ?? threadId}.`
         : `Loaded inbox thread ${threadId}.`);
 }

package/dist/tools/opportunity-sequences.d.ts

@@ -167,6 +167,10 @@ export declare const opportunitySequenceToolDefinitions: readonly [{
                         readonly type: "string";
                         readonly format: "date-time";
                     };
+                    readonly voicemail_policy: {
+                        readonly type: "string";
+                        readonly enum: readonly ["context_only_max_15s_then_email", "context_social_proof_max_30s_then_email", "do_not_leave"];
+                    };
                     readonly subject: {
                         readonly type: "string";
                         readonly minLength: 1;

package/dist/tools/opportunity-sequences.js

@@ -105,6 +105,14 @@ export const opportunitySequenceToolDefinitions = [
                             additionalProperties: false,
                         },
                         due_at: { type: "string", format: "date-time" },
+                        voicemail_policy: {
+                            type: "string",
+                            enum: [
+                                "context_only_max_15s_then_email",
+                                "context_social_proof_max_30s_then_email",
+                                "do_not_leave",
+                            ],
+                        },
                         subject: { type: "string", minLength: 1, maxLength: 200 },
                         body: { type: "string", minLength: 1, maxLength: 4000 },
                         rationale_summary: {

package/dist/tools/registry.d.ts

@@ -9569,6 +9569,12 @@ export declare const allTools: ({
             threadId: {
                 type: string;
             };
+            messageLimit: {
+                type: string;
+                minimum: number;
+                maximum: number;
+                description: string;
+            };
             limit?: undefined;
             cursor?: undefined;
             filter?: undefined;
@@ -9602,6 +9608,49 @@ export declare const allTools: ({
         openWorldHint: boolean;
         idempotentHint?: undefined;
     };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            threadId: {
+                type: string;
+            };
+            limit?: undefined;
+            cursor?: undefined;
+            filter?: undefined;
+            status?: undefined;
+            senderId?: undefined;
+            classification?: undefined;
+            search?: undefined;
+            includeEnrichment?: undefined;
+            includeReplyEligibility?: undefined;
+            messageLimit?: undefined;
+            versionId?: undefined;
+            body?: undefined;
+            approvedBody?: undefined;
+            approvedBodyHash?: undefined;
+            approvedThreadSnapshot?: undefined;
+            idempotencyKey?: undefined;
+            approval?: undefined;
+            workspaceId?: undefined;
+            message?: undefined;
+            approvedMessageHash?: undefined;
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+    outputSchema: {
+        type: string;
+        additionalProperties: boolean;
+    };
+    annotations: {
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        openWorldHint: boolean;
+        idempotentHint?: undefined;
+    };
 } | {
     name: string;
     description: string;
@@ -9626,6 +9675,7 @@ export declare const allTools: ({
             search?: undefined;
             includeEnrichment?: undefined;
             includeReplyEligibility?: undefined;
+            messageLimit?: undefined;
             approvedBody?: undefined;
             approvedBodyHash?: undefined;
             approvedThreadSnapshot?: undefined;
@@ -9707,6 +9757,7 @@ export declare const allTools: ({
             search?: undefined;
             includeEnrichment?: undefined;
             includeReplyEligibility?: undefined;
+            messageLimit?: undefined;
             body?: undefined;
             message?: undefined;
             approvedMessageHash?: undefined;
@@ -9780,6 +9831,7 @@ export declare const allTools: ({
             search?: undefined;
             includeEnrichment?: undefined;
             includeReplyEligibility?: undefined;
+            messageLimit?: undefined;
             versionId?: undefined;
             body?: undefined;
             approvedBody?: undefined;
@@ -10339,6 +10391,10 @@ export declare const allTools: ({
                         readonly type: "string";
                         readonly format: "date-time";
                     };
+                    readonly voicemail_policy: {
+                        readonly type: "string";
+                        readonly enum: readonly ["context_only_max_15s_then_email", "context_social_proof_max_30s_then_email", "do_not_leave"];
+                    };
                     readonly subject: {
                         readonly type: "string";
                         readonly minLength: 1;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sellable/mcp",
-  "version": "0.1.879",
+  "version": "0.1.881",
   "type": "module",
   "description": "Sellable MCP server for Claude Code, Codex, and Hermes campaign workflows",
   "main": "dist/index.js",