@sellable/mcp 0.1.556 → 0.1.557

package/dist/tools/auth.js

@@ -1,6 +1,6 @@
 import * as fs from "fs";
 import { getApi, SellableApiError } from "../api.js";
-import { getConfig, getConfigPath, getEffectiveConfiguredWorkspaceId, getLockedWorkspaceId, getResolvedConfigsDir, isWorkspaceLockRequired, workspaceLockRequiredMessage, } from "../auth.js";
+import { getConfig, getConfigPath, getResolvedConfigsDir } from "../auth.js";
 import { checkForUpdates } from "../update-check.js";
 function maskToken(token) {
     if (token.length <= 10)
@@ -38,8 +38,6 @@ export async function getAuthStatus() {
     const checkedAt = new Date().toISOString();
     const update = await getUpdateStatus();
     let tokenPresent = false;
-    const workspaceLockRequired = isWorkspaceLockRequired();
-    const lockedWorkspaceId = getLockedWorkspaceId();
     const base = {
         ok: false,
         configPath,
@@ -52,47 +50,27 @@ export async function getAuthStatus() {
         tokenPresent: false,
         tokenPrefix: null,
         workspacesCount: null,
-        workspaceLock: {
-            enabled: Boolean(lockedWorkspaceId),
-            workspaceId: lockedWorkspaceId,
-            required: workspaceLockRequired,
-        },
         _userNotice: appendUpdateNotice(null, update),
         update,
         checkedAt,
     };
-    if (workspaceLockRequired && !lockedWorkspaceId) {
-        return {
-            ...base,
-            error: {
-                type: "workspace",
-                message: "Customer profile workspace lock is missing.",
-                guidance: workspaceLockRequiredMessage("get_auth_status"),
-            },
-        };
-    }
     try {
         const config = getConfig();
         tokenPresent = Boolean(config.token);
         base.activeEnvName = config.activeEnvName || null;
         const api = getApi();
         const { workspaces } = await api.get("/api/v3/workspaces");
-        const activeWorkspaceId = getEffectiveConfiguredWorkspaceId(config);
+        const activeWorkspaceId = config.activeWorkspaceId || config.workspaceId || null;
         const activeWorkspace = activeWorkspaceId
             ? workspaces.find((ws) => ws.id === activeWorkspaceId)
             : null;
-        const visibleWorkspacesCount = lockedWorkspaceId
-            ? activeWorkspace
-                ? 1
-                : 0
-            : workspaces.length;
         if (!activeWorkspaceId) {
             return {
                 ...base,
                 apiUrl: config.apiUrl || null,
                 tokenPresent,
                 tokenPrefix: maskToken(config.token),
-                workspacesCount: visibleWorkspacesCount,
+                workspacesCount: workspaces.length,
                 error: {
                     type: "workspace",
                     message: "No active workspace selected.",
@@ -109,26 +87,22 @@ export async function getAuthStatus() {
                 apiUrl: config.apiUrl || null,
                 tokenPresent,
                 tokenPrefix: maskToken(config.token),
-                workspacesCount: visibleWorkspacesCount,
+                workspacesCount: workspaces.length,
                 error: {
                     type: "workspace",
                     message: `Active workspace ${activeWorkspaceId} not found in access list.`,
-                    guidance: lockedWorkspaceId
-                        ? "This profile is locked to a workspace that the configured Sellable token cannot access. Re-provision the customer profile from sellable-admin with the correct workspace token."
-                        : available
-                            ? `Available: ${available}. Run set_active_workspace with a valid ID.`
-                            : "Run list_workspaces to view available workspaces, then set_active_workspace.",
+                    guidance: available
+                        ? `Available: ${available}. Run set_active_workspace with a valid ID.`
+                        : "Run list_workspaces to view available workspaces, then set_active_workspace.",
                 },
             };
         }
         const workspaceName = activeWorkspace.name || config.activeWorkspaceName || null;
         const envLabel = config.activeEnvName || null;
         const wsLabel = workspaceName || activeWorkspaceId;
-        const noticePrefix = lockedWorkspaceId
-            ? `You're locked to ${wsLabel}.`
-            : envLabel
-                ? `You're in ${wsLabel} (${envLabel}).`
-                : `You're in ${wsLabel}.`;
+        const notice = envLabel
+            ? `You're in ${wsLabel} (${envLabel}).`
+            : `You're in ${wsLabel}.`;
         return {
             ok: true,
             configPath,
@@ -140,19 +114,8 @@ export async function getAuthStatus() {
             activeWorkspaceName: workspaceName,
             tokenPresent,
             tokenPrefix: maskToken(config.token),
-            workspacesCount: visibleWorkspacesCount,
-            workspaceLock: lockedWorkspaceId
-                ? {
-                    enabled: true,
-                    workspaceId: lockedWorkspaceId,
-                    required: workspaceLockRequired,
-                }
-                : {
-                    enabled: false,
-                    workspaceId: null,
-                    required: workspaceLockRequired,
-                },
-            _userNotice: appendUpdateNotice(noticePrefix, update),
+            workspacesCount: workspaces.length,
+            _userNotice: appendUpdateNotice(notice, update),
             update,
             checkedAt,
             error: null,

package/dist/tools/campaign-message-preparation.d.ts

@@ -36,16 +36,9 @@ type StartPrepareMessagesInput = PrepareMessagesBaseInput & {
     requestSource?: string;
     senderId?: string;
     actionType?: string;
-    targetDate?: string;
-    refillLaneKey?: string;
-    sourceEpoch?: string;
 };
 type StatusPrepareMessagesInput = PrepareMessagesBaseInput;
 type CancelPrepareMessagesInput = PrepareMessagesBaseInput;
-type StopSatisfiedPrepareMessagesInput = PrepareMessagesBaseInput & {
-    jobId: string;
-    expectedUpdatedAt?: string;
-};
 export declare const campaignMessagePreparationToolDefinitions: ({
     name: string;
     description: string;
@@ -124,18 +117,6 @@ export declare const campaignMessagePreparationToolDefinitions: ({
                 enum: string[];
                 description: string;
             };
-            targetDate: {
-                type: string;
-                description: string;
-            };
-            refillLaneKey: {
-                type: string;
-                description: string;
-            };
-            sourceEpoch: {
-                type: string;
-                description: string;
-            };
             disableLowPassRateStop: {
                 type: string;
                 description: string;
@@ -145,7 +126,6 @@ export declare const campaignMessagePreparationToolDefinitions: ({
                 description: string;
             };
             jobId?: undefined;
-            expectedUpdatedAt?: undefined;
         };
         required: string[];
         additionalProperties: boolean;
@@ -180,55 +160,13 @@ export declare const campaignMessagePreparationToolDefinitions: ({
             autoContinue?: undefined;
             senderId?: undefined;
             actionType?: undefined;
-            targetDate?: undefined;
-            refillLaneKey?: undefined;
-            sourceEpoch?: undefined;
             disableLowPassRateStop?: undefined;
-            expectedUpdatedAt?: undefined;
         };
         additionalProperties: boolean;
         required?: undefined;
     };
-} | {
-    name: string;
-    description: string;
-    inputSchema: {
-        type: string;
-        properties: {
-            jobId: {
-                type: string;
-            };
-            expectedUpdatedAt: {
-                type: string;
-                description: string;
-            };
-            workspaceId: {
-                type: string;
-                description?: undefined;
-            };
-            campaignId?: undefined;
-            tableId?: undefined;
-            targetPreparedMessages?: undefined;
-            maxRowsToCheck?: undefined;
-            batchSize?: undefined;
-            maxBatchRows?: undefined;
-            approvalMode?: undefined;
-            rowSelector?: undefined;
-            excludeRowIds?: undefined;
-            autoContinue?: undefined;
-            senderId?: undefined;
-            actionType?: undefined;
-            targetDate?: undefined;
-            refillLaneKey?: undefined;
-            sourceEpoch?: undefined;
-            disableLowPassRateStop?: undefined;
-        };
-        required: string[];
-        additionalProperties: boolean;
-    };
 })[];
 export declare function startPrepareCampaignMessages(input: StartPrepareMessagesInput): Promise<unknown>;
 export declare function getPrepareCampaignMessagesStatus(input: StatusPrepareMessagesInput): Promise<unknown>;
 export declare function cancelPrepareCampaignMessages(input: CancelPrepareMessagesInput): Promise<unknown>;
-export declare function stopSatisfiedPrepareCampaignMessages(input: StopSatisfiedPrepareMessagesInput): Promise<unknown>;
 export {};

package/dist/tools/campaign-message-preparation.js

@@ -84,18 +84,6 @@ export const campaignMessagePreparationToolDefinitions = [
                     ],
                     description: "Optional refill-scope send action. InMail scopes treat open and paid InMail as one contact-reuse family.",
                 },
-                targetDate: {
-                    type: "string",
-                    description: "Exact sender-local YYYY-MM-DD refill target date.",
-                },
-                refillLaneKey: {
-                    type: "string",
-                    description: "Normalized refill lane identity from the canonical target plan.",
-                },
-                sourceEpoch: {
-                    type: "string",
-                    description: "Stable source/provider epoch; only a material epoch change resets zero-yield recurrence.",
-                },
                 disableLowPassRateStop: {
                     type: "boolean",
                     description: "Operator override for explicit fill/exhaust requests. When true, keep processing eligible rows even if the enriched sample pass rate is low. Still bounded by targetPreparedMessages and maxRowsToCheck.",
@@ -123,23 +111,6 @@ export const campaignMessagePreparationToolDefinitions = [
             additionalProperties: false,
         },
     },
-    {
-        name: "stop_satisfied_campaign_message_preparation",
-        description: "Cooperatively stop exactly one preparation job after the server rereads its persisted refill scope and proves its allocatable preparation deficit is zero. This never cancels table-wide workflow cells.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                jobId: { type: "string" },
-                expectedUpdatedAt: {
-                    type: "string",
-                    description: "Optional optimistic job updatedAt revision from status.",
-                },
-                workspaceId: { type: "string" },
-            },
-            required: ["jobId"],
-            additionalProperties: false,
-        },
-    },
     {
         name: "cancel_campaign_message_preparation",
         description: "Cancel an active campaign message preparation job and cancel the same pending workflow-table cells that the UI Cancel Pending Cells button would cancel. Launch remains a separate explicit start_campaign step.",
@@ -174,9 +145,6 @@ export function startPrepareCampaignMessages(input) {
         requestSource: input.requestSource,
         senderId: input.senderId,
         actionType: input.actionType,
-        targetDate: input.targetDate,
-        refillLaneKey: input.refillLaneKey,
-        sourceEpoch: input.sourceEpoch,
         ...(workspaceId ? { workspaceId } : {}),
     }, workspaceId ?? undefined);
 }
@@ -200,12 +168,3 @@ export function cancelPrepareCampaignMessages(input) {
         ...(workspaceId ? { workspaceId } : {}),
     }, workspaceId ?? undefined);
 }
-export function stopSatisfiedPrepareCampaignMessages(input) {
-    const workspaceId = normalizeExplicitWorkspaceId(input.workspaceId);
-    return postPrepareMessages({
-        action: "stop_if_target_satisfied",
-        jobId: input.jobId,
-        expectedUpdatedAt: input.expectedUpdatedAt,
-        ...(workspaceId ? { workspaceId } : {}),
-    }, workspaceId ?? undefined);
-}

package/dist/tools/campaigns.js

@@ -1,5 +1,5 @@
 import { getApi } from "../api.js";
-import { getConfig, getEffectiveConfiguredWorkspaceId } from "../auth.js";
+import { getConfig } from "../auth.js";
 import { assertCreateCampaignPromptLoaded, assertNetNewCreateCampaignResearchReady, } from "./flow-preflight.js";
 import { setCampaignInteractionMode, } from "./interaction-mode.js";
 import { isLinkedInProfileInput, normalizeLinkedInProfileInput, } from "./linkedin-url.js";
@@ -114,7 +114,7 @@ function normalizeLeadSourceProvider(input) {
         : null;
 }
 export function buildWatchUrl(config, path) {
-    const workspaceId = getEffectiveConfiguredWorkspaceId(config);
+    const workspaceId = config.activeWorkspaceId || config.workspaceId;
     const url = new URL(path, config.apiUrl);
     if (workspaceId && !url.searchParams.has("workspaceId")) {
         url.searchParams.set("workspaceId", workspaceId);

package/dist/tools/csv-dnc.js

@@ -3,7 +3,7 @@ import { createHash, createHmac, randomBytes } from "node:crypto";
 import { readFileSync, statSync } from "node:fs";
 import { dirname, isAbsolute, resolve } from "node:path";
 import { getApi } from "../api.js";
-import { getConfig, getEffectiveConfiguredWorkspaceId } from "../auth.js";
+import { getConfig } from "../auth.js";
 import { resolveWorkspaceRoot } from "../utils/workspace-root.js";
 import { sanitizeCsvDomainCandidate } from "./csv-domains.js";
 import { validateAndNormalizeLinkedInUrl } from "./csv-linkedin.js";
@@ -324,7 +324,7 @@ function dedupeCandidates(candidates) {
 }
 async function getVerifiedActiveWorkspace() {
     const config = getConfig();
-    const activeWorkspaceId = getEffectiveConfiguredWorkspaceId(config);
+    const activeWorkspaceId = config.activeWorkspaceId || config.workspaceId;
     if (!activeWorkspaceId) {
         throw new Error("No active workspace selected. Run list_workspaces then set_active_workspace for the exact workspace whose Sellable DNC list should be read or updated.");
     }

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

@@ -2,9 +2,6 @@ type GetRefillPlanV2Input = {
     workspaceId?: string;
     intent?: "auto" | "evergreen" | "plain" | "active";
     senderIds?: string[];
-    horizonSendDays?: number;
-    untilDate?: string;
-    targetDate?: string;
     runState?: Record<string, unknown>;
     journal?: boolean;
     journalNote?: string;

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

@@ -2,7 +2,6 @@ import * as path from "node:path";
 import { getApi, SellableApiError } from "../api.js";
 import { appendIndexLine, appendJournalEvent, createRunJournal, renderBootstrapSection, renderPlanSection, renderTerminalSection, } from "../refill-journal.js";
 import { readRefillWorkspaceState } from "../refill-local-state.js";
-import { getRefillTargetPlan } from "./refill-target-plan.js";
 import { normalizeExplicitWorkspaceId, workspaceRequestOptions, } from "./workspace-context.js";
 const KNOWN_TOP_LEVEL_FIELDS = [
     "readOnly",
@@ -200,24 +199,12 @@ export async function getRefillPlanV2(input) {
         : buildRunStateFromLocalHints(workspaceId);
     let raw;
     try {
-        const hasExplicitDateSelector = input.targetDate !== undefined ||
-            input.untilDate !== undefined ||
-            input.horizonSendDays !== undefined;
-        raw = hasExplicitDateSelector
-            ? await getRefillTargetPlan({
-                workspaceId,
-                intent: input.intent === "auto" ? undefined : (input.intent ?? undefined),
-                senderIds: input.senderIds,
-                targetDate: input.targetDate,
-                untilDate: input.untilDate,
-                horizonSendDays: input.horizonSendDays,
-            })
-            : await postRefillPlanV2({
-                workspaceId,
-                intent: input.intent ?? "auto",
-                senderIds: input.senderIds,
-                runState,
-            }, workspaceId);
+        raw = await postRefillPlanV2({
+            workspaceId,
+            intent: input.intent ?? "auto",
+            senderIds: input.senderIds,
+            runState,
+        }, workspaceId);
     }
     catch (error) {
         if (!isWorkspaceAccessError(error))
@@ -251,16 +238,7 @@ export async function getRefillPlanV2(input) {
             workspaceResolution: "explicit",
         };
     }
-    const rawRecord = isRecord(raw) ? raw : {};
-    const target = isRecord(rawRecord.target) ? rawRecord.target : null;
-    const sanitized = sanitizeEvergreenRefillPlanResult(target
-        ? {
-            ...rawRecord,
-            plans: target.senderRefillPlans,
-            globalActionQueue: target.globalActionQueue,
-            packet: rawRecord,
-        }
-        : rawRecord);
+    const sanitized = sanitizeEvergreenRefillPlanResult(raw);
     const warnings = Array.isArray(sanitized.warnings)
         ? [...sanitized.warnings]
         : [];

package/dist/tools/find-leads-runs.d.ts

@@ -0,0 +1,151 @@
+type FindLeadsSnapshot = {
+    runId: string;
+    leadListId?: string;
+    version?: number;
+    status: string;
+    terminal?: boolean;
+    cancelled?: boolean;
+    [key: string]: unknown;
+};
+export declare const findLeadsRunToolDefinitions: readonly [{
+    readonly name: "bootstrap_find_leads";
+    readonly description: "Create or resume a durable campaignless Find Leads run and its lead list. No campaign or workingCampaignId is required.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly bootstrapKey: {
+                readonly type: "string";
+            };
+            readonly name: {
+                readonly type: "string";
+            };
+        };
+        readonly required: readonly ["bootstrapKey"];
+        readonly additionalProperties: false;
+    };
+}, {
+    readonly name: "get_find_leads_run";
+    readonly description: "Read the authoritative durable Find Leads snapshot.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly runId: {
+                readonly type: "string";
+            };
+        };
+        readonly required: readonly ["runId"];
+        readonly additionalProperties: false;
+    };
+}, {
+    readonly name: "update_find_leads_run";
+    readonly description: "Persist a provider/source/import approval receipt using optimistic concurrency.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly runId: {
+                readonly type: "string";
+            };
+            readonly version: {
+                readonly type: "number";
+            };
+            readonly action: {
+                readonly type: "string";
+                readonly enum: readonly ["approve_provider", "approve_source_plan", "approve_import"];
+            };
+            readonly provider: {
+                readonly type: "string";
+                readonly enum: readonly ["sales-nav", "prospeo", "signal-discovery"];
+            };
+            readonly receipt: {
+                readonly type: "object";
+            };
+        };
+        readonly required: readonly ["runId", "version", "action", "receipt"];
+        readonly additionalProperties: false;
+    };
+}, {
+    readonly name: "wait_for_find_leads_run";
+    readonly description: "Poll durable Find Leads state until it changes or reaches a terminal state. Progress notifications are optional hints only.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly runId: {
+                readonly type: "string";
+            };
+            readonly timeoutMs: {
+                readonly type: "number";
+            };
+            readonly intervalMs: {
+                readonly type: "number";
+            };
+        };
+        readonly required: readonly ["runId"];
+        readonly additionalProperties: false;
+    };
+}, {
+    readonly name: "cancel_find_leads";
+    readonly description: "Cancel a mutable Find Leads run with its current version.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly runId: {
+                readonly type: "string";
+            };
+            readonly version: {
+                readonly type: "number";
+            };
+        };
+        readonly required: readonly ["runId", "version"];
+        readonly additionalProperties: false;
+    };
+}, {
+    readonly name: "reissue_find_leads_watch_link";
+    readonly description: "Rotate and return a fresh one-time live Find Leads watch handoff. Old links are revoked and cannot be reconstructed.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly runId: {
+                readonly type: "string";
+            };
+            readonly mode: {
+                readonly type: "string";
+                readonly enum: readonly ["claude", "codex", "hermes"];
+            };
+        };
+        readonly required: readonly ["runId"];
+        readonly additionalProperties: false;
+    };
+}];
+export declare function bootstrapFindLeads(input: {
+    bootstrapKey: string;
+    name?: string;
+}): Promise<FindLeadsSnapshot>;
+export declare function getFindLeadsRun(input: {
+    runId: string;
+}): Promise<FindLeadsSnapshot>;
+export declare function updateFindLeadsRun(input: {
+    runId: string;
+    version: number;
+    action: "approve_provider" | "approve_source_plan" | "approve_import";
+    provider?: "sales-nav" | "prospeo" | "signal-discovery";
+    receipt: Record<string, unknown>;
+}): Promise<FindLeadsSnapshot>;
+export declare function cancelFindLeads(input: {
+    runId: string;
+    version: number;
+}): Promise<FindLeadsSnapshot>;
+export declare function reissueFindLeadsWatchLink(input: {
+    runId: string;
+    mode?: "claude" | "codex" | "hermes";
+}): Promise<{
+    runId: string;
+    leadListId: string;
+    watchUrl: string;
+    expiresAt: string;
+}>;
+export declare function waitForFindLeadsRun(input: {
+    runId: string;
+    timeoutMs?: number;
+    intervalMs?: number;
+}): Promise<FindLeadsSnapshot>;
+export {};

