@sellable/mcp 0.1.512 → 0.1.514

package/dist/tools/refill-sends.js

@@ -1,30 +1,7 @@
-import { getApi, SellableApiError } from "../api.js";
-import { startPrepareCampaignMessages } from "./campaign-message-preparation.js";
-import { confirmLeadList, importLeads, searchSignals, selectPromisingPosts, } from "./leads.js";
-import { markProviderPromptLoaded } from "./provider-preflight.js";
+import { actionIds, collectPaidInmailRefreshActions, executeOneYoloPrimitive, firstGlobalAction, normalizeStrings, numberValue, recordValue, refreshPaidInmailCreditsWithRetry, stringValue, } from "./refill-executors.js";
 import { getRefillTargetPlan } from "./refill-target-plan.js";
-import { refreshPaidInmailCredits } from "./senders.js";
-import { createWorkspaceContext, normalizeExplicitWorkspaceId, workspaceRequestOptions, } from "./workspace-context.js";
+import { createWorkspaceContext, normalizeExplicitWorkspaceId, } from "./workspace-context.js";
 const DEFAULT_SCHEDULER_FORWARD_HOURS = 48;
-const PAID_INMAIL_REFRESH_MAX_ATTEMPTS = 3;
-const PAID_INMAIL_REFRESH_RETRY_DELAY_MS = Number(process.env.SELLABLE_MCP_PAID_REFRESH_RETRY_DELAY_MS ?? "1000");
-const SIGNAL_DISCOVERY_MIN_REFILL_POSTS = 3;
-const SIGNAL_DISCOVERY_MAX_REFILL_POSTS = 10;
-const SIGNAL_DISCOVERY_TARGET_ROWS_PER_POST = 150;
-function normalizeStrings(values) {
-    if (!Array.isArray(values))
-        return [];
-    return [
-        ...new Set(values
-            .map((value) => (typeof value === "string" ? value.trim() : ""))
-            .filter(Boolean)),
-    ];
-}
-function sleep(ms) {
-    if (!Number.isFinite(ms) || ms <= 0)
-        return Promise.resolve();
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
 function normalizeHorizonSendDays(value) {
     if (value === undefined || value === null)
         return null;
@@ -70,20 +47,6 @@ function normalizeTargetDate(value) {
     }
     return trimmed;
 }
-function userAddedRowsLimitPayloadFromError(error) {
-    if (!(error instanceof SellableApiError) || error.status !== 400) {
-        return null;
-    }
-    try {
-        const parsed = JSON.parse(error.body);
-        if (parsed?.code !== "USER_ADDED_ROWS_LIMIT_EXCEEDED")
-            return null;
-        return parsed;
-    }
-    catch {
-        return null;
-    }
-}
 export const refillSendsToolDefinitions = [
     {
         name: "refill_sends",
@@ -350,67 +313,6 @@ function targetPlanInputFor(input = {}) {
         ...(workspaceId ? { workspaceId } : {}),
     };
 }
-function recordValue(value) {
-    return value && typeof value === "object" && !Array.isArray(value)
-        ? value
-        : null;
-}
-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 stringArray(value) {
-    if (!Array.isArray(value))
-        return [];
-    return value.filter((item) => typeof item === "string");
-}
-function prepareRowSelectorValue(value) {
-    const selector = recordValue(value);
-    const type = stringValue(selector?.type);
-    if (type !== "needsEnrichment" &&
-        type !== "needsApproval" &&
-        type !== "needsGeneratedMessage" &&
-        type !== "reviewBatch" &&
-        type !== "staleGeneratedMessages") {
-        return undefined;
-    }
-    const limit = numberValue(selector?.limit);
-    return {
-        type,
-        ...(limit && limit > 0 ? { limit: Math.floor(limit) } : {}),
-    };
-}
-function uniqueStrings(values) {
-    const seen = new Set();
-    const result = [];
-    for (const value of values) {
-        const normalized = typeof value === "string" ? value.trim() : "";
-        if (!normalized)
-            continue;
-        const key = normalized.toLowerCase();
-        if (seen.has(key))
-            continue;
-        seen.add(key);
-        result.push(normalized);
-    }
-    return result;
-}
-function paidRefreshActionFrom(value) {
-    const action = recordValue(value);
-    if (!action || action.type !== "refresh_paid_inmail_credits")
-        return null;
-    const ids = recordValue(action.ids);
-    const senderId = stringValue(ids?.senderId) ?? stringValue(action.senderId);
-    if (!senderId)
-        return null;
-    return {
-        senderId,
-        actionKey: stringValue(action.actionKey),
-        action,
-    };
-}
 function targetPlanFingerprint(plan) {
     const root = recordValue(plan);
     return {
@@ -440,563 +342,6 @@ function paidRefreshApprovalPacket(params) {
         targetPlanFingerprint: targetPlanFingerprint(params.targetPlan),
     };
 }
-function collectPaidInmailRefreshActions(plan) {
-    const root = recordValue(plan);
-    const target = recordValue(root?.target);
-    const bySender = new Map();
-    const add = (candidate) => {
-        const action = paidRefreshActionFrom(candidate);
-        if (action && !bySender.has(action.senderId)) {
-            bySender.set(action.senderId, action);
-        }
-    };
-    const senderPlans = Array.isArray(target?.senderRefillPlans)
-        ? target.senderRefillPlans
-        : [];
-    for (const senderPlan of senderPlans) {
-        const planRecord = recordValue(senderPlan);
-        const nextActions = Array.isArray(planRecord?.nextActions)
-            ? planRecord.nextActions
-            : [];
-        for (const action of nextActions)
-            add(action);
-        const paidInmail = recordValue(planRecord?.paidInmail);
-        const paidStatus = stringValue(paidInmail?.status);
-        const senderId = stringValue(planRecord?.senderId) ?? stringValue(paidInmail?.senderId);
-        if (senderId &&
-            (paidStatus === "missing_credit_facts" ||
-                paidStatus === "stale_credit_facts")) {
-            add({
-                type: "refresh_paid_inmail_credits",
-                actionKey: [
-                    "refresh_paid_inmail_credits",
-                    senderId,
-                    stringValue(paidInmail?.campaignId) ?? "unknown",
-                    stringValue(paidInmail?.columnId) ?? "unknown",
-                ].join(":"),
-                actionType: "send_inmail_closed",
-                senderId,
-                campaignId: stringValue(paidInmail?.campaignId) ?? undefined,
-                tableId: stringValue(paidInmail?.tableId) ?? undefined,
-                columnId: stringValue(paidInmail?.columnId) ?? undefined,
-                oldThreshold: numberValue(paidInmail?.threshold) ?? undefined,
-                maxStalenessSeconds: numberValue(paidInmail?.maxStalenessSeconds) ?? undefined,
-                ids: {
-                    senderId,
-                    campaignId: stringValue(paidInmail?.campaignId) ?? undefined,
-                    tableId: stringValue(paidInmail?.tableId) ?? undefined,
-                    columnId: stringValue(paidInmail?.columnId) ?? undefined,
-                },
-            });
-        }
-    }
-    const globalActionQueue = Array.isArray(target?.globalActionQueue)
-        ? target.globalActionQueue
-        : [];
-    for (const action of globalActionQueue)
-        add(action);
-    const actionCandidates = Array.isArray(root?.actionCandidates)
-        ? root.actionCandidates
-        : [];
-    for (const action of actionCandidates)
-        add(action);
-    return [...bySender.values()];
-}
-function firstGlobalAction(plan) {
-    const root = recordValue(plan);
-    const target = recordValue(root?.target);
-    const globalActionQueue = Array.isArray(target?.globalActionQueue)
-        ? target.globalActionQueue
-        : [];
-    const [first] = globalActionQueue;
-    return recordValue(first);
-}
-function actionIds(action) {
-    return recordValue(action.ids) ?? {};
-}
-function actionToolInput(action) {
-    return recordValue(action.toolInput) ?? {};
-}
-function actionCampaignId(action) {
-    const ids = actionIds(action);
-    const toolInput = actionToolInput(action);
-    return (stringValue(toolInput.campaignId) ??
-        stringValue(toolInput.campaignOfferId) ??
-        stringValue(ids.campaignId) ??
-        stringValue(action.campaignId));
-}
-function actionTableId(action) {
-    const ids = actionIds(action);
-    const toolInput = actionToolInput(action);
-    return (stringValue(toolInput.tableId) ??
-        stringValue(ids.tableId) ??
-        stringValue(action.tableId));
-}
-function actionSourceLeadListId(action) {
-    const ids = actionIds(action);
-    const toolInput = actionToolInput(action);
-    return (stringValue(toolInput.sourceLeadListId) ??
-        stringValue(ids.sourceLeadListId) ??
-        stringValue(action.sourceLeadListId));
-}
-function actionSenderId(action) {
-    const ids = actionIds(action);
-    const toolInput = actionToolInput(action);
-    return (stringValue(toolInput.senderId) ??
-        stringValue(ids.senderId) ??
-        stringValue(action.senderId));
-}
-function actionActionType(action) {
-    const ids = actionIds(action);
-    const toolInput = actionToolInput(action);
-    return (stringValue(toolInput.actionType) ??
-        stringValue(toolInput.selectedLane) ??
-        stringValue(ids.actionType) ??
-        stringValue(action.actionType) ??
-        stringValue(action.selectedLane));
-}
-function actionSourceFingerprint(action) {
-    const ids = actionIds(action);
-    const toolInput = actionToolInput(action);
-    return (stringValue(toolInput.sourceFingerprint) ??
-        stringValue(ids.sourceFingerprint) ??
-        stringValue(action.sourceFingerprint));
-}
-function actionLeadSourceProvider(action) {
-    const ids = actionIds(action);
-    const toolInput = actionToolInput(action);
-    return (stringValue(toolInput.leadSourceProvider) ??
-        stringValue(toolInput.provider) ??
-        stringValue(ids.leadSourceProvider) ??
-        stringValue(action.leadSourceProvider));
-}
-function normalizedSignalKeyword(value) {
-    if (typeof value !== "string")
-        return null;
-    const keyword = value.trim();
-    if (!keyword)
-        return null;
-    if (/^(https?:\/\/|www\.|linkedin\.com\/|\/?in\/)/i.test(keyword)) {
-        return null;
-    }
-    return keyword;
-}
-function keywordsFromSignalTabs(tabs) {
-    const selectedKeywords = [];
-    const fallbackKeywords = [];
-    for (const tab of tabs) {
-        const keyword = normalizedSignalKeyword(tab.keyword);
-        if (!keyword)
-            continue;
-        const selected = (tab.posts ?? []).some((post) => post.isSelected === true);
-        if (selected) {
-            selectedKeywords.push(keyword);
-        }
-        else {
-            fallbackKeywords.push(keyword);
-        }
-    }
-    return uniqueStrings([...selectedKeywords, ...fallbackKeywords]).slice(0, 5);
-}
-function selectedPostIdsFromSignalTabs(tabs) {
-    return uniqueStrings(tabs.flatMap((tab) => (tab.posts ?? [])
-        .filter((post) => post.isSelected === true)
-        .map((post) => post.id)));
-}
-function postIdsFromSignalSearch(summary, maxPosts, options = {}) {
-    const excludedPostIds = new Set((options.excludePostIds ?? []).map((postId) => postId.toLowerCase()));
-    const recommendedPostIds = stringArray(summary?.recommendedPostIds);
-    const topPostIds = Array.isArray(summary?.topPosts)
-        ? summary.topPosts
-            .map((post) => post && typeof post === "object"
-            ? stringValue(post.id)
-            : null)
-            .filter((id) => Boolean(id))
-        : [];
-    return uniqueStrings([...recommendedPostIds, ...topPostIds])
-        .filter((postId) => !excludedPostIds.has(postId.toLowerCase()))
-        .slice(0, Math.max(1, maxPosts));
-}
-function maxSignalDiscoveryPostsForSourceLimit(sourceRowLimit) {
-    return Math.min(SIGNAL_DISCOVERY_MAX_REFILL_POSTS, Math.max(SIGNAL_DISCOVERY_MIN_REFILL_POSTS, Math.ceil(sourceRowLimit / SIGNAL_DISCOVERY_TARGET_ROWS_PER_POST)));
-}
-function refillPrepareRequestHash(params) {
-    return [
-        "refill_sends",
-        "prepare_messages",
-        params.campaignId,
-        params.tableId ?? "no-table",
-        actionSenderId(params.action) ?? "all-senders",
-        actionSourceLeadListId(params.action) ?? "no-source-list",
-        actionActionType(params.action) ?? "no-action-type",
-        params.approvalMode,
-        params.rowSelector
-            ? `${params.rowSelector.type}:${params.rowSelector.limit ?? "no-limit"}`
-            : "no-row-selector",
-    ].join(":");
-}
-function boundedApprovalLimit(action) {
-    const toolInput = actionToolInput(action);
-    const rowSelector = recordValue(toolInput.rowSelector);
-    const selectorLimit = numberValue(rowSelector?.limit);
-    const inputLimit = numberValue(toolInput.limit);
-    const limit = selectorLimit ?? inputLimit;
-    if (!limit || limit <= 0)
-        return null;
-    return Math.floor(limit);
-}
-async function approveGeneratedMessagesBatch(action, workspaceId) {
-    const tableId = actionTableId(action);
-    const toolInput = actionToolInput(action);
-    const columnId = stringValue(toolInput.columnId) ?? stringValue(actionIds(action).columnId);
-    const limit = boundedApprovalLimit(action);
-    if (!tableId || !limit) {
-        return {
-            status: "refused",
-            refusalReason: "approve_messages action is missing tableId or a bounded rowSelector.limit",
-        };
-    }
-    const api = getApi();
-    const requestOptions = workspaceRequestOptions(workspaceId);
-    const result = await api.post("/api/v3/workflow-tables/cells/approve-batch", {
-        tableId,
-        ...(columnId ? { columnId } : {}),
-        limit,
-        scope: "generated_unapproved",
-        ...(workspaceId ? { workspaceId } : {}),
-    }, requestOptions);
-    return { status: "executed_and_reread", result };
-}
-async function continueSignalDiscoverySource(action, workspaceId) {
-    const campaignOfferId = actionCampaignId(action);
-    const sourceLeadListId = actionSourceLeadListId(action);
-    const sourceFingerprint = actionSourceFingerprint(action);
-    const toolInput = actionToolInput(action);
-    const sourceRowLimit = Math.min(1500, Math.max(100, Math.floor(numberValue(toolInput.sourceRowLimit) ??
-        numberValue(toolInput.targetRows) ??
-        numberValue(action.targetRows) ??
-        100)));
-    const maxPostsToScrape = maxSignalDiscoveryPostsForSourceLimit(sourceRowLimit);
-    if (!campaignOfferId || !sourceLeadListId || !sourceFingerprint) {
-        return {
-            status: "refused",
-            refusalReason: "continue_signal_discovery_source action is missing campaignOfferId, sourceLeadListId, or sourceFingerprint",
-        };
-    }
-    const requestedProvider = actionLeadSourceProvider(action);
-    if (requestedProvider &&
-        requestedProvider !== "signal-discovery" &&
-        requestedProvider !== "campaign-tracked-post") {
-        return {
-            status: "refused",
-            refusalReason: "continue_signal_discovery_source can only run for Signal Discovery source families",
-        };
-    }
-    const api = getApi();
-    const requestOptions = workspaceRequestOptions(workspaceId);
-    const campaign = await api.get(`/api/v2/campaign-offers/${campaignOfferId}`, requestOptions);
-    if (campaign.leadSourceProvider !== "signal-discovery" &&
-        campaign.leadSourceProvider !== "campaign-tracked-post") {
-        return {
-            status: "refused",
-            refusalReason: "campaign leadSourceProvider is not Signal Discovery; refusing same-source continuation",
-        };
-    }
-    if (campaign.selectedLeadListId &&
-        campaign.selectedLeadListId !== sourceLeadListId) {
-        return {
-            status: "refused",
-            refusalReason: "campaign selectedLeadListId changed since the plan packet; rerun get_refill_target_plan before source continuation",
-        };
-    }
-    const sourceMeta = await api.get(`/api/v3/workflow-tables/${sourceLeadListId}?mode=meta`, requestOptions);
-    const sourceConfig = sourceMeta.table?.config ?? null;
-    const headlineICPCriteria = stringArray(sourceConfig?.headlineICPCriteria).length > 0
-        ? stringArray(sourceConfig?.headlineICPCriteria)
-        : stringArray(sourceConfig?.rubricGuidelines);
-    const tabsResponse = await api.get(`/api/v3/campaigns/${campaignOfferId}/signal-discovery/tabs`, requestOptions);
-    const signalTabs = tabsResponse.tabs ?? [];
-    const keywords = keywordsFromSignalTabs(signalTabs);
-    const excludedPostIds = selectedPostIdsFromSignalTabs(signalTabs);
-    if (keywords.length === 0) {
-        return {
-            status: "refused",
-            refusalReason: "no reusable Signal Discovery keywords were found on the campaign tabs",
-        };
-    }
-    markProviderPromptLoaded({
-        provider: "signal-discovery",
-        campaignOfferId,
-    });
-    const searchSummary = await searchSignals({
-        type: "keywords",
-        keywords: keywords.map((keyword) => ({
-            keyword,
-            source: "refill-sends-source-continuation",
-        })),
-        campaignOfferId,
-        currentStep: null,
-        headlineICPCriteria,
-        rubricGuidelines: headlineICPCriteria,
-        confirmed: true,
-        limit: 50,
-        ...(workspaceId ? { workspaceId } : {}),
-    });
-    const selectedPostIds = postIdsFromSignalSearch(searchSummary, maxPostsToScrape, { excludePostIds: excludedPostIds });
-    if (selectedPostIds.length === 0) {
-        return {
-            status: "refused",
-            refusalReason: "Signal Discovery search returned no new recommended posts to continue the source",
-            result: { keywords, excludedPostIds, searchSummary },
-        };
-    }
-    const selectionResult = await selectPromisingPosts({
-        campaignOfferId,
-        selections: selectedPostIds.map((postId) => ({
-            postId,
-            reason: "refill_sends same-source continuation: recent post from the campaign's existing Signal Discovery keyword family",
-        })),
-        headlineICPCriteria,
-        currentStep: null,
-        selectionMode: "replace",
-        scrapePlanMode: "all-selected",
-        ...(workspaceId ? { workspaceId } : {}),
-    });
-    if (selectionResult.success === false) {
-        return {
-            status: "refused",
-            refusalReason: stringValue(selectionResult.message) ??
-                "select_promising_posts did not select any posts",
-            result: { keywords, selectedPostIds, selectionResult },
-        };
-    }
-    const importResult = await importLeads({
-        campaignOfferId,
-        provider: "signal-discovery",
-        sourceLeadListId,
-        currentStep: null,
-        headlineICPCriteria,
-        rubricGuidelines: headlineICPCriteria,
-        confirmed: true,
-        maxPostsToScrape: selectedPostIds.length,
-        allowInvalidSignalPosts: true,
-        ...(workspaceId ? { workspaceId } : {}),
-    });
-    const importRecord = recordValue(importResult);
-    if (importRecord?.error) {
-        return {
-            status: "refused",
-            refusalReason: stringValue(importRecord.message) ??
-                `Signal Discovery import returned ${String(importRecord.error)}`,
-            result: {
-                keywords,
-                excludedPostIds,
-                selectedPostIds,
-                selectionResult,
-                importResult,
-            },
-        };
-    }
-    return {
-        status: "executed_and_reread",
-        result: {
-            provider: "signal-discovery",
-            campaignOfferId,
-            previousSourceLeadListId: sourceLeadListId,
-            sourceFingerprint,
-            keywords,
-            excludedPostIds,
-            selectedPostIds,
-            sourceRowLimit,
-            maxPostsToScrape: selectedPostIds.length,
-            searchSummary,
-            selectionResult,
-            importResult,
-        },
-    };
-}
-async function refreshPaidInmailCreditsWithRetry(senderId, workspaceId) {
-    const errors = [];
-    for (let attempt = 1; attempt <= PAID_INMAIL_REFRESH_MAX_ATTEMPTS; attempt += 1) {
-        try {
-            const receipt = await refreshPaidInmailCredits({
-                senderId,
-                workspaceId,
-            });
-            return { receipt, attempts: attempt, errors };
-        }
-        catch (error) {
-            errors.push(error instanceof Error ? error.message : String(error));
-            if (attempt < PAID_INMAIL_REFRESH_MAX_ATTEMPTS) {
-                await sleep(PAID_INMAIL_REFRESH_RETRY_DELAY_MS);
-            }
-        }
-    }
-    return {
-        receipt: null,
-        attempts: PAID_INMAIL_REFRESH_MAX_ATTEMPTS,
-        errors,
-    };
-}
-async function executeOneYoloPrimitive(action, workspaceId) {
-    if (!action)
-        return { status: "no_action" };
-    if (action.yoloEligible === false) {
-        return {
-            status: "refused",
-            refusalReason: "first global action is not yolo eligible",
-        };
-    }
-    switch (action.type) {
-        case "wait_for_scheduler":
-        case "wait_for_active_work":
-        case "wait_for_source_import":
-            return { status: "read_only_reread", result: { waited: true } };
-        case "prepare_messages": {
-            const campaignId = actionCampaignId(action);
-            const tableId = actionTableId(action) ?? undefined;
-            const toolInput = actionToolInput(action);
-            const targetPreparedMessages = numberValue(toolInput.targetPreparedMessages);
-            const rowSelector = prepareRowSelectorValue(toolInput.rowSelector);
-            const approvalMode = toolInput.approvalMode === "approve" ? "approve" : "mark_ready";
-            if (!campaignId ||
-                !targetPreparedMessages ||
-                targetPreparedMessages <= 0) {
-                return {
-                    status: "refused",
-                    refusalReason: "prepare_messages action is missing campaignId or bounded targetPreparedMessages",
-                };
-            }
-            const result = await startPrepareCampaignMessages({
-                campaignId,
-                tableId,
-                ...(workspaceId ? { workspaceId } : {}),
-                targetPreparedMessages,
-                maxRowsToCheck: numberValue(toolInput.maxRowsToCheck) ?? 300,
-                approvalMode,
-                rowSelector,
-                autoContinue: true,
-                disableLowPassRateStop: true,
-                senderId: actionSenderId(action) ?? undefined,
-                actionType: actionActionType(action) ?? undefined,
-                requestHash: refillPrepareRequestHash({
-                    action,
-                    campaignId,
-                    tableId,
-                    approvalMode,
-                    rowSelector,
-                }),
-                requestSource: "refill_sends",
-            });
-            return { status: "executed_and_reread", result };
-        }
-        case "copy_selected_source_rows": {
-            const campaignOfferId = actionCampaignId(action);
-            const sourceLeadListId = actionSourceLeadListId(action);
-            const toolInput = actionToolInput(action);
-            const sourceRowIds = stringArray(toolInput.sourceRowIds);
-            const sourceRowLimit = numberValue(toolInput.sourceRowLimit);
-            const sourceFingerprint = stringValue(toolInput.sourceFingerprint) ??
-                stringValue(actionIds(action).sourceFingerprint);
-            if (!campaignOfferId || !sourceLeadListId || !sourceFingerprint) {
-                return {
-                    status: "refused",
-                    refusalReason: "copy_selected_source_rows action is missing campaignOfferId, sourceLeadListId, or sourceFingerprint",
-                };
-            }
-            if (sourceRowIds.length === 0 &&
-                (!sourceRowLimit || sourceRowLimit <= 0)) {
-                return {
-                    status: "refused",
-                    refusalReason: "copy_selected_source_rows action is missing exact sourceRowIds or a bounded sourceRowLimit",
-                };
-            }
-            const copyInput = {
-                campaignOfferId,
-                sourceLeadListId,
-                currentStep: null,
-                confirmed: true,
-                ...(workspaceId ? { workspaceId } : {}),
-                sourceRowIds: sourceRowIds.length > 0 ? sourceRowIds : undefined,
-                sourceRowLimit: sourceRowIds.length > 0 ? undefined : (sourceRowLimit ?? undefined),
-                reviewBatchLimit: sourceRowIds.length > 0
-                    ? sourceRowIds.length
-                    : (sourceRowLimit ?? undefined),
-            };
-            let result;
-            try {
-                result = await confirmLeadList(copyInput);
-            }
-            catch (error) {
-                const rowLimitPayload = userAddedRowsLimitPayloadFromError(error);
-                if (!rowLimitPayload)
-                    throw error;
-                const remainingRows = typeof rowLimitPayload.remainingRows === "number" &&
-                    Number.isFinite(rowLimitPayload.remainingRows)
-                    ? Math.floor(rowLimitPayload.remainingRows)
-                    : 0;
-                if (remainingRows <= 0) {
-                    return {
-                        status: "refused",
-                        refusalReason: rowLimitPayload.error ??
-                            "selected campaign table is at the workflow row limit",
-                    };
-                }
-                const retrySourceRowIds = sourceRowIds.length > 0 ? sourceRowIds.slice(0, remainingRows) : [];
-                const retrySourceRowLimit = retrySourceRowIds.length > 0
-                    ? undefined
-                    : Math.min(sourceRowLimit ?? remainingRows, remainingRows);
-                const retryReviewBatchLimit = retrySourceRowIds.length > 0
-                    ? retrySourceRowIds.length
-                    : retrySourceRowLimit;
-                if (!retryReviewBatchLimit || retryReviewBatchLimit <= 0) {
-                    return {
-                        status: "refused",
-                        refusalReason: rowLimitPayload.error ??
-                            "selected campaign table cannot accept more workflow rows",
-                    };
-                }
-                const retryResult = await confirmLeadList({
-                    ...copyInput,
-                    sourceRowIds: retrySourceRowIds.length > 0 ? retrySourceRowIds : undefined,
-                    sourceRowLimit: retrySourceRowIds.length > 0 ? undefined : retrySourceRowLimit,
-                    reviewBatchLimit: retryReviewBatchLimit,
-                });
-                result =
-                    retryResult && typeof retryResult === "object"
-                        ? {
-                            ...retryResult,
-                            rowLimitRetry: {
-                                code: rowLimitPayload.code,
-                                maxRows: rowLimitPayload.maxRows,
-                                currentRows: rowLimitPayload.currentRows,
-                                requestedRows: rowLimitPayload.requestedRows,
-                                remainingRows,
-                                retriedRows: retryReviewBatchLimit,
-                            },
-                        }
-                        : {
-                            result: retryResult,
-                            rowLimitRetry: {
-                                code: rowLimitPayload.code,
-                                remainingRows,
-                                retriedRows: retryReviewBatchLimit,
-                            },
-                        };
-            }
-            return { status: "executed_and_reread", result };
-        }
-        case "continue_signal_discovery_source":
-            return continueSignalDiscoverySource(action, workspaceId);
-        case "approve_messages":
-            return approveGeneratedMessagesBatch(action, workspaceId);
-        default:
-            return {
-                status: "refused",
-                refusalReason: `action ${String(action.type)} is not a safe yolo primitive`,
-            };
-    }
-}
 export async function executeRefillSendsCommand(input = {}) {
     const yolo = input.yolo === true;
     const executionMode = input.executionMode ?? (yolo ? "yolo" : "manual");