@sellable/mcp 0.1.513 → 0.1.514

package/dist/tools/refill-executors.js

@@ -0,0 +1,788 @@
+import { getApi, SellableApiError } from "../api.js";
+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 { refreshPaidInmailCredits } from "./senders.js";
+import { workspaceRequestOptions } from "./workspace-context.js";
+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;
+export function normalizeStrings(values) {
+    if (!Array.isArray(values))
+        return [];
+    return [
+        ...new Set(values
+            .map((value) => (typeof value === "string" ? value.trim() : ""))
+            .filter(Boolean)),
+    ];
+}
+export function sleep(ms) {
+    if (!Number.isFinite(ms) || ms <= 0)
+        return Promise.resolve();
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export function recordValue(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+export function stringValue(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+export function numberValue(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+export function stringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((item) => typeof item === "string");
+}
+export 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) } : {}),
+    };
+}
+export 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;
+}
+export 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 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,
+    };
+}
+export 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()];
+}
+export 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);
+}
+export function actionIds(action) {
+    return recordValue(action.ids) ?? {};
+}
+export function actionToolInput(action) {
+    return recordValue(action.toolInput) ?? {};
+}
+export function actionCampaignId(action) {
+    const ids = actionIds(action);
+    const toolInput = actionToolInput(action);
+    return (stringValue(toolInput.campaignId) ??
+        stringValue(toolInput.campaignOfferId) ??
+        stringValue(ids.campaignId) ??
+        stringValue(action.campaignId));
+}
+export function actionTableId(action) {
+    const ids = actionIds(action);
+    const toolInput = actionToolInput(action);
+    return (stringValue(toolInput.tableId) ??
+        stringValue(ids.tableId) ??
+        stringValue(action.tableId));
+}
+export function actionSourceLeadListId(action) {
+    const ids = actionIds(action);
+    const toolInput = actionToolInput(action);
+    return (stringValue(toolInput.sourceLeadListId) ??
+        stringValue(ids.sourceLeadListId) ??
+        stringValue(action.sourceLeadListId));
+}
+export function actionSenderId(action) {
+    const ids = actionIds(action);
+    const toolInput = actionToolInput(action);
+    return (stringValue(toolInput.senderId) ??
+        stringValue(ids.senderId) ??
+        stringValue(action.senderId));
+}
+export 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 rerunErroredCellsOperations(action) {
+    const toolInput = actionToolInput(action);
+    const operations = Array.isArray(toolInput.operations)
+        ? toolInput.operations
+        : [];
+    return operations.flatMap((raw) => {
+        const operation = recordValue(raw);
+        const columnRole = stringValue(operation?.columnRole);
+        if (columnRole !== "icpScore" && columnRole !== "generateMessage") {
+            return [];
+        }
+        const rowSelector = recordValue(operation?.rowSelector);
+        if (rowSelector?.type !== "rowIds")
+            return [];
+        const rowIds = stringArray(rowSelector.rowIds);
+        if (rowIds.length === 0)
+            return [];
+        return [
+            {
+                columnRole,
+                rowSelector: { type: "rowIds", rowIds },
+                cellIds: stringArray(operation?.cellIds),
+            },
+        ];
+    });
+}
+export function actionSourceFingerprint(action) {
+    const ids = actionIds(action);
+    const toolInput = actionToolInput(action);
+    return (stringValue(toolInput.sourceFingerprint) ??
+        stringValue(ids.sourceFingerprint) ??
+        stringValue(action.sourceFingerprint));
+}
+export function actionLeadSourceProvider(action) {
+    const ids = actionIds(action);
+    const toolInput = actionToolInput(action);
+    return (stringValue(toolInput.leadSourceProvider) ??
+        stringValue(toolInput.provider) ??
+        stringValue(ids.leadSourceProvider) ??
+        stringValue(action.leadSourceProvider));
+}
+export 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;
+}
+export 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);
+}
+export function selectedPostIdsFromSignalTabs(tabs) {
+    return uniqueStrings(tabs.flatMap((tab) => (tab.posts ?? [])
+        .filter((post) => post.isSelected === true)
+        .map((post) => post.id)));
+}
+export 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));
+}
+export 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)));
+}
+export 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(":");
+}
+export 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);
+}
+export 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 };
+}
+export 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,
+        },
+    };
+}
+export 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,
+    };
+}
+export async function executeStartCampaignPrimitive(params) {
+    void params.workspaceId;
+    const campaignId = actionCampaignId(params.action);
+    if (params.action.type !== "start_paused_campaign") {
+        return {
+            executed: false,
+            refused: true,
+            reason: "action_type_not_start_paused_campaign",
+            campaignId,
+            laneChainCampaignIds: params.authority.laneChainCampaignIds,
+        };
+    }
+    const authorizedByPinnedCampaign = campaignId !== null && campaignId === params.authority.pinnedCampaignId;
+    if (campaignId &&
+        (params.authority.laneChainCampaignIds.includes(campaignId) ||
+            authorizedByPinnedCampaign)) {
+        try {
+            const result = await startCampaign(campaignId);
+            return {
+                executed: true,
+                type: "start_paused_campaign",
+                campaignId,
+                authorizedBy: {
+                    planRevision: params.authority.planRevision,
+                    action: params.action,
+                },
+                result,
+            };
+        }
+        catch (error) {
+            if (error instanceof SellableApiError) {
+                return {
+                    executed: false,
+                    blocked: true,
+                    reason: "start_route_rejected",
+                    status: error.status,
+                    body: error.body,
+                    campaignId,
+                };
+            }
+            throw error;
+        }
+    }
+    return {
+        executed: false,
+        refused: true,
+        reason: "campaign_not_in_pinned_lane_chain",
+        campaignId,
+        laneChainCampaignIds: params.authority.laneChainCampaignIds,
+    };
+}
+export async function executeRerunErroredCellsPrimitive(params) {
+    if (params.action.type !== "rerun_errored_cells") {
+        return {
+            executed: false,
+            refused: true,
+            reason: "action_type_not_rerun_errored_cells",
+        };
+    }
+    const campaignId = actionCampaignId(params.action);
+    const tableId = actionTableId(params.action);
+    const operations = rerunErroredCellsOperations(params.action);
+    if (!campaignId || !tableId || operations.length === 0) {
+        return {
+            executed: false,
+            refused: true,
+            reason: "missing_bounded_operations",
+        };
+    }
+    const api = getApi();
+    const requestOptions = workspaceRequestOptions(params.workspaceId ?? null);
+    const results = [];
+    for (const operation of operations) {
+        const body = {
+            action: "queue",
+            campaignId,
+            tableId,
+            columnRole: operation.columnRole,
+            rowSelector: operation.rowSelector,
+        };
+        const result = requestOptions
+            ? await api.post("/api/v3/mcp/campaign-processing", body, requestOptions)
+            : await api.post("/api/v3/mcp/campaign-processing", body);
+        results.push({ ...operation, result });
+    }
+    return {
+        executed: true,
+        type: "rerun_errored_cells",
+        operations: results,
+    };
+}
+export 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 "rerun_errored_cells": {
+            const result = await executeRerunErroredCellsPrimitive({
+                action,
+                workspaceId,
+            });
+            if (!result.executed) {
+                return {
+                    status: "refused",
+                    refusalReason: result.reason,
+                };
+            }
+            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`,
+            };
+    }
+}