package/dist/tools/find-leads-runs.js

@@ -0,0 +1,98 @@
+import { getApi } from "../api.js";
+import { getConfig } from "../auth.js";
+function requestOptions() {
+    const config = getConfig();
+    const workspaceId = config.activeWorkspaceId || config.workspaceId || null;
+    if (!workspaceId) {
+        throw new Error("No active Sellable workspace. Run list_workspaces then set_active_workspace and retry Find Leads.");
+    }
+    return { workspaceId };
+}
+export const findLeadsRunToolDefinitions = [
+    {
+        name: "bootstrap_find_leads",
+        description: "Create or resume a durable campaignless Find Leads run and its lead list. No campaign or workingCampaignId is required.",
+        inputSchema: {
+            type: "object",
+            properties: { bootstrapKey: { type: "string" }, name: { type: "string" } },
+            required: ["bootstrapKey"],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "get_find_leads_run",
+        description: "Read the authoritative durable Find Leads snapshot.",
+        inputSchema: { type: "object", properties: { runId: { type: "string" } }, required: ["runId"], additionalProperties: false },
+    },
+    {
+        name: "update_find_leads_run",
+        description: "Persist a provider/source/import approval receipt using optimistic concurrency.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                runId: { type: "string" }, version: { type: "number" },
+                action: { type: "string", enum: ["approve_provider", "approve_source_plan", "approve_import"] },
+                provider: { type: "string", enum: ["sales-nav", "prospeo", "signal-discovery"] },
+                receipt: { type: "object" },
+            },
+            required: ["runId", "version", "action", "receipt"],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "wait_for_find_leads_run",
+        description: "Poll durable Find Leads state until it changes or reaches a terminal state. Progress notifications are optional hints only.",
+        inputSchema: {
+            type: "object",
+            properties: { runId: { type: "string" }, timeoutMs: { type: "number" }, intervalMs: { type: "number" } },
+            required: ["runId"], additionalProperties: false,
+        },
+    },
+    {
+        name: "cancel_find_leads",
+        description: "Cancel a mutable Find Leads run with its current version.",
+        inputSchema: { type: "object", properties: { runId: { type: "string" }, version: { type: "number" } }, required: ["runId", "version"], additionalProperties: false },
+    },
+    {
+        name: "reissue_find_leads_watch_link",
+        description: "Rotate and return a fresh one-time live Find Leads watch handoff. Old links are revoked and cannot be reconstructed.",
+        inputSchema: { type: "object", properties: { runId: { type: "string" }, mode: { type: "string", enum: ["claude", "codex", "hermes"] } }, required: ["runId"], additionalProperties: false },
+    },
+];
+export async function bootstrapFindLeads(input) {
+    return getApi().post("/api/v3/find-leads/runs", input, requestOptions());
+}
+export async function getFindLeadsRun(input) {
+    return getApi().get(`/api/v3/find-leads/runs/${encodeURIComponent(input.runId)}`, requestOptions());
+}
+export async function updateFindLeadsRun(input) {
+    const kind = input.action === "approve_provider"
+        ? "provider_prompt"
+        : input.action === "approve_source_plan"
+            ? "source_plan"
+            : "import_approval";
+    const provider = input.provider?.replace(/-/g, "_");
+    return getApi().patch(`/api/v3/find-leads/runs/${encodeURIComponent(input.runId)}`, { action: "record_receipt", version: input.version, kind, receipt: input.receipt, ...(provider ? { provider } : {}) }, requestOptions());
+}
+export async function cancelFindLeads(input) {
+    return getApi().patch(`/api/v3/find-leads/runs/${encodeURIComponent(input.runId)}`, { action: "cancel", version: input.version }, requestOptions());
+}
+export async function reissueFindLeadsWatchLink(input) {
+    return getApi().post(`/api/v3/find-leads/runs/${encodeURIComponent(input.runId)}/watch-token`, { mode: input.mode ?? (process.env.CODEX_HOME ? "codex" : "claude") }, requestOptions());
+}
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+export async function waitForFindLeadsRun(input) {
+    const timeoutMs = Math.min(Math.max(input.timeoutMs ?? 55_000, 25), 55_000);
+    const intervalMs = Math.min(Math.max(input.intervalMs ?? 2_000, 1), 10_000);
+    const startedAt = Date.now();
+    let previousVersion;
+    let snapshot = await getFindLeadsRun(input);
+    while (!snapshot.terminal && !snapshot.cancelled && Date.now() - startedAt < timeoutMs) {
+        if (previousVersion !== undefined && snapshot.version !== previousVersion)
+            return snapshot;
+        previousVersion = snapshot.version;
+        await sleep(intervalMs);
+        snapshot = await getFindLeadsRun(input);
+    }
+    return snapshot;
+}