@sellable/mcp 0.1.467 → 0.1.468

package/dist/tools/refill-target-plan.js

@@ -1,8 +1,234 @@
 import { getApi } from "../api.js";
+const REFILL_TARGET_ACTION_TYPES = [
+    "send_invite",
+    "send_inmail_closed",
+];
+const REFILL_TARGET_ACTION_SET = new Set(REFILL_TARGET_ACTION_TYPES);
 async function postRefillTargetPlan(body) {
     const api = getApi();
     return api.post("/api/v3/mcp/refill-target-plan", body);
 }
+function isRecord(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function allowedActionType(value) {
+    return typeof value === "string" && REFILL_TARGET_ACTION_SET.has(value)
+        ? value
+        : null;
+}
+function actionTypesFrom(value) {
+    if (!Array.isArray(value))
+        return [];
+    return [...new Set(value.map(allowedActionType).filter(Boolean))];
+}
+function numberValue(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function evidenceLatestMs(evidence) {
+    const latestAt = evidence.latestAt;
+    if (typeof latestAt !== "string")
+        return 0;
+    const timestamp = new Date(latestAt).getTime();
+    return Number.isFinite(timestamp) ? timestamp : 0;
+}
+function chooseEvidenceAction(evidence, fallback) {
+    const byAction = new Map();
+    for (const item of evidence) {
+        if (!isRecord(item))
+            continue;
+        const actionType = allowedActionType(item.actionType);
+        if (!actionType)
+            continue;
+        const current = byAction.get(actionType) ?? { count: 0, latestMs: 0 };
+        current.count += numberValue(item.count);
+        current.latestMs = Math.max(current.latestMs, evidenceLatestMs(item));
+        byAction.set(actionType, current);
+    }
+    const [best] = [...byAction.entries()].sort((a, b) => {
+        if (a[1].latestMs !== b[1].latestMs)
+            return b[1].latestMs - a[1].latestMs;
+        if (a[1].count !== b[1].count)
+            return b[1].count - a[1].count;
+        return (REFILL_TARGET_ACTION_TYPES.indexOf(a[0]) -
+            REFILL_TARGET_ACTION_TYPES.indexOf(b[0]));
+    });
+    return best?.[0] ?? fallback[0] ?? null;
+}
+function senderActionKey(senderId, actionType) {
+    return typeof senderId === "string" && typeof actionType === "string"
+        ? `${senderId}:${actionType}`
+        : null;
+}
+function sanitizeCounts(counts, selectedKeys) {
+    if (!Array.isArray(counts))
+        return [];
+    return counts.filter((item) => {
+        if (!isRecord(item))
+            return false;
+        const actionType = allowedActionType(item.actionType);
+        const key = senderActionKey(item.senderId, actionType);
+        return Boolean(key && selectedKeys.has(key));
+    });
+}
+function sanitizeActionCandidates(candidates, selectedKeys, status, remainingReadyOrProjectedGap, remainingProjectedGap) {
+    const filtered = Array.isArray(candidates)
+        ? candidates.filter((item) => {
+            if (!isRecord(item))
+                return false;
+            const actionType = item.actionType;
+            if (actionType === undefined)
+                return item.type === "wait_for_scheduler";
+            const allowed = allowedActionType(actionType);
+            const key = senderActionKey(item.senderId, allowed);
+            return Boolean(key && selectedKeys.has(key));
+        })
+        : [];
+    if (status === "awaiting_scheduler_after_ready_buffer" &&
+        remainingProjectedGap > 0 &&
+        remainingReadyOrProjectedGap === 0 &&
+        !filtered.some((item) => item.type === "wait_for_scheduler")) {
+        filtered.push({
+            type: "wait_for_scheduler",
+            reason: "ready buffer covers the projected target gap but scheduledFor coverage is still short",
+        });
+    }
+    return filtered;
+}
+function sanitizeBlockers(blockers, selectedKeys) {
+    if (!Array.isArray(blockers))
+        return [];
+    return blockers.filter((item) => {
+        if (!isRecord(item))
+            return false;
+        const detail = item.detail;
+        const code = String(item.code ?? "");
+        if (typeof detail !== "string")
+            return true;
+        const detailSenderId = detail.split(":")[0];
+        if (code.startsWith("paid_inmail_")) {
+            return selectedKeys.has(`${detailSenderId}:send_inmail_closed`);
+        }
+        if (detail.includes(":send_dm") || detail.includes(":send_inmail_open")) {
+            return false;
+        }
+        const parts = detail.split(":");
+        if (parts.length < 2)
+            return true;
+        const actionType = allowedActionType(parts[parts.length - 1]);
+        if (!actionType)
+            return true;
+        const senderId = parts[0];
+        return selectedKeys.size === 0 || selectedKeys.has(`${senderId}:${actionType}`);
+    });
+}
+function sanitizeRefillTargetPlanResult(result) {
+    if (!isRecord(result) || !isRecord(result.target))
+        return result;
+    const target = result.target;
+    const rawSelections = Array.isArray(target.actionSelections)
+        ? target.actionSelections
+        : [];
+    const rawSenderPlans = Array.isArray(target.senderPlans)
+        ? target.senderPlans
+        : [];
+    const selectedBySender = new Map();
+    for (const rawSelection of rawSelections) {
+        if (!isRecord(rawSelection) || typeof rawSelection.senderId !== "string") {
+            continue;
+        }
+        const fallback = actionTypesFrom(rawSelection.actionTypes);
+        const evidence = Array.isArray(rawSelection.evidence)
+            ? rawSelection.evidence
+            : [];
+        const chosen = chooseEvidenceAction(evidence, fallback);
+        if (chosen)
+            selectedBySender.set(rawSelection.senderId, chosen);
+    }
+    for (const rawPlan of rawSenderPlans) {
+        if (!isRecord(rawPlan) ||
+            typeof rawPlan.senderId !== "string" ||
+            selectedBySender.has(rawPlan.senderId)) {
+            continue;
+        }
+        const actionType = allowedActionType(rawPlan.actionType);
+        if (actionType)
+            selectedBySender.set(rawPlan.senderId, actionType);
+    }
+    const selectedKeys = new Set([...selectedBySender.entries()].map(([senderId, actionType]) => `${senderId}:${actionType}`));
+    const actionTypes = [...new Set(selectedBySender.values())];
+    if (selectedKeys.size === 0)
+        return result;
+    const senderPlans = rawSenderPlans.filter((plan) => isRecord(plan) &&
+        selectedKeys.has(`${String(plan.senderId)}:${String(plan.actionType)}`));
+    const selectedDays = Array.isArray(target.selectedDays)
+        ? target.selectedDays.filter((day) => isRecord(day) &&
+            selectedKeys.has(`${String(day.senderId)}:${String(day.actionType)}`))
+        : [];
+    const actionSelections = rawSelections
+        .filter((selection) => isRecord(selection) &&
+        typeof selection.senderId === "string" &&
+        selectedBySender.has(selection.senderId))
+        .map((selection) => {
+        const actionType = selectedBySender.get(selection.senderId);
+        const evidence = Array.isArray(selection.evidence)
+            ? selection.evidence.filter((item) => isRecord(item) && item.actionType === actionType)
+            : [];
+        return {
+            ...selection,
+            actionTypes: actionType ? [actionType] : [],
+            evidence,
+        };
+    });
+    const grossTarget = senderPlans.reduce((sum, plan) => sum + numberValue(plan.grossTarget), 0);
+    const sent = senderPlans.reduce((sum, plan) => sum + numberValue(plan.sent), 0);
+    const scheduled = senderPlans.reduce((sum, plan) => sum + numberValue(plan.scheduled), 0);
+    const projected = sent + scheduled;
+    const readyBuffer = senderPlans.reduce((sum, plan) => sum + numberValue(plan.readyBuffer), 0);
+    const remainingScheduledGap = senderPlans.reduce((sum, plan) => sum + numberValue(plan.remainingScheduledGap), 0);
+    const remainingProjectedGap = senderPlans.reduce((sum, plan) => sum + numberValue(plan.remainingProjectedGap), 0);
+    const remainingReadyOrProjectedGap = senderPlans.reduce((sum, plan) => sum + numberValue(plan.remainingReadyOrProjectedGap), 0);
+    const blockers = sanitizeBlockers(result.blockers, selectedKeys);
+    const status = blockers.some((blocker) => ["sender_disconnected", "sender_sales_nav_disconnected"].includes(String(blocker.code))) || grossTarget <= 0
+        ? "blocked"
+        : remainingProjectedGap === 0
+            ? "complete"
+            : remainingReadyOrProjectedGap === 0
+                ? "awaiting_scheduler_after_ready_buffer"
+                : "needs_refill";
+    return {
+        ...result,
+        status,
+        request: isRecord(result.request)
+            ? { ...result.request, actionTypes }
+            : result.request,
+        target: {
+            ...target,
+            actionSelections,
+            selectedDays,
+            senderPlans,
+            grossTarget,
+            sent,
+            scheduled,
+            projected,
+            readyBuffer,
+            remainingScheduledGap,
+            remainingProjectedGap,
+            remainingReadyOrProjectedGap,
+            remainingReadyOrScheduledGap: remainingReadyOrProjectedGap,
+        },
+        coverage: isRecord(result.coverage)
+            ? {
+                ...result.coverage,
+                sentCounts: sanitizeCounts(result.coverage.sentCounts, selectedKeys),
+                scheduledCounts: sanitizeCounts(result.coverage.scheduledCounts, selectedKeys),
+                readyCounts: sanitizeCounts(result.coverage.readyCounts, selectedKeys),
+            }
+            : result.coverage,
+        actionCandidates: sanitizeActionCandidates(result.actionCandidates, selectedKeys, status, remainingReadyOrProjectedGap, remainingProjectedGap),
+        blockers,
+        mcpSanitizedRefillLanes: true,
+    };
+}
 export const refillTargetPlanToolDefinitions = [
     {
         name: "get_refill_target_plan",
@@ -68,8 +294,8 @@ export const refillTargetPlanToolDefinitions = [
         },
     },
 ];
-export function getRefillTargetPlan(input = {}) {
-    return postRefillTargetPlan({
+export async function getRefillTargetPlan(input = {}) {
+    const result = await postRefillTargetPlan({
         intent: input.intent,
         horizonSendDays: input.horizonSendDays,
         untilDate: input.untilDate,
@@ -81,4 +307,5 @@ export function getRefillTargetPlan(input = {}) {
         actionTypes: input.actionTypes,
         approvalMode: input.approvalMode,
     });
+    return sanitizeRefillTargetPlanResult(result);
 }

package/package.json

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