@sellable/mcp 0.1.553 → 0.1.554

package/dist/refill-date-window.d.ts

@@ -0,0 +1,34 @@
+export type RefillDateWindowSource = "default_scheduler_forward" | "horizon_send_days" | "until_date" | "target_date";
+export type NormalizedRefillDateSelector = {
+    source: RefillDateWindowSource;
+    targetDate: string | null;
+    untilDate: string | null;
+    horizonSendDays: number | null;
+};
+export type RefillRunDateWindow = NormalizedRefillDateSelector & {
+    version: 1;
+    selectedDates: string[];
+    senderWindows?: Array<{
+        senderId: string | null;
+        timeZone: string | null;
+        selectedDates: string[];
+    }>;
+};
+type DateSelectorInput = {
+    targetDate?: unknown;
+    untilDate?: unknown;
+    horizonSendDays?: unknown;
+};
+export declare function normalizeRefillDateSelector(input: DateSelectorInput): NormalizedRefillDateSelector;
+export declare function refillDateSelectorBody(selector: NormalizedRefillDateSelector): {
+    targetDate?: string;
+    untilDate?: string;
+    horizonSendDays?: number;
+};
+export declare function dateWindowFromSelector(selector: NormalizedRefillDateSelector): RefillRunDateWindow;
+export declare function dateWindowFromPlan(plan: Record<string, unknown>, selector: NormalizedRefillDateSelector): RefillRunDateWindow;
+export declare function dateWindowFromRunState(runState: unknown): RefillRunDateWindow | null;
+export declare function selectorFromDateWindow(window: RefillRunDateWindow): NormalizedRefillDateSelector;
+export declare function dateSelectorMatchesWindow(selector: NormalizedRefillDateSelector, window: RefillRunDateWindow): boolean;
+export declare function schedulerSweepTargetDates(window: RefillRunDateWindow): string[];
+export {};

package/dist/refill-date-window.js

