@sellable/mcp 0.1.548 → 0.1.550

package/dist/api.js

@@ -3,7 +3,7 @@ import { mkdir, rename, rm, stat } from "node:fs/promises";
 import path from "node:path";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
-import { getConfig, getConfigPath } from "./auth.js";
+import { getConfig, getConfigPath, getEffectiveConfiguredWorkspaceId, resolveWorkspaceIdForRequest, } from "./auth.js";
 export class SellableApiError extends Error {
     status;
     body;
@@ -42,9 +42,12 @@ export class SellableApi {
         // Re-read config on every request so workspace switches take effect immediately
         const config = getConfig();
         const url = `${config.apiUrl}${path}`;
-        const workspaceId = options && Object.prototype.hasOwnProperty.call(options, "workspaceId")
+        const requestedWorkspaceId = options && Object.prototype.hasOwnProperty.call(options, "workspaceId")
             ? options.workspaceId
-            : config.activeWorkspaceId || config.workspaceId || null;
+            : getEffectiveConfiguredWorkspaceId(config);
+        const workspaceId = options && Object.prototype.hasOwnProperty.call(options, "workspaceId")
+            ? resolveWorkspaceIdForRequest(requestedWorkspaceId, `${method} ${path}`)
+            : requestedWorkspaceId;
         const response = await fetch(url, {
             method,
             headers: {

package/dist/auth.d.ts

@@ -40,6 +40,12 @@ export type SkillState = {
 export declare function setConfigFile(fileName: string): void;
 export declare function getResolvedConfigsDir(): string | null;
 export declare function getConfigPath(): string;
+export declare function getLockedWorkspaceId(): string | null;
+export declare function isWorkspaceLockRequired(): boolean;
+export declare function workspaceLockRequiredMessage(action?: string): string;
+export declare function assertWorkspaceLockSatisfied(action?: string): void;
+export declare function getEffectiveConfiguredWorkspaceId(config: Pick<SellableConfig, "activeWorkspaceId" | "workspaceId">): string | null;
+export declare function resolveWorkspaceIdForRequest(requestedWorkspaceId: string | null | undefined, action?: string): string | null;
 export declare function getConfig(): SellableConfig;
 export declare function updateActiveWorkspace(params: {
     workspaceId: string;

package/dist/auth.js

@@ -2,6 +2,8 @@ import * as fs from "fs";
 import * as os from "os";
 import * as path from "path";
 const DEFAULT_API_URL = "https://app.sellable.dev";
+const WORKSPACE_LOCK_ENV = "SELLABLE_LOCK_WORKSPACE_ID";
+const REQUIRE_WORKSPACE_LOCK_ENV = "SELLABLE_REQUIRE_WORKSPACE_LOCK";
 // No caching — re-read config on every call so token/workspace changes
 // made by the LLM (editing sellable.json) take effect immediately
 // without requiring an MCP server restart.
@@ -85,6 +87,44 @@ function normalizeConfig(raw) {
         apiUrl: raw.apiUrl || DEFAULT_API_URL,
     };
 }
+export function getLockedWorkspaceId() {
+    const value = process.env[WORKSPACE_LOCK_ENV]?.trim();
+    return value || null;
+}
+export function isWorkspaceLockRequired() {
+    const value = process.env[REQUIRE_WORKSPACE_LOCK_ENV]?.trim().toLowerCase();
+    return value === "1" || value === "true" || value === "yes";
+}
+export function workspaceLockRequiredMessage(action = "Sellable request") {
+    return (`Workspace lock required: ${action} cannot run because ` +
+        `${REQUIRE_WORKSPACE_LOCK_ENV}=1 but ${WORKSPACE_LOCK_ENV} is missing. ` +
+        "Ask the sellable-admin profile to provision this customer profile with an approved customer workspace.");
+}
+export function assertWorkspaceLockSatisfied(action = "Sellable request") {
+    if (isWorkspaceLockRequired() && !getLockedWorkspaceId()) {
+        throw new Error(workspaceLockRequiredMessage(action));
+    }
+}
+function normalizeWorkspaceId(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+export function getEffectiveConfiguredWorkspaceId(config) {
+    assertWorkspaceLockSatisfied("workspace resolution");
+    return (getLockedWorkspaceId() ||
+        normalizeWorkspaceId(config.activeWorkspaceId) ||
+        normalizeWorkspaceId(config.workspaceId));
+}
+export function resolveWorkspaceIdForRequest(requestedWorkspaceId, action = "Sellable request") {
+    assertWorkspaceLockSatisfied(action);
+    const lockedWorkspaceId = getLockedWorkspaceId();
+    const requested = normalizeWorkspaceId(requestedWorkspaceId);
+    if (!lockedWorkspaceId)
+        return requested;
+    if (requested && requested !== lockedWorkspaceId) {
+        throw new Error(`Workspace lock violation: ${action} requested workspace ${requested}, but this profile is locked to ${lockedWorkspaceId}.`);
+    }
+    return lockedWorkspaceId;
+}
 export function getConfig() {
     // Config cache removed 2026-05-04: we always re-read from disk so
     // workspace switches (set_active_workspace) take effect immediately
@@ -139,6 +179,7 @@ export function getConfig() {
     }
 }
 export function updateActiveWorkspace(params) {
+    resolveWorkspaceIdForRequest(params.workspaceId, "set_active_workspace");
     const configPath = getConfigPath();
     const configDir = path.dirname(configPath);
     if (!fs.existsSync(configDir)) {
@@ -226,6 +267,7 @@ function writeRawConfigFile(configPath, raw) {
  * new config without an MCP server restart.
  */
 export function writeNewConfig(opts) {
+    resolveWorkspaceIdForRequest(opts.activeWorkspaceId, "write Sellable auth config");
     const configPath = getConfigWritePath();
     let raw = {};
     if (fs.existsSync(configPath)) {
@@ -283,7 +325,7 @@ function getActiveEnvConfigRef(raw) {
 }
 export function getEngageState() {
     const config = getConfig();
-    const workspaceId = config.activeWorkspaceId || config.workspaceId || null;
+    const workspaceId = getEffectiveConfiguredWorkspaceId(config);
     if (!workspaceId) {
         return { activeWorkspaceId: null, state: null };
     }
@@ -294,7 +336,7 @@ export function updateEngageState(patch) {
     const { configPath, raw } = readRawConfigFile();
     const { envConfig, set } = getActiveEnvConfigRef(raw);
     const normalized = normalizeConfig(envConfig);
-    const workspaceId = normalized.activeWorkspaceId || normalized.workspaceId || null;
+    const workspaceId = getEffectiveConfiguredWorkspaceId(normalized);
     if (!workspaceId) {
         throw new Error("No active workspace selected. Run list_workspaces then set_active_workspace.");
     }

package/dist/refill-date-window.d.ts

@@ -0,0 +1,34 @@
+export type RefillDateWindowSource = "default_scheduler_forward" | "horizon_send_days" | "until_date" | "target_date";
+export type NormalizedRefillDateSelector = {
+    source: RefillDateWindowSource;
+    targetDate: string | null;
+    untilDate: string | null;
+    horizonSendDays: number | null;
+};
+export type RefillRunDateWindow = NormalizedRefillDateSelector & {
+    version: 1;
+    selectedDates: string[];
+    senderWindows?: Array<{
+        senderId: string | null;
+        timeZone: string | null;
+        selectedDates: string[];
+    }>;
+};
+type DateSelectorInput = {
+    targetDate?: unknown;
+    untilDate?: unknown;
+    horizonSendDays?: unknown;
+};
+export declare function normalizeRefillDateSelector(input: DateSelectorInput): NormalizedRefillDateSelector;
+export declare function refillDateSelectorBody(selector: NormalizedRefillDateSelector): {
+    targetDate?: string;
+    untilDate?: string;
+    horizonSendDays?: number;
+};
+export declare function dateWindowFromSelector(selector: NormalizedRefillDateSelector): RefillRunDateWindow;
+export declare function dateWindowFromPlan(plan: Record<string, unknown>, selector: NormalizedRefillDateSelector): RefillRunDateWindow;
+export declare function dateWindowFromRunState(runState: unknown): RefillRunDateWindow | null;
+export declare function selectorFromDateWindow(window: RefillRunDateWindow): NormalizedRefillDateSelector;
+export declare function dateSelectorMatchesWindow(selector: NormalizedRefillDateSelector, window: RefillRunDateWindow): boolean;
+export declare function schedulerSweepTargetDates(window: RefillRunDateWindow): string[];
+export {};

package/dist/refill-date-window.js

@@ -0,0 +1,210 @@
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+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 arrayValue(value) {
+    return Array.isArray(value) ? value : [];
+}
+function isValidDateKey(value) {
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(value))
+        return false;
+    const [year, month, day] = value.split("-").map(Number);
+    const date = new Date(Date.UTC(year, month - 1, day));
+    return (date.getUTCFullYear() === year &&
+        date.getUTCMonth() === month - 1 &&
+        date.getUTCDate() === day);
+}
+function normalizeDateKey(value, field) {
+    if (value === undefined || value === null || value === "")
+        return null;
+    if (typeof value !== "string") {
+        throw new Error(`${field} must be a string in YYYY-MM-DD format.`);
+    }
+    const trimmed = value.trim();
+    if (!isValidDateKey(trimmed)) {
+        throw new Error(`${field} must be a valid YYYY-MM-DD calendar date.`);
+    }
+    return trimmed;
+}
+function normalizeHorizonSendDays(value) {
+    if (value === undefined)
+        return null;
+    if (typeof value !== "number" ||
+        !Number.isInteger(value) ||
+        value < 1 ||
+        value > 7) {
+        throw new Error("horizonSendDays must be an integer between 1 and 7.");
+    }
+    return value;
+}
+export function normalizeRefillDateSelector(input) {
+    const targetDate = normalizeDateKey(input.targetDate, "targetDate");
+    const untilDate = normalizeDateKey(input.untilDate, "untilDate");
+    const horizonSendDays = normalizeHorizonSendDays(input.horizonSendDays);
+    if (targetDate) {
+        return {
+            source: "target_date",
+            targetDate,
+            untilDate: null,
+            horizonSendDays: null,
+        };
+    }
+    if (untilDate) {
+        return {
+            source: "until_date",
+            targetDate: null,
+            untilDate,
+            horizonSendDays: null,
+        };
+    }
+    if (horizonSendDays !== null) {
+        return {
+            source: "horizon_send_days",
+            targetDate: null,
+            untilDate: null,
+            horizonSendDays,
+        };
+    }
+    return {
+        source: "default_scheduler_forward",
+        targetDate: null,
+        untilDate: null,
+        horizonSendDays: null,
+    };
+}
+export function refillDateSelectorBody(selector) {
+    if (selector.source === "target_date" && selector.targetDate) {
+        return { targetDate: selector.targetDate };
+    }
+    if (selector.source === "until_date" && selector.untilDate) {
+        return { untilDate: selector.untilDate };
+    }
+    if (selector.source === "horizon_send_days" &&
+        selector.horizonSendDays !== null) {
+        return { horizonSendDays: selector.horizonSendDays };
+    }
+    return {};
+}
+export function dateWindowFromSelector(selector) {
+    return {
+        version: 1,
+        ...selector,
+        selectedDates: selector.targetDate ? [selector.targetDate] : [],
+    };
+}
+function selectedDatesFromPlan(plan) {
+    const packet = isRecord(plan.packet) ? plan.packet : {};
+    const target = isRecord(packet.target) ? packet.target : {};
+    const window = isRecord(target.window) ? target.window : {};
+    const senderWindows = arrayValue(window.senderWindows).filter(isRecord);
+    const fromWindows = senderWindows.flatMap((senderWindow) => arrayValue(senderWindow.selectedDates)
+        .map((entry) => stringValue(entry))
+        .filter((entry) => Boolean(entry)));
+    if (fromWindows.length > 0)
+        return Array.from(new Set(fromWindows)).sort();
+    const senderRefillPlans = arrayValue(target.senderRefillPlans).filter(isRecord);
+    return Array.from(new Set(senderRefillPlans.flatMap((senderPlan) => {
+        const horizon = isRecord(senderPlan.horizon) ? senderPlan.horizon : {};
+        return arrayValue(horizon.selectedDays)
+            .filter(isRecord)
+            .map((day) => stringValue(day.date))
+            .filter((entry) => Boolean(entry));
+    }))).sort();
+}
+function senderWindowsFromPlan(plan) {
+    const packet = isRecord(plan.packet) ? plan.packet : {};
+    const target = isRecord(packet.target) ? packet.target : {};
+    const window = isRecord(target.window) ? target.window : {};
+    return arrayValue(window.senderWindows)
+        .filter(isRecord)
+        .map((senderWindow) => ({
+        senderId: stringValue(senderWindow.senderId),
+        timeZone: stringValue(senderWindow.timeZone),
+        selectedDates: arrayValue(senderWindow.selectedDates)
+            .map((entry) => stringValue(entry))
+            .filter((entry) => Boolean(entry)),
+    }));
+}
+export function dateWindowFromPlan(plan, selector) {
+    const packet = isRecord(plan.packet) ? plan.packet : {};
+    const request = isRecord(packet.request) ? packet.request : {};
+    const targetDate = stringValue(request.targetDate) ?? selector.targetDate ?? null;
+    const untilDate = stringValue(request.untilDate) ?? selector.untilDate ?? null;
+    const horizonSendDays = numberValue(request.horizonSendDays) ?? selector.horizonSendDays ?? null;
+    const source = targetDate
+        ? "target_date"
+        : untilDate
+            ? "until_date"
+            : horizonSendDays !== null
+                ? "horizon_send_days"
+                : selector.source;
+    const selectedDates = selectedDatesFromPlan(plan);
+    return {
+        version: 1,
+        source,
+        targetDate: source === "target_date" ? targetDate : null,
+        untilDate: source === "until_date" ? untilDate : null,
+        horizonSendDays: source === "horizon_send_days" ? horizonSendDays : null,
+        selectedDates: selectedDates.length > 0
+            ? selectedDates
+            : targetDate
+                ? [targetDate]
+                : [],
+        senderWindows: senderWindowsFromPlan(plan),
+    };
+}
+export function dateWindowFromRunState(runState) {
+    const state = isRecord(runState) ? runState : {};
+    const raw = isRecord(state.dateWindow) ? state.dateWindow : null;
+    if (!raw || raw.version !== 1)
+        return null;
+    const source = raw.source === "target_date" ||
+        raw.source === "until_date" ||
+        raw.source === "horizon_send_days" ||
+        raw.source === "default_scheduler_forward"
+        ? raw.source
+        : null;
+    if (!source)
+        return null;
+    return {
+        version: 1,
+        source,
+        targetDate: source === "target_date" ? stringValue(raw.targetDate) : null,
+        untilDate: source === "until_date" ? stringValue(raw.untilDate) : null,
+        horizonSendDays: source === "horizon_send_days"
+            ? numberValue(raw.horizonSendDays)
+            : null,
+        selectedDates: arrayValue(raw.selectedDates)
+            .map((entry) => stringValue(entry))
+            .filter((entry) => Boolean(entry)),
+    };
+}
+export function selectorFromDateWindow(window) {
+    return {
+        source: window.source,
+        targetDate: window.targetDate,
+        untilDate: window.untilDate,
+        horizonSendDays: window.horizonSendDays,
+    };
+}
+export function dateSelectorMatchesWindow(selector, window) {
+    return (selector.source === window.source &&
+        selector.targetDate === window.targetDate &&
+        selector.untilDate === window.untilDate &&
+        selector.horizonSendDays === window.horizonSendDays);
+}
+export function schedulerSweepTargetDates(window) {
+    if (window.source === "target_date" && window.targetDate) {
+        return [window.targetDate];
+    }
+    if (window.source === "until_date" ||
+        window.source === "horizon_send_days") {
+        return window.selectedDates;
+    }
+    return [];
+}

package/dist/server.js

@@ -338,7 +338,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 }
                 break;
             case "duplicate_campaign":
-                result = await duplicateCampaign(args?.campaignId, args?.name);
+                result = await duplicateCampaign(args?.campaignId);
                 if (result?.campaignOfferId) {
                     markCampaignContextDirty(result.campaignOfferId, "duplicate_campaign");
                 }

package/dist/tools/auth.d.ts

@@ -11,6 +11,11 @@ export type AuthStatus = {
     tokenPresent: boolean;
     tokenPrefix: string | null;
     workspacesCount: number | null;
+    workspaceLock: {
+        enabled: boolean;
+        workspaceId: string | null;
+        required: boolean;
+    };
     checkedAt: string;
     /** Short message the LLM MUST show the user after auth succeeds. */
     _userNotice: string | null;

package/dist/tools/auth.js

@@ -1,6 +1,6 @@
 import * as fs from "fs";
 import { getApi, SellableApiError } from "../api.js";
-import { getConfig, getConfigPath, getResolvedConfigsDir } from "../auth.js";
+import { getConfig, getConfigPath, getEffectiveConfiguredWorkspaceId, getLockedWorkspaceId, getResolvedConfigsDir, isWorkspaceLockRequired, workspaceLockRequiredMessage, } from "../auth.js";
 import { checkForUpdates } from "../update-check.js";
 function maskToken(token) {
     if (token.length <= 10)
@@ -38,6 +38,8 @@ 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,
@@ -50,27 +52,47 @@ 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 = config.activeWorkspaceId || config.workspaceId || null;
+        const activeWorkspaceId = getEffectiveConfiguredWorkspaceId(config);
         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: workspaces.length,
+                workspacesCount: visibleWorkspacesCount,
                 error: {
                     type: "workspace",
                     message: "No active workspace selected.",
@@ -87,22 +109,26 @@ export async function getAuthStatus() {
                 apiUrl: config.apiUrl || null,
                 tokenPresent,
                 tokenPrefix: maskToken(config.token),
-                workspacesCount: workspaces.length,
+                workspacesCount: visibleWorkspacesCount,
                 error: {
                     type: "workspace",
                     message: `Active workspace ${activeWorkspaceId} not found in access list.`,
-                    guidance: available
-                        ? `Available: ${available}. Run set_active_workspace with a valid ID.`
-                        : "Run list_workspaces to view available workspaces, then set_active_workspace.",
+                    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.",
                 },
             };
         }
         const workspaceName = activeWorkspace.name || config.activeWorkspaceName || null;
         const envLabel = config.activeEnvName || null;
         const wsLabel = workspaceName || activeWorkspaceId;
-        const notice = envLabel
-            ? `You're in ${wsLabel} (${envLabel}).`
-            : `You're in ${wsLabel}.`;
+        const noticePrefix = lockedWorkspaceId
+            ? `You're locked to ${wsLabel}.`
+            : envLabel
+                ? `You're in ${wsLabel} (${envLabel}).`
+                : `You're in ${wsLabel}.`;
         return {
             ok: true,
             configPath,
@@ -114,8 +140,19 @@ export async function getAuthStatus() {
             activeWorkspaceName: workspaceName,
             tokenPresent,
             tokenPrefix: maskToken(config.token),
-            workspacesCount: workspaces.length,
-            _userNotice: appendUpdateNotice(notice, update),
+            workspacesCount: visibleWorkspacesCount,
+            workspaceLock: lockedWorkspaceId
+                ? {
+                    enabled: true,
+                    workspaceId: lockedWorkspaceId,
+                    required: workspaceLockRequired,
+                }
+                : {
+                    enabled: false,
+                    workspaceId: null,
+                    required: workspaceLockRequired,
+                },
+            _userNotice: appendUpdateNotice(noticePrefix, update),
             update,
             checkedAt,
             error: null,

package/dist/tools/campaigns.d.ts

@@ -136,7 +136,6 @@ export interface CreateCampaignInput {
 }
 export interface UpdateCampaignInput {
     flowVersion?: "v1" | "v2";
-    name?: string;
     offerPositioning?: unknown;
     campaignBrief?: unknown;
     leadSourceType?: string | null;
@@ -162,55 +161,12 @@ export declare const campaignToolDefinitions: ({
                 type: string;
                 description: string;
             };
-            name?: undefined;
-            limit?: undefined;
-            tableId?: undefined;
-            leadLimit?: undefined;
-            page?: undefined;
-            filters?: undefined;
-            clientProspectId?: undefined;
-            senderLinkedinUrl?: undefined;
-            offerPositioning?: undefined;
-            campaignBrief?: undefined;
-            messageGenerationMode?: undefined;
-            currentStep?: undefined;
-            watchNarration?: undefined;
-            leadSourceType?: undefined;
-            leadSourceProvider?: undefined;
-            selectedLeadListId?: undefined;
-            senderIds?: undefined;
-            currentStepTransition?: undefined;
-            clearCurrentStepIfMatches?: undefined;
-            interactionMode?: undefined;
-            enableICPFilters?: undefined;
-            useMessagingTemplate?: undefined;
-            rubric?: undefined;
-            flowVersion?: undefined;
-            workspaceId?: undefined;
-        };
-        required: string[];
-        additionalProperties: boolean;
-    };
-} | {
-    name: string;
-    description: string;
-    inputSchema: {
-        type: string;
-        properties: {
-            campaignId: {
-                type: string;
-                description: string;
-            };
-            name: {
-                type: string;
-                maxLength: number;
-                description: string;
-            };
             limit?: undefined;
             tableId?: undefined;
             leadLimit?: undefined;
             page?: undefined;
             filters?: undefined;
+            name?: undefined;
             clientProspectId?: undefined;
             senderLinkedinUrl?: undefined;
             offerPositioning?: undefined;
@@ -245,11 +201,11 @@ export declare const campaignToolDefinitions: ({
                 description: string;
             };
             campaignId?: undefined;
-            name?: undefined;
             tableId?: undefined;
             leadLimit?: undefined;
             page?: undefined;
             filters?: undefined;
+            name?: undefined;
             clientProspectId?: undefined;
             senderLinkedinUrl?: undefined;
             offerPositioning?: undefined;
@@ -283,12 +239,12 @@ export declare const campaignToolDefinitions: ({
                 type: string;
                 description: string;
             };
-            name?: undefined;
             limit?: undefined;
             tableId?: undefined;
             leadLimit?: undefined;
             page?: undefined;
             filters?: undefined;
+            name?: undefined;
             clientProspectId?: undefined;
             senderLinkedinUrl?: undefined;
             offerPositioning?: undefined;
@@ -369,8 +325,8 @@ export declare const campaignToolDefinitions: ({
                     additionalProperties: boolean;
                 };
             };
-            name?: undefined;
             limit?: undefined;
+            name?: undefined;
             clientProspectId?: undefined;
             senderLinkedinUrl?: undefined;
             offerPositioning?: undefined;
@@ -407,7 +363,6 @@ export declare const campaignToolDefinitions: ({
             name: {
                 type: string;
                 description: string;
-                maxLength?: undefined;
             };
             clientProspectId: {
                 type: string;
@@ -600,11 +555,6 @@ export declare const campaignToolDefinitions: ({
                 type: string;
                 description: string;
             };
-            name: {
-                type: string;
-                maxLength: number;
-                description: string;
-            };
             offerPositioning: {
                 type: string;
                 description: string;
@@ -792,6 +742,7 @@ export declare const campaignToolDefinitions: ({
             leadLimit?: undefined;
             page?: undefined;
             filters?: undefined;
+            name?: undefined;
             clientProspectId?: undefined;
             senderLinkedinUrl?: undefined;
             messageGenerationMode?: undefined;
@@ -814,12 +765,12 @@ export declare const campaignToolDefinitions: ({
                 type: string;
                 description: string;
             };
-            name?: undefined;
             limit?: undefined;
             tableId?: undefined;
             leadLimit?: undefined;
             page?: undefined;
             filters?: undefined;
+            name?: undefined;
             clientProspectId?: undefined;
             senderLinkedinUrl?: undefined;
             offerPositioning?: undefined;
@@ -856,12 +807,12 @@ export declare const campaignToolDefinitions: ({
                 type: string;
                 description: string;
             };
-            name?: undefined;
             limit?: undefined;
             tableId?: undefined;
             leadLimit?: undefined;
             page?: undefined;
             filters?: undefined;
+            name?: undefined;
             clientProspectId?: undefined;
             senderLinkedinUrl?: undefined;
             offerPositioning?: undefined;
@@ -932,7 +883,7 @@ export declare function archiveCampaign(campaignId: string): Promise<{
     cellsReset?: number;
     workflowTableId?: string;
 }>;
-export declare function duplicateCampaign(campaignId: string, name?: string): Promise<{
+export declare function duplicateCampaign(campaignId: string): Promise<{
     campaignOfferId: string;
     campaignName: string;
     workflowTableId: string | null;