@sellable/mcp 0.1.613 → 0.1.614

package/dist/server.js

@@ -52,7 +52,7 @@ import { addRubricItem, checkRubric, deleteRubricItem, draftRubrics, saveRubrics
 import { getSchedulerFillCapacity } from "./tools/scheduler-fill-capacity.js";
 import { runSchedulerSweep } from "./tools/scheduler-run.js";
 import { getSenderRoutingTool, setSenderRoutingTool, } from "./tools/sender-routing.js";
-import { getSender, listSenders, refreshPaidInmailCredits, } from "./tools/senders.js";
+import { getSender, listSenders, refreshPaidInmailCredits, setSenderCalendarLink, } from "./tools/senders.js";
 import { attachRecommendedSequence, attachSequence, createWorkflowTable, } from "./tools/sequencer.js";
 import { setupEvergreenCampaigns } from "./tools/setup-evergreen-campaigns.js";
 import { exportTableCsv, listTables } from "./tools/tables.js";
@@ -577,6 +577,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "get_sender":
                 result = await getSender(args);
                 break;
+            case "set_sender_calendar_link":
+                result = await setSenderCalendarLink(args);
+                break;
             case "refresh_paid_inmail_credits":
                 result = await refreshPaidInmailCredits(args);
                 break;

package/dist/tools/registry.d.ts

@@ -2720,10 +2720,12 @@ export declare const allTools: ({
             senderId: {
                 type: string;
                 description: string;
+                minLength?: undefined;
             };
             workspaceId: {
                 type: string;
                 description: string;
+                minLength?: undefined;
             };
             actionType?: undefined;
             campaignId?: undefined;
@@ -2732,10 +2734,134 @@ export declare const allTools: ({
             threshold?: undefined;
             maxStalenessSeconds?: undefined;
             paidInmailCreditsMaxStalenessSeconds?: undefined;
+            calendarLink?: undefined;
+            expectedCalendarLink?: undefined;
+            expectedCalendarLinkRevision?: undefined;
+            force?: undefined;
         };
         required: string[];
         additionalProperties: boolean;
     };
+    outputSchema?: undefined;
+    annotations?: undefined;
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            senderId: {
+                type: string;
+                minLength: number;
+                description?: undefined;
+            };
+            workspaceId: {
+                type: string;
+                minLength: number;
+                description?: undefined;
+            };
+            calendarLink: {
+                readonly type: readonly ["string", "null"];
+            };
+            expectedCalendarLink: {
+                readonly type: readonly ["string", "null"];
+            };
+            expectedCalendarLinkRevision: {
+                readonly type: readonly ["string", "null"];
+            };
+            force: {
+                type: string;
+            };
+            actionType?: undefined;
+            campaignId?: undefined;
+            tableId?: undefined;
+            columnId?: undefined;
+            threshold?: undefined;
+            maxStalenessSeconds?: undefined;
+            paidInmailCreditsMaxStalenessSeconds?: undefined;
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+    outputSchema: {
+        readonly type: "object";
+        readonly oneOf: readonly [{
+            readonly type: "object";
+            readonly properties: {
+                readonly ok: {
+                    readonly const: true;
+                };
+                readonly senderId: {
+                    readonly type: "string";
+                };
+                readonly workspaceId: {
+                    readonly type: "string";
+                };
+                readonly previousCalendarLink: {
+                    readonly type: readonly ["string", "null"];
+                };
+                readonly calendarLink: {
+                    readonly type: readonly ["string", "null"];
+                };
+                readonly previousCalendarLinkRevision: {
+                    readonly type: readonly ["string", "null"];
+                };
+                readonly calendarLinkRevision: {
+                    readonly type: readonly ["string", "null"];
+                };
+                readonly changed: {
+                    readonly type: "boolean";
+                };
+                readonly cleared: {
+                    readonly type: "boolean";
+                };
+                readonly forced: {
+                    readonly type: "boolean";
+                };
+            };
+            readonly required: readonly ["ok", "senderId", "workspaceId", "previousCalendarLink", "calendarLink", "previousCalendarLinkRevision", "calendarLinkRevision", "changed", "cleared", "forced"];
+            readonly additionalProperties: false;
+        }, {
+            readonly type: "object";
+            readonly properties: {
+                readonly ok: {
+                    readonly const: false;
+                };
+                readonly code: {
+                    readonly type: "string";
+                };
+                readonly message: {
+                    readonly type: "string";
+                };
+                readonly status: {
+                    readonly type: readonly ["number", "null"];
+                };
+                readonly authError: {
+                    readonly type: "boolean";
+                };
+                readonly uncertain: {
+                    readonly type: "boolean";
+                };
+                readonly currentCalendarLink: {
+                    readonly type: readonly ["string", "null"];
+                };
+                readonly currentCalendarLinkRevision: {
+                    readonly type: readonly ["string", "null"];
+                };
+                readonly guidance: {
+                    readonly type: readonly ["string", "null"];
+                };
+            };
+            readonly required: readonly ["ok", "code", "message", "status", "authError", "uncertain", "currentCalendarLink", "currentCalendarLinkRevision", "guidance"];
+            readonly additionalProperties: false;
+        }];
+    };
+    annotations: {
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+        openWorldHint: boolean;
+    };
 } | {
     name: string;
     description: string;

package/dist/tools/senders.d.ts

@@ -14,6 +14,8 @@ export type SenderListItem = {
     timeZone: string;
     displayName: string;
     linkedinProfileUrl: string | null;
+    calendarLink: string | null;
+    calendarLinkRevision: string | null;
     verifiedAccountIdentity: VerifiedAccountIdentity | null;
     identityProofAvailable: boolean;
     identityMatchFields: SenderIdentityMatchField[];
@@ -70,6 +72,45 @@ export type RefreshPaidInmailCreditsResponse = {
         sendMutation: boolean;
     };
 };
+export type SetSenderCalendarLinkInput = {
+    senderId: string;
+    workspaceId: string;
+    calendarLink: string | null;
+    expectedCalendarLink: string | null;
+    expectedCalendarLinkRevision: string | null;
+    force?: boolean;
+};
+export type SetSenderCalendarLinkSuccess = {
+    ok: true;
+    senderId: string;
+    workspaceId: string;
+    previousCalendarLink: string | null;
+    calendarLink: string | null;
+    previousCalendarLinkRevision: string | null;
+    calendarLinkRevision: string | null;
+    changed: boolean;
+    cleared: boolean;
+    forced: boolean;
+};
+export type SetSenderCalendarLinkError = {
+    ok: false;
+    code: string;
+    message: string;
+    status: number | null;
+    authError: boolean;
+    uncertain: boolean;
+    currentCalendarLink: string | null;
+    currentCalendarLinkRevision: string | null;
+    guidance: string | null;
+};
+type SenderCalendarLinkToolResult = {
+    structuredContent: SetSenderCalendarLinkSuccess | SetSenderCalendarLinkError;
+    content: [{
+        type: "text";
+        text: string;
+    }];
+    isError?: true;
+};
 export declare const senderToolDefinitions: ({
     name: string;
     description: string;
@@ -79,6 +120,7 @@ export declare const senderToolDefinitions: ({
             workspaceId: {
                 type: string;
                 description: string;
+                minLength?: undefined;
             };
             senderId?: undefined;
             actionType?: undefined;
@@ -88,10 +130,16 @@ export declare const senderToolDefinitions: ({
             threshold?: undefined;
             maxStalenessSeconds?: undefined;
             paidInmailCreditsMaxStalenessSeconds?: undefined;
+            calendarLink?: undefined;
+            expectedCalendarLink?: undefined;
+            expectedCalendarLinkRevision?: undefined;
+            force?: undefined;
         };
         required: never[];
         additionalProperties: boolean;
     };
+    outputSchema?: undefined;
+    annotations?: undefined;
 } | {
     name: string;
     description: string;
@@ -101,10 +149,12 @@ export declare const senderToolDefinitions: ({
             senderId: {
                 type: string;
                 description: string;
+                minLength?: undefined;
             };
             workspaceId: {
                 type: string;
                 description: string;
+                minLength?: undefined;
             };
             actionType?: undefined;
             campaignId?: undefined;
@@ -113,10 +163,16 @@ export declare const senderToolDefinitions: ({
             threshold?: undefined;
             maxStalenessSeconds?: undefined;
             paidInmailCreditsMaxStalenessSeconds?: undefined;
+            calendarLink?: undefined;
+            expectedCalendarLink?: undefined;
+            expectedCalendarLinkRevision?: undefined;
+            force?: undefined;
         };
         required: string[];
         additionalProperties: boolean;
     };
+    outputSchema?: undefined;
+    annotations?: undefined;
 } | {
     name: string;
     description: string;
@@ -126,10 +182,12 @@ export declare const senderToolDefinitions: ({
             senderId: {
                 type: string;
                 description: string;
+                minLength?: undefined;
             };
             workspaceId: {
                 type: string;
                 description: string;
+                minLength?: undefined;
             };
             actionType: {
                 type: string;
@@ -159,12 +217,137 @@ export declare const senderToolDefinitions: ({
                 type: string;
                 description: string;
             };
+            calendarLink?: undefined;
+            expectedCalendarLink?: undefined;
+            expectedCalendarLinkRevision?: undefined;
+            force?: undefined;
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+    outputSchema?: undefined;
+    annotations?: undefined;
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            senderId: {
+                type: string;
+                minLength: number;
+                description?: undefined;
+            };
+            workspaceId: {
+                type: string;
+                minLength: number;
+                description?: undefined;
+            };
+            calendarLink: {
+                readonly type: readonly ["string", "null"];
+            };
+            expectedCalendarLink: {
+                readonly type: readonly ["string", "null"];
+            };
+            expectedCalendarLinkRevision: {
+                readonly type: readonly ["string", "null"];
+            };
+            force: {
+                type: string;
+            };
+            actionType?: undefined;
+            campaignId?: undefined;
+            tableId?: undefined;
+            columnId?: undefined;
+            threshold?: undefined;
+            maxStalenessSeconds?: undefined;
+            paidInmailCreditsMaxStalenessSeconds?: undefined;
         };
         required: string[];
         additionalProperties: boolean;
     };
+    outputSchema: {
+        readonly type: "object";
+        readonly oneOf: readonly [{
+            readonly type: "object";
+            readonly properties: {
+                readonly ok: {
+                    readonly const: true;
+                };
+                readonly senderId: {
+                    readonly type: "string";
+                };
+                readonly workspaceId: {
+                    readonly type: "string";
+                };
+                readonly previousCalendarLink: {
+                    readonly type: readonly ["string", "null"];
+                };
+                readonly calendarLink: {
+                    readonly type: readonly ["string", "null"];
+                };
+                readonly previousCalendarLinkRevision: {
+                    readonly type: readonly ["string", "null"];
+                };
+                readonly calendarLinkRevision: {
+                    readonly type: readonly ["string", "null"];
+                };
+                readonly changed: {
+                    readonly type: "boolean";
+                };
+                readonly cleared: {
+                    readonly type: "boolean";
+                };
+                readonly forced: {
+                    readonly type: "boolean";
+                };
+            };
+            readonly required: readonly ["ok", "senderId", "workspaceId", "previousCalendarLink", "calendarLink", "previousCalendarLinkRevision", "calendarLinkRevision", "changed", "cleared", "forced"];
+            readonly additionalProperties: false;
+        }, {
+            readonly type: "object";
+            readonly properties: {
+                readonly ok: {
+                    readonly const: false;
+                };
+                readonly code: {
+                    readonly type: "string";
+                };
+                readonly message: {
+                    readonly type: "string";
+                };
+                readonly status: {
+                    readonly type: readonly ["number", "null"];
+                };
+                readonly authError: {
+                    readonly type: "boolean";
+                };
+                readonly uncertain: {
+                    readonly type: "boolean";
+                };
+                readonly currentCalendarLink: {
+                    readonly type: readonly ["string", "null"];
+                };
+                readonly currentCalendarLinkRevision: {
+                    readonly type: readonly ["string", "null"];
+                };
+                readonly guidance: {
+                    readonly type: readonly ["string", "null"];
+                };
+            };
+            readonly required: readonly ["ok", "code", "message", "status", "authError", "uncertain", "currentCalendarLink", "currentCalendarLinkRevision", "guidance"];
+            readonly additionalProperties: false;
+        }];
+    };
+    annotations: {
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+        openWorldHint: boolean;
+    };
 })[];
 export declare function listSenders(input?: ListSendersInput): Promise<ListSendersResponse>;
+export declare function setSenderCalendarLink(input: SetSenderCalendarLinkInput): Promise<SenderCalendarLinkToolResult>;
 export declare function getSender(input: GetSenderInput): Promise<SenderDetailResponse>;
 export declare function refreshPaidInmailCredits(input: RefreshPaidInmailCreditsInput): Promise<RefreshPaidInmailCreditsResponse>;
 export {};

package/dist/tools/senders.js

@@ -1,6 +1,66 @@
-import { getApi } from "../api.js";
+import { getApi, SellableApiError } from "../api.js";
 import { isLinkedInProfileInput, normalizeLinkedInProfileInput, } from "./linkedin-url.js";
 import { normalizeExplicitWorkspaceId, workspaceRequestOptions, } from "./workspace-context.js";
+const nullableStringSchema = { type: ["string", "null"] };
+const setSenderCalendarLinkOutputSchema = {
+    type: "object",
+    oneOf: [
+        {
+            type: "object",
+            properties: {
+                ok: { const: true },
+                senderId: { type: "string" },
+                workspaceId: { type: "string" },
+                previousCalendarLink: nullableStringSchema,
+                calendarLink: nullableStringSchema,
+                previousCalendarLinkRevision: nullableStringSchema,
+                calendarLinkRevision: nullableStringSchema,
+                changed: { type: "boolean" },
+                cleared: { type: "boolean" },
+                forced: { type: "boolean" },
+            },
+            required: [
+                "ok",
+                "senderId",
+                "workspaceId",
+                "previousCalendarLink",
+                "calendarLink",
+                "previousCalendarLinkRevision",
+                "calendarLinkRevision",
+                "changed",
+                "cleared",
+                "forced",
+            ],
+            additionalProperties: false,
+        },
+        {
+            type: "object",
+            properties: {
+                ok: { const: false },
+                code: { type: "string" },
+                message: { type: "string" },
+                status: { type: ["number", "null"] },
+                authError: { type: "boolean" },
+                uncertain: { type: "boolean" },
+                currentCalendarLink: nullableStringSchema,
+                currentCalendarLinkRevision: nullableStringSchema,
+                guidance: nullableStringSchema,
+            },
+            required: [
+                "ok",
+                "code",
+                "message",
+                "status",
+                "authError",
+                "uncertain",
+                "currentCalendarLink",
+                "currentCalendarLinkRevision",
+                "guidance",
+            ],
+            additionalProperties: false,
+        },
+    ],
+};
 function pickString(...values) {
     for (const value of values) {
         if (typeof value !== "string")
@@ -11,6 +71,74 @@ function pickString(...values) {
     }
     return null;
 }
+function isNullableString(value) {
+    return value === null || typeof value === "string";
+}
+function calendarLinkToolResult(structuredContent) {
+    return {
+        structuredContent,
+        content: [{ type: "text", text: JSON.stringify(structuredContent) }],
+        ...(structuredContent.ok ? {} : { isError: true }),
+    };
+}
+function calendarLinkError(values) {
+    return calendarLinkToolResult({ ok: false, ...values });
+}
+function parseErrorBody(body) {
+    try {
+        const parsed = JSON.parse(body);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+function safeErrorCode(value, fallback) {
+    return typeof value === "string" && /^[a-z0-9_]+$/.test(value)
+        ? value
+        : fallback;
+}
+function canonicalConflictCalendarLink(value) {
+    if (typeof value !== "string")
+        return null;
+    let parsed;
+    try {
+        parsed = new URL(value.trim());
+    }
+    catch {
+        return null;
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        return null;
+    }
+    if (parsed.username !== "" || parsed.password !== "") {
+        return null;
+    }
+    return parsed.toString();
+}
+function canonicalConflictRevision(value) {
+    if (typeof value !== "string")
+        return null;
+    const parsed = new Date(value);
+    if (!Number.isFinite(parsed.getTime()))
+        return null;
+    const canonical = parsed.toISOString();
+    return canonical === value ? canonical : null;
+}
+function isSenderCalendarLinkReceipt(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const receipt = value;
+    return (isNullableString(receipt.previousCalendarLink) &&
+        isNullableString(receipt.calendarLink) &&
+        isNullableString(receipt.previousCalendarLinkRevision) &&
+        isNullableString(receipt.calendarLinkRevision) &&
+        typeof receipt.changed === "boolean" &&
+        typeof receipt.cleared === "boolean" &&
+        typeof receipt.forced === "boolean");
+}
 const DEFAULT_PAID_INMAIL_CREDITS_MAX_STALENESS_SECONDS = 4 * 60 * 60;
 function numberOrNull(value) {
     return typeof value === "number" && Number.isFinite(value) ? value : null;
@@ -188,6 +316,36 @@ export const senderToolDefinitions = [
             additionalProperties: false,
         },
     },
+    {
+        name: "set_sender_calendar_link",
+        description: "Set or clear one exact outbound sender's calendar booking link through Sellable's workspace-scoped compare-before-write route. Read list_senders first and pass its calendarLink and calendarLinkRevision. Use force only after the user explicitly authorizes overwriting newer state.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                senderId: { type: "string", minLength: 1 },
+                workspaceId: { type: "string", minLength: 1 },
+                calendarLink: nullableStringSchema,
+                expectedCalendarLink: nullableStringSchema,
+                expectedCalendarLinkRevision: nullableStringSchema,
+                force: { type: "boolean" },
+            },
+            required: [
+                "senderId",
+                "workspaceId",
+                "calendarLink",
+                "expectedCalendarLink",
+                "expectedCalendarLinkRevision",
+            ],
+            additionalProperties: false,
+        },
+        outputSchema: setSenderCalendarLinkOutputSchema,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    },
 ];
 export async function listSenders(input = {}) {
     const api = getApi();
@@ -205,6 +363,12 @@ export async function listSenders(input = {}) {
                 timeZone: String(s?.timeZone || ""),
                 displayName: computeDisplayName(s),
                 linkedinProfileUrl,
+                calendarLink: isNullableString(s?.replySettings?.calendarLink)
+                    ? s.replySettings.calendarLink
+                    : null,
+                calendarLinkRevision: isNullableString(s?.replySettings?.calendarLinkRevision)
+                    ? s.replySettings.calendarLinkRevision
+                    : null,
                 verifiedAccountIdentity: identity.verifiedAccountIdentity,
                 identityProofAvailable: identity.identityMatchFields.length > 0,
                 identityMatchFields: identity.identityMatchFields,
@@ -213,6 +377,127 @@ export async function listSenders(input = {}) {
         }),
     };
 }
+export async function setSenderCalendarLink(input) {
+    const candidate = input;
+    const record = candidate && typeof candidate === "object" && !Array.isArray(candidate)
+        ? candidate
+        : null;
+    const senderId = record && typeof record.senderId === "string"
+        ? record.senderId.trim()
+        : "";
+    const workspaceId = record && typeof record.workspaceId === "string"
+        ? record.workspaceId.trim()
+        : "";
+    const hasOwn = (key) => record !== null && Object.prototype.hasOwnProperty.call(record, key);
+    const valid = senderId.length > 0 &&
+        workspaceId.length > 0 &&
+        hasOwn("calendarLink") &&
+        isNullableString(record?.calendarLink) &&
+        hasOwn("expectedCalendarLink") &&
+        isNullableString(record?.expectedCalendarLink) &&
+        hasOwn("expectedCalendarLinkRevision") &&
+        isNullableString(record?.expectedCalendarLinkRevision) &&
+        (!hasOwn("force") || typeof record?.force === "boolean");
+    if (!valid || !record) {
+        return calendarLinkError({
+            code: "invalid_arguments",
+            message: "senderId, workspaceId, calendarLink, expectedCalendarLink, and expectedCalendarLinkRevision are required with the documented types.",
+            status: null,
+            authError: false,
+            uncertain: false,
+            currentCalendarLink: null,
+            currentCalendarLinkRevision: null,
+            guidance: "Read list_senders and retry with its current calendarLink and calendarLinkRevision values.",
+        });
+    }
+    const api = getApi();
+    try {
+        const rawReceipt = await api.put(`/api/v3/mcp/senders/${encodeURIComponent(senderId)}/calendar-link`, {
+            workspaceId,
+            calendarLink: record.calendarLink,
+            expectedCalendarLink: record.expectedCalendarLink,
+            expectedCalendarLinkRevision: record.expectedCalendarLinkRevision,
+            force: record.force === true,
+        }, workspaceRequestOptions(workspaceId));
+        if (!isSenderCalendarLinkReceipt(rawReceipt)) {
+            return calendarLinkError({
+                code: "malformed_sender_calendar_link_response",
+                message: "The calendar-link update returned an incomplete receipt, so the final state is uncertain.",
+                status: null,
+                authError: false,
+                uncertain: true,
+                currentCalendarLink: null,
+                currentCalendarLinkRevision: null,
+                guidance: "Reread list_senders and reconcile the sender state before retrying or forcing another write.",
+            });
+        }
+        return calendarLinkToolResult({
+            ok: true,
+            senderId,
+            workspaceId,
+            previousCalendarLink: rawReceipt.previousCalendarLink,
+            calendarLink: rawReceipt.calendarLink,
+            previousCalendarLinkRevision: rawReceipt.previousCalendarLinkRevision,
+            calendarLinkRevision: rawReceipt.calendarLinkRevision,
+            changed: rawReceipt.changed,
+            cleared: rawReceipt.cleared,
+            forced: rawReceipt.forced,
+        });
+    }
+    catch (error) {
+        if (error instanceof SellableApiError) {
+            const body = parseErrorBody(error.body);
+            const code = safeErrorCode(body?.code, `http_${error.status}`);
+            const isConflict = error.status === 409 && code === "calendar_link_conflict";
+            const uncertain = error.status >= 500;
+            const guidance = isConflict
+                ? "Reread list_senders, compare the current value, and use force only after the user explicitly authorizes overwriting it."
+                : uncertain
+                    ? "Reread list_senders and reconcile the sender state before retrying; do not force while the result is uncertain."
+                    : error.isAuthError
+                        ? error.guidance || "Authenticate again and retry the same scoped request."
+                        : error.status === 400 && code === "precondition_required"
+                            ? "Reread list_senders and retry with all current comparison fields."
+                            : error.status === 400
+                                ? "Use an HTTP(S) booking URL or null, then retry with current comparison fields."
+                                : error.status === 404
+                                    ? "Reread list_senders in the explicit workspace and select an existing sender."
+                                    : null;
+            return calendarLinkError({
+                code,
+                message: isConflict
+                    ? "The sender calendar link changed after it was read."
+                    : uncertain
+                        ? "The calendar-link update did not complete with a confirmed result."
+                        : error.isAuthError
+                            ? "Sellable authentication or authorization failed."
+                            : error.status === 404
+                                ? "The sender was not found in the explicit workspace."
+                                : "The sender calendar link was not updated.",
+                status: error.status,
+                authError: error.isAuthError,
+                uncertain,
+                currentCalendarLink: isConflict
+                    ? canonicalConflictCalendarLink(body?.currentCalendarLink)
+                    : null,
+                currentCalendarLinkRevision: isConflict
+                    ? canonicalConflictRevision(body?.currentCalendarLinkRevision)
+                    : null,
+                guidance,
+            });
+        }
+        return calendarLinkError({
+            code: "sender_calendar_link_uncertain",
+            message: "The calendar-link request ended without a confirmed response, so the final state is uncertain.",
+            status: null,
+            authError: false,
+            uncertain: true,
+            currentCalendarLink: null,
+            currentCalendarLinkRevision: null,
+            guidance: "Reread list_senders and reconcile the sender state before retrying; do not force while the result is uncertain.",
+        });
+    }
+}
 export async function getSender(input) {
     const api = getApi();
     const requestOptions = workspaceRequestOptions(input.workspaceId);

package/package.json

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

package/skills/refill-sends-v2-workflow/core/flow.v1.json

@@ -255,6 +255,7 @@
         "set_engage_state",
         "set_engage_style_guide",
         "set_headline_icp_criteria",
+        "set_sender_calendar_link",
         "set_sender_routing",
         "setup_evergreen_campaigns",
         "start_campaign",