@@ -0,0 +1,210 @@
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function stringValue(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function numberValue(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function arrayValue(value) {
+    return Array.isArray(value) ? value : [];
+}
+function isValidDateKey(value) {
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(value))
+        return false;
+    const [year, month, day] = value.split("-").map(Number);
+    const date = new Date(Date.UTC(year, month - 1, day));
+    return (date.getUTCFullYear() === year &&
+        date.getUTCMonth() === month - 1 &&
+        date.getUTCDate() === day);
+}
+function normalizeDateKey(value, field) {
+    if (value === undefined || value === null || value === "")
+        return null;
+    if (typeof value !== "string") {
+        throw new Error(`${field} must be a string in YYYY-MM-DD format.`);
+    }
+    const trimmed = value.trim();
+    if (!isValidDateKey(trimmed)) {
+        throw new Error(`${field} must be a valid YYYY-MM-DD calendar date.`);
+    }
+    return trimmed;
+}
+function normalizeHorizonSendDays(value) {
+    if (value === undefined)
+        return null;
+    if (typeof value !== "number" ||
+        !Number.isInteger(value) ||
+        value < 1 ||
+        value > 7) {
+        throw new Error("horizonSendDays must be an integer between 1 and 7.");
+    }
+    return value;
+}
+export function normalizeRefillDateSelector(input) {
+    const targetDate = normalizeDateKey(input.targetDate, "targetDate");
+    const untilDate = normalizeDateKey(input.untilDate, "untilDate");
+    const horizonSendDays = normalizeHorizonSendDays(input.horizonSendDays);
+    if (targetDate) {
+        return {
+            source: "target_date",
+            targetDate,
+            untilDate: null,
+            horizonSendDays: null,
+        };
+    }
+    if (untilDate) {
+        return {
+            source: "until_date",
+            targetDate: null,
+            untilDate,
+            horizonSendDays: null,
+        };
+    }
+    if (horizonSendDays !== null) {
+        return {
+            source: "horizon_send_days",
+            targetDate: null,
+            untilDate: null,
+            horizonSendDays,
+        };
+    }
+    return {
+        source: "default_scheduler_forward",
+        targetDate: null,
+        untilDate: null,
+        horizonSendDays: null,
+    };
+}
+export function refillDateSelectorBody(selector) {
+    if (selector.source === "target_date" && selector.targetDate) {
+        return { targetDate: selector.targetDate };
+    }
+    if (selector.source === "until_date" && selector.untilDate) {
+        return { untilDate: selector.untilDate };
+    }
+    if (selector.source === "horizon_send_days" &&
+        selector.horizonSendDays !== null) {
+        return { horizonSendDays: selector.horizonSendDays };
+    }
+    return {};
+}
+export function dateWindowFromSelector(selector) {
+    return {
+        version: 1,
+        ...selector,
+        selectedDates: selector.targetDate ? [selector.targetDate] : [],
+    };
+}
+function selectedDatesFromPlan(plan) {
+    const packet = isRecord(plan.packet) ? plan.packet : {};
+    const target = isRecord(packet.target) ? packet.target : {};
+    const window = isRecord(target.window) ? target.window : {};
+    const senderWindows = arrayValue(window.senderWindows).filter(isRecord);
+    const fromWindows = senderWindows.flatMap((senderWindow) => arrayValue(senderWindow.selectedDates)
+        .map((entry) => stringValue(entry))
+        .filter((entry) => Boolean(entry)));
+    if (fromWindows.length > 0)
+        return Array.from(new Set(fromWindows)).sort();
+    const senderRefillPlans = arrayValue(target.senderRefillPlans).filter(isRecord);
+    return Array.from(new Set(senderRefillPlans.flatMap((senderPlan) => {
+        const horizon = isRecord(senderPlan.horizon) ? senderPlan.horizon : {};
+        return arrayValue(horizon.selectedDays)
+            .filter(isRecord)
+            .map((day) => stringValue(day.date))
+            .filter((entry) => Boolean(entry));
+    }))).sort();
+}
+function senderWindowsFromPlan(plan) {
+    const packet = isRecord(plan.packet) ? plan.packet : {};
+    const target = isRecord(packet.target) ? packet.target : {};
+    const window = isRecord(target.window) ? target.window : {};
+    return arrayValue(window.senderWindows)
+        .filter(isRecord)
+        .map((senderWindow) => ({
+        senderId: stringValue(senderWindow.senderId),
+        timeZone: stringValue(senderWindow.timeZone),
+        selectedDates: arrayValue(senderWindow.selectedDates)
+            .map((entry) => stringValue(entry))
+            .filter((entry) => Boolean(entry)),
+    }));
+}
+export function dateWindowFromPlan(plan, selector) {
+    const packet = isRecord(plan.packet) ? plan.packet : {};
+    const request = isRecord(packet.request) ? packet.request : {};
+    const targetDate = stringValue(request.targetDate) ?? selector.targetDate ?? null;
+    const untilDate = stringValue(request.untilDate) ?? selector.untilDate ?? null;
+    const horizonSendDays = numberValue(request.horizonSendDays) ?? selector.horizonSendDays ?? null;
+    const source = targetDate
+        ? "target_date"
+        : untilDate
+            ? "until_date"
+            : horizonSendDays !== null
+                ? "horizon_send_days"
+                : selector.source;
+    const selectedDates = selectedDatesFromPlan(plan);
+    return {
+        version: 1,
+        source,
+        targetDate: source === "target_date" ? targetDate : null,
+        untilDate: source === "until_date" ? untilDate : null,
+        horizonSendDays: source === "horizon_send_days" ? horizonSendDays : null,
+        selectedDates: selectedDates.length > 0
+            ? selectedDates
+            : targetDate
+                ? [targetDate]
+                : [],
+        senderWindows: senderWindowsFromPlan(plan),
+    };
+}
+export function dateWindowFromRunState(runState) {
+    const state = isRecord(runState) ? runState : {};
+    const raw = isRecord(state.dateWindow) ? state.dateWindow : null;
+    if (!raw || raw.version !== 1)
+        return null;
+    const source = raw.source === "target_date" ||
+        raw.source === "until_date" ||
+        raw.source === "horizon_send_days" ||
+        raw.source === "default_scheduler_forward"
+        ? raw.source
+        : null;
+    if (!source)
+        return null;
+    return {
+        version: 1,
+        source,
+        targetDate: source === "target_date" ? stringValue(raw.targetDate) : null,
+        untilDate: source === "until_date" ? stringValue(raw.untilDate) : null,
+        horizonSendDays: source === "horizon_send_days"
+            ? numberValue(raw.horizonSendDays)
+            : null,
+        selectedDates: arrayValue(raw.selectedDates)
+            .map((entry) => stringValue(entry))
+            .filter((entry) => Boolean(entry)),
+    };
+}
+export function selectorFromDateWindow(window) {
+    return {
+        source: window.source,
+        targetDate: window.targetDate,
+        untilDate: window.untilDate,
+        horizonSendDays: window.horizonSendDays,
+    };
+}
+export function dateSelectorMatchesWindow(selector, window) {
+    return (selector.source === window.source &&
+        selector.targetDate === window.targetDate &&
+        selector.untilDate === window.untilDate &&
+        selector.horizonSendDays === window.horizonSendDays);
+}
+export function schedulerSweepTargetDates(window) {
+    if (window.source === "target_date" && window.targetDate) {
+        return [window.targetDate];
+    }
+    if (window.source === "until_date" ||
+        window.source === "horizon_send_days") {
+        return window.selectedDates;
+    }
+    return [];
+}

package/dist/tools/refill-executors.d.ts

@@ -134,36 +134,6 @@ export declare function sleep(ms: number): Promise<unknown>;
 export declare function recordValue(value: unknown): Record<string, unknown> | null;
 export declare function stringValue(value: unknown): string | null;
 export declare function numberValue(value: unknown): number | null;
-export type SchedulerChangedCount = {
-    campaignId: string;
-    tableId: string;
-    actionType: string;
-    count: number;
-};
-export type SchedulerChangedCounts = {
-    complete: true;
-    truncated: false;
-    total: number;
-    byCampaignTableActionType: SchedulerChangedCount[];
-};
-export declare function normalizeSchedulerChangedCounts(value: unknown): SchedulerChangedCounts | null;
-export declare function normalizeSchedulerPrimitiveResult(value: unknown): {
-    status: "scheduler_receipt_incomplete";
-    schedulerStatus: string;
-    receipt: {} | null;
-    retryAfterMs: number | null;
-    changedCounts: null;
-    auditComplete: false;
-    blocker: "scheduler_receipt_incomplete";
-} | {
-    status: string;
-    receipt: {} | null;
-    retryAfterMs: number | null;
-    changedCounts: SchedulerChangedCounts;
-    auditComplete: true;
-    schedulerStatus?: undefined;
-    blocker?: undefined;
-};
 export declare function stringArray(value: unknown): string[];
 export declare function prepareRowSelectorValue(value: unknown): PrepareRowSelector | undefined;
 export declare function uniqueStrings(values: Array<string | null | undefined>): string[];

package/dist/tools/refill-executors.js

@@ -3,7 +3,6 @@ import { startPrepareCampaignMessages } from "./campaign-message-preparation.js"
 import { startCampaign } from "./campaigns.js";
 import { confirmLeadList, importLeads, searchSignals, selectPromisingPosts, } from "./leads.js";
 import { markProviderPromptLoaded } from "./provider-preflight.js";
-import { runSchedulerSweep } from "./scheduler-run.js";
 import { refreshPaidInmailCredits } from "./senders.js";
 import { workspaceRequestOptions } from "./workspace-context.js";
 const PAID_INMAIL_REFRESH_MAX_ATTEMPTS = 3;
@@ -41,92 +40,6 @@ export function stringValue(value) {
 export function numberValue(value) {
     return typeof value === "number" && Number.isFinite(value) ? value : null;
 }
-export function normalizeSchedulerChangedCounts(value) {
-    const changedCounts = recordValue(value);
-    if (!changedCounts ||
-        changedCounts.complete !== true ||
-        changedCounts.truncated !== false) {
-        return null;
-    }
-    const total = numberValue(changedCounts.total);
-    if (total === null || total < 0 || !Number.isInteger(total))
-        return null;
-    if (!Array.isArray(changedCounts.byCampaignTableActionType))
-        return null;
-    const groups = [];
-    const seen = new Set();
-    for (const rawGroup of changedCounts.byCampaignTableActionType) {
-        const group = recordValue(rawGroup);
-        const campaignId = stringValue(group?.campaignId);
-        const tableId = stringValue(group?.tableId);
-        const actionType = stringValue(group?.actionType);
-        const count = numberValue(group?.count);
-        if (!campaignId ||
-            !tableId ||
-            !actionType ||
-            count === null ||
-            count <= 0 ||
-            !Number.isInteger(count)) {
-            return null;
-        }
-        const key = `${campaignId}:${tableId}:${actionType}`;
-        if (seen.has(key))
-            return null;
-        seen.add(key);
-        groups.push({ campaignId, tableId, actionType, count });
-    }
-    groups.sort((a, b) => {
-        if (a.campaignId !== b.campaignId) {
-            return a.campaignId.localeCompare(b.campaignId);
-        }
-        if (a.tableId !== b.tableId)
-            return a.tableId.localeCompare(b.tableId);
-        return a.actionType.localeCompare(b.actionType);
-    });
-    if (groups.reduce((sum, group) => sum + group.count, 0) !== total) {
-        return null;
-    }
-    return {
-        complete: true,
-        truncated: false,
-        total,
-        byCampaignTableActionType: groups,
-    };
-}
-export function normalizeSchedulerPrimitiveResult(value) {
-    const response = recordValue(value);
-    const receipt = recordValue(response?.receipt);
-    const changedCounts = normalizeSchedulerChangedCounts(receipt?.changedCounts ?? response?.changedCounts);
-    const schedulerStatus = stringValue(response?.status) ?? stringValue(receipt?.status) ?? "unknown";
-    if (!changedCounts) {
-        return {
-            status: "scheduler_receipt_incomplete",
-            schedulerStatus,
-            receipt: response?.receipt ?? null,
-            retryAfterMs: numberValue(response?.retryAfterMs),
-            changedCounts: null,
-            auditComplete: false,
-            blocker: "scheduler_receipt_incomplete",
-        };
-    }
-    return {
-        status: schedulerStatus,
-        receipt: response?.receipt ?? null,
-        retryAfterMs: numberValue(response?.retryAfterMs),
-        changedCounts,
-        auditComplete: true,
-    };
-}
-function exactDateValue(value) {
-    const targetDate = stringValue(value);
-    if (!targetDate || !/^\d{4}-\d{2}-\d{2}$/.test(targetDate))
-        return null;
-    const parsed = new Date(`${targetDate}T00:00:00.000Z`);
-    return !Number.isNaN(parsed.getTime()) &&
-        parsed.toISOString().slice(0, 10) === targetDate
-        ? targetDate
-        : null;
-}
 export function stringArray(value) {
     if (!Array.isArray(value))
         return [];
@@ -857,45 +770,6 @@ export async function executeOneYoloPrimitive(action, workspaceId) {
         case "wait_for_active_work":
         case "wait_for_source_import":
             return { status: "read_only_reread", result: waitResultForAction(action) };
-        case "run_scheduler_sweep": {
-            const toolInput = actionToolInput(action);
-            const actionWorkspaceId = stringValue(toolInput.workspaceId);
-            const targetDate = exactDateValue(toolInput.targetDate);
-            const targetDateKey = exactDateValue(toolInput.targetDateKey);
-            const actionKey = stringValue(action.actionKey);
-            const requestKey = stringValue(toolInput.requestKey);
-            const targetShapeRevision = stringValue(toolInput.targetShapeRevision);
-            const receiptRequirements = recordValue(action.receiptRequirements);
-            const receiptGroups = stringArray(receiptRequirements?.groupBy);
-            if (!workspaceId ||
-                !actionWorkspaceId ||
-                actionWorkspaceId !== workspaceId ||
-                toolInput.action !== "run" ||
-                !targetDate ||
-                targetDateKey !== targetDate ||
-                !actionKey ||
-                requestKey !== actionKey ||
-                !targetShapeRevision ||
-                action.workspaceWide !== true ||
-                receiptRequirements?.nonTruncated !== true ||
-                receiptGroups.join(":") !== "campaignId:tableId:actionType") {
-                return {
-                    status: "refused",
-                    refusalReason: "run_scheduler_sweep action is missing exact workspace/date/revision scope or complete receipt requirements",
-                };
-            }
-            const result = await runSchedulerSweep({
-                workspaceId,
-                action: "run",
-                targetDate,
-                requestKey,
-                targetShapeRevision,
-            });
-            return {
-                status: "executed_and_reread",
-                result: normalizeSchedulerPrimitiveResult(result),
-            };
-        }
         case "prepare_messages": {
             const campaignId = actionCampaignId(action);
             const tableId = actionTableId(action) ?? undefined;

package/dist/tools/refill-sends-evergreen.d.ts

@@ -0,0 +1,28 @@
+type RefillSendsEvergreenInput = {
+    workspaceId?: string;
+};
+export declare const refillSendsEvergreenToolDefinitions: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            workspaceId: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+}[];
+export declare function refillSendsEvergreenCommand(input: RefillSendsEvergreenInput): {
+    readOnly: boolean;
+    workspaceId: string | null;
+    firstOperationalSteps: string[];
+    approvalContract: string;
+    forbiddenActions: string[];
+    fillWindow: string;
+    hostExamples: string[];
+};
+export {};

package/dist/tools/refill-sends-evergreen.js

@@ -0,0 +1,47 @@
+export const refillSendsEvergreenToolDefinitions = [
+    {
+        name: "refill_sends_evergreen",
+        description: "Read-only Phase 85 evergreen refill command contract. It performs no mutations and only tells the operator to call get_evergreen_refill_plan for a dry-run packet and journal.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                workspaceId: {
+                    type: "string",
+                    description: "Explicit request-scoped workspace id.",
+                },
+            },
+            required: ["workspaceId"],
+            additionalProperties: false,
+        },
+    },
+];
+export function refillSendsEvergreenCommand(input) {
+    return {
+        readOnly: true,
+        workspaceId: input.workspaceId ?? null,
+        firstOperationalSteps: [
+            "Call get_evergreen_refill_plan with the explicit workspaceId.",
+            "Read the returned packet, globalActionQueue, per-sender plans, and itinerary before taking any action.",
+            "Review the dry-run journal file path returned by get_evergreen_refill_plan.",
+            "Phase 85 is PLAN-ONLY; execution arrives in Phase 86.",
+        ],
+        approvalContract: "Nothing is approved or executable in Phase 85. The evergreen command is read-only; Phase 86 introduces execution approval.",
+        forbiddenActions: [
+            "Do not schedule sends.",
+            "Do not send messages.",
+            "Do not approve messages.",
+            "Do not prepare messages.",
+            "Do not start or launch campaigns.",
+            "Do not create campaigns.",
+            "Do not switch providers or source families.",
+            "Do not lower paid InMail thresholds.",
+            "Do not refresh paid InMail credits.",
+            "Do not write scheduler fields.",
+        ],
+        fillWindow: "Use only the target window and caps returned by get_evergreen_refill_plan.",
+        hostExamples: [
+            "refill_sends_evergreen({ workspaceId })",
+            "get_evergreen_refill_plan({ workspaceId })",
+        ],
+    };
+}