@sellable/mcp 0.1.554 → 0.1.555

package/dist/tools/refill-executors.js

@@ -3,6 +3,7 @@ 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;
@@ -40,6 +41,160 @@ 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;
+    }
+    if (!Array.isArray(changedCounts.byCampaignTableActionTypeSender)) {
+        return null;
+    }
+    const senderGroups = [];
+    const senderSeen = new Set();
+    for (const rawGroup of changedCounts.byCampaignTableActionTypeSender) {
+        const group = recordValue(rawGroup);
+        const campaignId = stringValue(group?.campaignId);
+        const tableId = stringValue(group?.tableId);
+        const actionType = stringValue(group?.actionType);
+        const senderId = stringValue(group?.senderId);
+        const count = numberValue(group?.count);
+        if (!campaignId ||
+            !tableId ||
+            !actionType ||
+            !senderId ||
+            count === null ||
+            count <= 0 ||
+            !Number.isInteger(count)) {
+            return null;
+        }
+        const key = `${campaignId}:${tableId}:${actionType}:${senderId}`;
+        if (senderSeen.has(key))
+            return null;
+        senderSeen.add(key);
+        senderGroups.push({ campaignId, tableId, actionType, senderId, count });
+    }
+    if (senderGroups.reduce((sum, group) => sum + group.count, 0) !== total) {
+        return null;
+    }
+    return {
+        complete: true,
+        truncated: false,
+        total,
+        byCampaignTableActionType: groups,
+        byCampaignTableActionTypeSender: senderGroups,
+    };
+}
+function completeExpectedTargetSummary(value, expectedTargets, maxPlacements) {
+    const summary = recordValue(value);
+    const items = Array.isArray(summary?.items) ? summary.items : [];
+    if (summary?.complete !== true ||
+        summary.truncated !== false ||
+        numberValue(summary.requested) !== expectedTargets.length ||
+        numberValue(summary.included) == null ||
+        numberValue(summary.omitted) == null ||
+        numberValue(summary.included) + numberValue(summary.omitted) !==
+            expectedTargets.length ||
+        numberValue(summary.maxPlacements) !== maxPlacements ||
+        items.length !== expectedTargets.length) {
+        return false;
+    }
+    return items.every((rawItem, index) => {
+        const item = recordValue(rawItem);
+        const target = expectedTargets[index];
+        const senderIds = stringArray(item?.senderIds).sort();
+        const bySender = Array.isArray(item?.bySender) ? item.bySender : [];
+        const accounted = bySender
+            .map((entry) => stringValue(recordValue(entry)?.senderId))
+            .filter((senderId) => Boolean(senderId))
+            .sort();
+        return (Boolean(target) &&
+            item?.campaignId === target?.campaignId &&
+            item?.tableId === target?.tableId &&
+            item?.refillLaneKey === target?.refillLaneKey &&
+            (item?.outcome === "included" || item?.outcome === "omitted") &&
+            JSON.stringify(senderIds) === JSON.stringify(target?.senderIds) &&
+            JSON.stringify(accounted) === JSON.stringify(target?.senderIds));
+    });
+}
+export function normalizeSchedulerPrimitiveResult(value, expected) {
+    const response = recordValue(value);
+    const receipt = recordValue(response?.receipt);
+    const changedCounts = normalizeSchedulerChangedCounts(receipt?.changedCounts ?? response?.changedCounts);
+    const targetAuditComplete = !expected ||
+        (receipt?.receiptVersion === 3 &&
+            receipt.expectedTargetsHash === expected.expectedTargetsHash &&
+            receipt.maxPlacements === expected.maxPlacements &&
+            completeExpectedTargetSummary(receipt.expectedTargetSummary, expected.expectedTargets, expected.maxPlacements));
+    const schedulerStatus = stringValue(response?.status) ?? stringValue(receipt?.status) ?? "unknown";
+    if (!changedCounts || !targetAuditComplete) {
+        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 [];
@@ -225,7 +380,9 @@ export function classifyPaidInmailRefreshReceipt(value) {
         refreshed,
         error: stringValue(response?.error) ??
             stringValue(nestedReceipt?.error) ??
-            (usableCurrentFacts ? null : "paid InMail credit refresh did not return usable current facts"),
+            (usableCurrentFacts
+                ? null
+                : "paid InMail credit refresh did not return usable current facts"),
     };
 }
 export function firstGlobalAction(plan) {
@@ -769,7 +926,67 @@ export async function executeOneYoloPrimitive(action, workspaceId) {
         case "wait_for_scheduler":
         case "wait_for_active_work":
         case "wait_for_source_import":
-            return { status: "read_only_reread", result: waitResultForAction(action) };
+            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);
+            const expectedTargets = Array.isArray(toolInput.expectedTargets)
+                ? toolInput.expectedTargets
+                : [];
+            const expectedTargetsHash = stringValue(toolInput.expectedTargetsHash);
+            const maxPlacements = numberValue(toolInput.maxPlacements);
+            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:senderId" ||
+                receiptRequirements?.expectedTargetSummary !== true ||
+                expectedTargets.length === 0 ||
+                !expectedTargetsHash ||
+                maxPlacements === null ||
+                !Number.isInteger(maxPlacements) ||
+                maxPlacements <= 0) {
+                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,
+                expectedTargets,
+                expectedTargetsHash,
+                maxPlacements,
+            });
+            return {
+                status: "executed_and_reread",
+                result: normalizeSchedulerPrimitiveResult(result, {
+                    expectedTargets,
+                    expectedTargetsHash,
+                    maxPlacements,
+                }),
+            };
+        }
         case "prepare_messages": {
             const campaignId = actionCampaignId(action);
             const tableId = actionTableId(action) ?? undefined;
@@ -791,7 +1008,9 @@ export async function executeOneYoloPrimitive(action, workspaceId) {
                 tableId,
                 ...(workspaceId ? { workspaceId } : {}),
                 targetPreparedMessages,
-                maxRowsToCheck: numberValue(toolInput.maxRowsToCheck) ?? 300,
+                ...(numberValue(toolInput.maxRowsToCheck) != null
+                    ? { maxRowsToCheck: numberValue(toolInput.maxRowsToCheck) }
+                    : {}),
                 approvalMode,
                 rowSelector,
                 ...(excludeRowIds.length > 0 ? { excludeRowIds } : {}),

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

@@ -1,4 +1,4 @@
-type RefillSendsV2Input = {
+export type RefillSendsV2Input = {
     workspaceId?: string;
     runId?: string;
     fence?: number;
@@ -6,6 +6,39 @@ type RefillSendsV2Input = {
     approvalMode?: "approve" | "mark_ready";
     senderIds?: string[];
     intent?: "auto" | "evergreen" | "plain" | "active";
+    targetDate?: string;
+    untilDate?: string;
+    horizonSendDays?: number;
+    scope?: Record<string, unknown>;
+    scopeHash?: string;
+    approval?: Record<string, unknown>;
+    targetPlan?: Record<string, unknown>;
+    approvalEcho?: {
+        scopeHash: string;
+        targetShapeRevision: string;
+        actionFingerprint: string;
+        expectedTargetsHash: string;
+        approvalExpiresAt: string;
+        approvalFingerprint: string;
+    };
+};
+type RefillV2ApprovalPreparationInput = Pick<RefillSendsV2Input, "workspaceId" | "intent" | "senderIds" | "approvalMode" | "targetDate" | "untilDate" | "horizonSendDays"> & {
+    targetPlan: Record<string, unknown>;
+    now?: Date;
+    approvalExpiresAt?: string;
+};
+export declare const REFILL_V2_RUNTIME_IDENTITY: {
+    readonly contract: {
+        readonly version: "2.0.0";
+        readonly hash: string;
+        readonly cacheKey: "refill-contract-v1";
+    };
+    readonly installed: {
+        readonly mcpVersion: "phase98-local";
+        readonly installVersion: "phase98-local";
+        readonly pluginVersion: "phase98-local";
+        readonly cacheIdentity: "phase98-local-plugin-cache";
+    };
 };
 export declare const refillSendsV2ToolDefinitions: {
     name: string;
@@ -44,11 +77,89 @@ export declare const refillSendsV2ToolDefinitions: {
                 type: string;
                 enum: string[];
             };
+            targetDate: {
+                type: string;
+                description: string;
+            };
+            untilDate: {
+                type: string;
+                description: string;
+            };
+            horizonSendDays: {
+                type: string;
+                description: string;
+            };
         };
         required: string[];
         additionalProperties: boolean;
     };
 }[];
+export declare function prepareRefillSendsV2Approval(input: RefillV2ApprovalPreparationInput): Promise<{
+    status: "blocked";
+    blocker: string;
+    response: unknown;
+} | {
+    status: "awaiting_approval";
+    runId: string;
+    fence: number;
+    scope: Record<string, unknown> | {
+        version: 2;
+        workspaceId: string;
+        intent: "active" | "plain" | "evergreen" | "auto";
+        senderIds: string[];
+        campaignIds: string[];
+        tableIds: string[];
+        actionIds: string[];
+        approvalMode: "mark_ready" | "approve";
+        dateSelector: {
+            kind: "target_date";
+            targetDate: string;
+            untilDate?: undefined;
+            horizonSendDays?: undefined;
+        } | {
+            kind: "until_date";
+            untilDate: string;
+            targetDate?: undefined;
+            horizonSendDays?: undefined;
+        } | {
+            kind: "horizon_send_days";
+            horizonSendDays: number;
+            targetDate?: undefined;
+            untilDate?: undefined;
+        } | {
+            kind: "scheduler_default";
+            targetDate?: undefined;
+            untilDate?: undefined;
+            horizonSendDays?: undefined;
+        };
+        senderTimezones: {
+            [k: string]: string;
+        };
+        expectedTargetsHash: string;
+        maxPlacements: number;
+        contract: {
+            version: "2.0.0";
+            hash: string;
+            cacheKey: "refill-contract-v1";
+        };
+        installed: {
+            mcpVersion: "phase98-local";
+            installVersion: "phase98-local";
+            pluginVersion: "phase98-local";
+            cacheIdentity: "phase98-local-plugin-cache";
+        };
+    };
+    approvalFingerprint: string;
+    scopeHash: string;
+    targetShapeRevision: string;
+    actionFingerprint: string;
+    expectedTargetsHash: string;
+    sideEffectEnvelope: string[];
+    maxPlacements: number;
+    approvalExpiresAt: string;
+    blocker?: undefined;
+    response?: undefined;
+}>;
 export declare function refillSendsV2Command(input: RefillSendsV2Input): Promise<{
     readOnly: boolean;
     mode: string;