@leadbay/mcp 0.2.2 → 0.4.0

package/dist/{chunk-FJBO2MY2.js → chunk-O2UOXRZO.js}

@@ -17,7 +17,7 @@ function httpsRequest(method, url, headers, body) {
     const start = Date.now();
     const parsed = new URL(url);
     const reqHeaders = { ...headers };
-    if (body) {
+    if (body !== void 0) {
       reqHeaders["Content-Length"] = Buffer.byteLength(body);
     }
     const req = https.request({
@@ -39,7 +39,7 @@ function httpsRequest(method, url, headers, body) {
       });
     });
     req.on("error", reject);
-    if (body)
+    if (body !== void 0)
       req.write(body);
     req.end();
   });
@@ -52,6 +52,14 @@ function createClient(config = {}) {
   }
   return new LeadbayClient(baseUrl, config.token, region);
 }
+function formatLoginError(status, body, baseUrl) {
+  const trimmed = body.trim();
+  const head = `login failed (${status}) at ${baseUrl}`;
+  const hint = status === 401 ? " (wrong email or password?)" : status === 429 ? " (rate-limited; wait and retry)" : status >= 500 ? " (server error; try again shortly)" : "";
+  if (!trimmed)
+    return head + hint;
+  return `${head}: ${trimmed.slice(0, 200)}${hint}`;
+}
 async function resolveRegion(email, password, startWith = "us") {
   const order = startWith === "fr" ? ["fr", "us"] : ["us", "fr"];
   let lastErr = null;
@@ -71,12 +79,13 @@ async function resolveRegion(email, password, startWith = "us") {
           };
         }
       }
-      lastErr = { status: res.status, body: res.body, region };
+      lastErr = { kind: "http", status: res.status, body: res.body, region, baseUrl };
     } catch (e) {
-      lastErr = { error: e, region };
+      lastErr = { kind: "network", error: e, region, baseUrl };
     }
   }
-  throw new Error(`Leadbay login failed in both regions (us, fr). Last response: ${JSON.stringify(lastErr)}`);
+  const detail = lastErr?.kind === "http" ? formatLoginError(lastErr.status, lastErr.body, lastErr.baseUrl) : lastErr?.kind === "network" ? `network error at ${lastErr.baseUrl}: ${lastErr.error?.message ?? String(lastErr.error)}` : "no attempts made";
+  throw new Error(`Leadbay login failed in both regions (us, fr). ${detail}`);
 }
 var _mockFixtures = null;
 var _mockJournal = [];
@@ -300,6 +309,43 @@ var LeadbayClient = class {
       this.releaseSemaphore();
     }
   }
+  // Like request(), but the caller supplies the Content-Type and the already-
+  // serialized body (string for text payloads such as CSV; Buffer for binary
+  // uploads). Auth, semaphore, error mapping, _lastMeta, and mock-mode all
+  // mirror request() exactly. Used by leadbay_import_leads to upload CSVs to
+  // the wizard at POST /1.5/imports.
+  async requestRawBinary(method, path, contentType, body) {
+    if (process.env.LEADBAY_MOCK === "1") {
+      return this.mockRequestBinary(method, path, contentType, body);
+    }
+    if (!this.token) {
+      throw this.makeError("NOT_AUTHENTICATED", "Not logged in to Leadbay", "Set LEADBAY_TOKEN in your MCP client config, or run: npx -y @leadbay/mcp install --email <you> --region <us|fr>", path);
+    }
+    await this.acquireSemaphore();
+    try {
+      const url = `${this._baseUrl}/1.5${path}`;
+      const headers = {
+        Authorization: `Bearer ${this.token}`,
+        "Content-Type": contentType
+      };
+      const res = await httpsRequest(method, url, headers, body);
+      this._lastMeta = {
+        region: this._region,
+        endpoint: `${method} ${path}`,
+        latency_ms: res.latency_ms,
+        retry_after: parseRetryAfter(res.headers["retry-after"])
+      };
+      if (res.status === 204) {
+        return null;
+      }
+      if (res.status < 200 || res.status >= 300) {
+        throw this.mapErrorResponse(res.status, res.body, path, res.headers);
+      }
+      return JSON.parse(res.body);
+    } finally {
+      this.releaseSemaphore();
+    }
+  }
   mockRequest(method, path, body) {
     const fullPath = `/1.5${path}`;
     this._lastMeta = {
@@ -323,6 +369,39 @@ var LeadbayClient = class {
       would_call: { method, path: fullPath, body }
     };
   }
+  mockRequestBinary(method, path, contentType, body) {
+    const fullPath = `/1.5${path}`;
+    this._lastMeta = {
+      region: this._region,
+      endpoint: `${method} ${path}`,
+      latency_ms: 0,
+      retry_after: null
+    };
+    if (method === "GET") {
+      const fixture = findMockFixture("GET", fullPath);
+      if (!fixture) {
+        throw this.makeError("MOCK_NOT_FOUND", `LEADBAY_MOCK=1: no fixture for GET ${path}`, `Add a fixture to LEADBAY_MOCK_DIR (default: ./.context/leadbay-live-shapes/) \u2014 run a probe script to generate one.`, path);
+      }
+      if (fixture.status === 204)
+        return null;
+      return fixture.body;
+    }
+    const journalBody = {
+      _binary: true,
+      length: Buffer.byteLength(body),
+      content_type: contentType
+    };
+    _mockJournal.push({
+      method,
+      path: fullPath,
+      body: journalBody,
+      ts: Date.now()
+    });
+    return {
+      mocked: true,
+      would_call: { method, path: fullPath, body: journalBody }
+    };
+  }
   mapErrorResponse(status, rawBody, endpoint, headers) {
     let parsed;
     try {
@@ -587,6 +666,11 @@ var getLeadProfile = {
   },
   execute: async (client, params) => {
     const lensId = params.lensId ?? await client.resolveDefaultLens();
+    void client.request("POST", "/interactions", [
+      { type: "LEAD_SEEN", leadId: params.leadId, lensId: String(lensId) },
+      { type: "LEAD_CLICKED", leadId: params.leadId, lensId: String(lensId) }
+    ]).catch(() => {
+    });
     const [leadResult, qualResult, contactsResult, paidContactsResult, webFetchResult] = await Promise.allSettled([
       client.request("GET", `/lenses/${lensId}/leads/${params.leadId}`),
       client.request("GET", `/leads/${params.leadId}/ai_agent_responses`),
@@ -1322,12 +1406,12 @@ var setUserPrompt = {
         would_call: {
           method: "POST",
           path: `/organizations/${orgId}/user_prompt`,
-          body: { prompt: params.prompt }
+          body: { user_prompt: params.prompt }
         }
       };
     }
     await client.requestVoid("POST", `/organizations/${orgId}/user_prompt`, {
-      prompt: params.prompt
+      user_prompt: params.prompt
     });
     client.invalidateMe();
     return { set: true };
@@ -1802,6 +1886,11 @@ var researchLead = {
   execute: async (client, params, ctx) => {
     const lensId = params.lensId ?? await client.resolveDefaultLens();
     const leadId = params.leadId;
+    void client.request("POST", "/interactions", [
+      { type: "LEAD_SEEN", leadId, lensId: String(lensId) },
+      { type: "LEAD_CLICKED", leadId, lensId: String(lensId) }
+    ]).catch(() => {
+    });
     const [profileR, qualR, contactsR, webFetchR] = await Promise.allSettled([
       client.request("GET", `/lenses/${lensId}/leads/${leadId}`),
       client.request("GET", `/leads/${leadId}/ai_agent_responses`),
@@ -2190,6 +2279,680 @@ var bulkQualifyLeads = {
   }
 };
 
+// ../core/dist/composite/import-leads.js
+import { randomUUID } from "crypto";
+var CHUNK_SIZE = 100;
+var POLL_INTERVAL_MS = 2e3;
+var DEFAULT_PER_PHASE_BUDGET_MS = 6e4;
+var DEFAULT_TOTAL_BUDGET_MS2 = 3e5;
+var STABILIZATION_POLLS = 2;
+var MAX_COLUMN_NAME_LEN = 128;
+var RESERVED_COLUMN_RE = /^mcp_row_id$/i;
+var PUBLIC_MAILBOX_DOMAINS = /* @__PURE__ */ new Set([
+  "gmail.com",
+  "googlemail.com",
+  "yahoo.com",
+  "ymail.com",
+  "outlook.com",
+  "hotmail.com",
+  "live.com",
+  "icloud.com",
+  "me.com",
+  "mac.com",
+  "aol.com",
+  "proton.me",
+  "protonmail.com",
+  "tutanota.com",
+  "gmx.com",
+  "gmx.net",
+  "gmx.de",
+  "mail.com",
+  "yandex.com",
+  "yandex.ru",
+  "qq.com",
+  "163.com",
+  "126.com"
+]);
+function normalizeDomain(input) {
+  if (!input || typeof input !== "string")
+    return null;
+  let v = input.trim().toLowerCase();
+  if (!v)
+    return null;
+  v = v.replace(/^https?:\/\//, "");
+  v = v.replace(/^www\./, "");
+  v = v.split("/")[0].split("?")[0].split("#")[0];
+  v = v.replace(/\.+$/, "");
+  if (!v)
+    return null;
+  if (/\s/.test(v))
+    return null;
+  if (!v.includes("."))
+    return null;
+  if (v.startsWith(".") || v.endsWith("."))
+    return null;
+  const parts = v.split(".");
+  if (parts.length < 2)
+    return null;
+  if (parts.some((p) => p.length === 0))
+    return null;
+  const tld = parts[parts.length - 1];
+  if (!/^[a-z]{2,}$/.test(tld) && !tld.startsWith("xn--"))
+    return null;
+  if (!/^[a-z0-9-]+$/.test(parts[parts.length - 2]))
+    return null;
+  return v;
+}
+function escapeCsvCell(raw) {
+  if (raw == null)
+    return "";
+  let s = String(raw);
+  const trimmed = s.replace(/^[\s\r\n\t]+/, "");
+  if (trimmed.length > 0) {
+    const first = trimmed[0];
+    if (first === "=" || first === "+" || first === "-" || first === "@") {
+      s = "'" + s;
+    }
+  }
+  if (/[",\n\r]/.test(s)) {
+    s = '"' + s.replace(/"/g, '""') + '"';
+  }
+  return s;
+}
+function synthesizeCsv(header, rows) {
+  const headerLine = header.map(escapeCsvCell).join(",");
+  const dataLines = rows.map((r) => header.map((col) => escapeCsvCell(r[col] ?? "")).join(","));
+  return [headerLine, ...dataLines].join("\n") + "\n";
+}
+function chunkAt100(items) {
+  if (items.length === 0)
+    return [];
+  const chunks = [];
+  for (let i = 0; i < items.length; i += CHUNK_SIZE) {
+    chunks.push(items.slice(i, i + CHUNK_SIZE));
+  }
+  return chunks;
+}
+function checkAborted(signal) {
+  if (signal?.aborted) {
+    throw Object.assign(new Error("aborted"), { name: "AbortError" });
+  }
+}
+async function sleepWithAbort(ms, signal) {
+  if (!signal) {
+    await new Promise((r) => setTimeout(r, ms));
+    return;
+  }
+  if (signal.aborted) {
+    checkAborted(signal);
+  }
+  await new Promise((resolve, reject) => {
+    const t = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(t);
+      signal.removeEventListener("abort", onAbort);
+      reject(Object.assign(new Error("aborted"), { name: "AbortError" }));
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function readCell(record, key) {
+  const want = key.toLowerCase();
+  const arr = record.records;
+  if (Array.isArray(arr)) {
+    for (const c of arr) {
+      const k = (c?.column_name ?? c?.key ?? c?.field ?? "").toString().toLowerCase();
+      if (k === want) {
+        const v = c?.value ?? null;
+        return v != null ? String(v) : null;
+      }
+    }
+  }
+  const cells = record.cells;
+  if (cells && typeof cells === "object" && !Array.isArray(cells)) {
+    for (const [k, v] of Object.entries(cells)) {
+      if (k.toLowerCase() === want) {
+        return v != null ? String(v) : null;
+      }
+    }
+  }
+  if (Array.isArray(cells)) {
+    for (const c of cells) {
+      const k = (c?.key ?? c?.field ?? c?.column_name ?? "").toString().toLowerCase();
+      if (k === want) {
+        const v = c?.value ?? null;
+        return v != null ? String(v) : null;
+      }
+    }
+  }
+  return null;
+}
+function validateColumnName(client, name, path) {
+  if (typeof name !== "string" || name.length === 0) {
+    throw client.makeError("IMPORT_INVALID_COLUMN_NAME", `Column name at ${path} must be a non-empty string`, `Use a plain string column name (1-${MAX_COLUMN_NAME_LEN} chars).`, "POST /imports");
+  }
+  if (name.length > MAX_COLUMN_NAME_LEN) {
+    throw client.makeError("IMPORT_INVALID_COLUMN_NAME", `Column name at ${path} exceeds ${MAX_COLUMN_NAME_LEN} chars`, `Shorten the column name to ${MAX_COLUMN_NAME_LEN} chars or fewer.`, "POST /imports");
+  }
+  if (/[\x00-\x1F\x7F]/.test(name)) {
+    throw client.makeError("IMPORT_INVALID_COLUMN_NAME", `Column name at ${path} contains control characters`, `Strip control characters (e.g. \\n, \\t, \\x00) from column names.`, "POST /imports");
+  }
+}
+function coerceCell(client, v, path) {
+  if (v == null)
+    return "";
+  if (typeof v === "string")
+    return v;
+  if (typeof v === "number" || typeof v === "boolean")
+    return String(v);
+  throw client.makeError("IMPORT_INVALID_CELL_TYPE", `Cell at ${path} is ${Array.isArray(v) ? "an array" : typeof v}, expected string|number|boolean|null`, `Convert the value to a string before passing.`, "POST /imports");
+}
+function prepareDomainsMode(client, inputs) {
+  const validInputs = [];
+  const malformedDomains = [];
+  const byDomain = /* @__PURE__ */ new Map();
+  const byRowId = /* @__PURE__ */ new Map();
+  for (const inp of inputs) {
+    const norm = normalizeDomain(inp?.domain ?? "");
+    if (!norm) {
+      malformedDomains.push(inp?.domain ?? "");
+      continue;
+    }
+    if (byDomain.has(norm))
+      continue;
+    const rowId = randomUUID();
+    const idx = validInputs.length;
+    const name = inp.name?.trim() || norm;
+    validInputs.push({
+      index: idx,
+      rowId,
+      row: { MCP_ROW_ID: rowId, LEAD_NAME: name, LEAD_WEBSITE: norm },
+      domain: norm,
+      outputDomain: norm
+    });
+    byDomain.set(norm, idx);
+    byRowId.set(rowId, idx);
+  }
+  return {
+    mode: "domains",
+    validInputs,
+    malformedDomains,
+    byDomain,
+    byRowId,
+    header: ["MCP_ROW_ID", "LEAD_NAME", "LEAD_WEBSITE"],
+    mappings: {
+      fields: { LEAD_NAME: "LEAD_NAME", LEAD_WEBSITE: "LEAD_WEBSITE" },
+      statuses: {},
+      default_status: null
+    }
+  };
+}
+function prepareRecordsMode(client, records, mappings) {
+  if (!mappings || !mappings.fields || typeof mappings.fields !== "object") {
+    throw client.makeError("IMPORT_MAPPING_REQUIRED", "records[] requires a mappings.fields object", "Pass `mappings: { fields: { CsvColumn: 'LEAD_NAME', ... } }`.", "POST /imports");
+  }
+  const fieldEntries = Object.entries(mappings.fields);
+  if (fieldEntries.length === 0) {
+    throw client.makeError("IMPORT_MAPPING_REQUIRED", "mappings.fields must contain at least one column \u2192 CRM field entry", "Map at least one CSV column to LEAD_NAME or LEAD_WEBSITE.", "POST /imports");
+  }
+  const targets = new Set(fieldEntries.map(([, v]) => v));
+  if (!targets.has("LEAD_NAME") && !targets.has("LEAD_WEBSITE")) {
+    throw client.makeError("IMPORT_MAPPING_NO_RESOLVER", "mappings.fields must include LEAD_NAME or LEAD_WEBSITE", "The wizard needs at least one of those fields to match a lead. Map a CSV column to one of them.", "POST /imports");
+  }
+  for (const [colName] of fieldEntries) {
+    validateColumnName(client, colName, `mappings.fields[${JSON.stringify(colName)}]`);
+    if (RESERVED_COLUMN_RE.test(colName)) {
+      throw client.makeError("IMPORT_RESERVED_COLUMN", `mappings.fields key '${colName}' collides with reserved synthetic column MCP_ROW_ID`, `Rename the column. MCP_ROW_ID (any case) is reserved for tool-internal reconciliation.`, "POST /imports");
+    }
+  }
+  const headerSet = /* @__PURE__ */ new Set();
+  const coercedRecords = [];
+  records.forEach((rec, i) => {
+    if (rec == null || typeof rec !== "object" || Array.isArray(rec)) {
+      throw client.makeError("IMPORT_INVALID_CELL_TYPE", `records[${i}] must be a plain object`, `Pass each record as { ColumnName: value, ... }.`, "POST /imports");
+    }
+    const out = {};
+    for (const [k, v] of Object.entries(rec)) {
+      validateColumnName(client, k, `records[${i}] key`);
+      if (RESERVED_COLUMN_RE.test(k)) {
+        throw client.makeError("IMPORT_RESERVED_COLUMN", `records[${i}] key '${k}' collides with reserved synthetic column MCP_ROW_ID`, `Rename the column in your records (any case variant of MCP_ROW_ID is reserved).`, "POST /imports");
+      }
+      out[k] = coerceCell(client, v, `records[${i}].${k}`);
+      headerSet.add(k);
+    }
+    coercedRecords.push(out);
+  });
+  for (const [colName] of fieldEntries) {
+    if (!headerSet.has(colName)) {
+      throw client.makeError("IMPORT_MAPPING_KEY_UNKNOWN", `mappings.fields key '${colName}' is not present in any record`, `Add a value for '${colName}' to at least one record, or remove it from mappings.`, "POST /imports");
+    }
+  }
+  const userKeys = [...headerSet].sort();
+  const header = ["MCP_ROW_ID", ...userKeys];
+  const websiteCol = fieldEntries.find(([, v]) => v === "LEAD_WEBSITE")?.[0];
+  const validInputs = [];
+  const byDomain = /* @__PURE__ */ new Map();
+  const byRowId = /* @__PURE__ */ new Map();
+  coercedRecords.forEach((row) => {
+    const rowId = randomUUID();
+    const idx = validInputs.length;
+    let normDomain = null;
+    if (websiteCol) {
+      normDomain = normalizeDomain(row[websiteCol] ?? "");
+    }
+    const fullRow = { MCP_ROW_ID: rowId, ...row };
+    validInputs.push({
+      index: idx,
+      rowId,
+      row: fullRow,
+      domain: normDomain,
+      outputDomain: normDomain ?? void 0
+    });
+    byRowId.set(rowId, idx);
+    if (normDomain && !byDomain.has(normDomain))
+      byDomain.set(normDomain, idx);
+  });
+  return {
+    mode: "records",
+    validInputs,
+    malformedDomains: [],
+    byDomain,
+    byRowId,
+    header,
+    mappings: {
+      fields: { ...mappings.fields },
+      statuses: mappings.statuses ?? {},
+      default_status: mappings.default_status ?? null
+    }
+  };
+}
+async function pollUntil(fn, done, budgetMs, signal, ctx, label) {
+  const deadline = Date.now() + budgetMs;
+  let last;
+  while (true) {
+    checkAborted(signal);
+    last = await fn();
+    if (done(last))
+      return last;
+    if (Date.now() >= deadline) {
+      ctx?.logger?.warn?.(`import-leads: ${label} budget exhausted (${budgetMs}ms)`);
+      return last;
+    }
+    await sleepWithAbort(POLL_INTERVAL_MS, signal);
+  }
+}
+async function pollPreprocess(client, importId, budgetMs, ctx, signal) {
+  const result = await pollUntil(() => client.request("GET", `/imports/${importId}`), (r) => Boolean(r.pre_processing?.finished), budgetMs, signal, ctx, "preprocess");
+  if (!result.pre_processing?.finished) {
+    throw client.makeError("IMPORT_BUDGET_EXHAUSTED", `Preprocess phase did not finish within ${budgetMs}ms`, `Increase per_phase_budget_ms (current: ${budgetMs}) or split the batch. importId=${importId}.`, `GET /imports/${importId}`);
+  }
+  if (result.pre_processing.error) {
+    throw client.makeError("IMPORT_PREPROCESS_FAILED", `Preprocess failed: ${result.pre_processing.error}`, `Check the input domains. importId=${importId} for backend debugging.`, `GET /imports/${importId}`);
+  }
+  return result;
+}
+async function pollProcess(client, importId, budgetMs, ctx, signal) {
+  const result = await pollUntil(() => client.request("GET", `/imports/${importId}`), (r) => Boolean(r.processing?.finished), budgetMs, signal, ctx, "process");
+  if (!result.processing?.finished) {
+    throw client.makeError("IMPORT_BUDGET_EXHAUSTED", `Process phase did not finish within ${budgetMs}ms`, `Increase per_phase_budget_ms (current: ${budgetMs}) or split the batch. importId=${importId}.`, `GET /imports/${importId}`);
+  }
+  if (result.processing.error != null) {
+    throw client.makeError("IMPORT_PROCESSING_FAILED", `Backend processing failed: ${result.processing.error}`, `importId=${importId}.`, `GET /imports/${importId}`);
+  }
+  return result;
+}
+async function pollRecordsToTerminal(client, importId, budgetMs, expectedRowCount, ctx, signal) {
+  const deadline = Date.now() + budgetMs;
+  const maxPagesPerPoll = Math.max(2, Math.ceil(expectedRowCount / 100) * 2 + 4);
+  let stableCounts = 0;
+  let lastSnapshot = null;
+  while (true) {
+    checkAborted(signal);
+    let total = 0;
+    let transient = 0;
+    let pagesFetched = 0;
+    let exhaustedPagination = false;
+    const records = [];
+    for (let page = 0; page < maxPagesPerPoll; page++) {
+      checkAborted(signal);
+      const qs = `count=100&page=${page}&automatic_match=true&manual_match=true&no_match=true&matching=true&importing=true&imported=true`;
+      const res = await client.request("GET", `/imports/${importId}/records?${qs}`);
+      pagesFetched++;
+      records.push(...res.items);
+      total = res.pagination.total ?? records.length;
+      for (const r of res.items) {
+        const status = (r.status ?? "").toString().toUpperCase();
+        const matchType = (r.match_type ?? r.matchType ?? "").toString().toUpperCase();
+        const isTerminal = matchType === "NO_MATCH" || status === "IMPORTED";
+        if (!isTerminal)
+          transient++;
+      }
+      const totalPages = res.pagination.pages ?? 0;
+      if (page + 1 >= totalPages) {
+        exhaustedPagination = true;
+        break;
+      }
+    }
+    if (!exhaustedPagination) {
+      throw client.makeError("IMPORT_PAGINATION_RUNAWAY", `Records pagination exceeded ${maxPagesPerPoll} pages`, `importId=${importId}. Please file a bug at https://github.com/leadbay/leadclaw/issues.`, `GET /imports/${importId}/records`);
+    }
+    const snapshot = { total, transient };
+    const settled = transient === 0;
+    const stableVsLast = lastSnapshot != null && lastSnapshot.total === snapshot.total && lastSnapshot.transient === snapshot.transient;
+    if (settled && stableVsLast) {
+      stableCounts++;
+    } else if (settled) {
+      stableCounts = 1;
+    } else {
+      stableCounts = 0;
+    }
+    lastSnapshot = snapshot;
+    if (settled && stableCounts >= STABILIZATION_POLLS) {
+      return records;
+    }
+    if (Date.now() >= deadline) {
+      ctx?.logger?.warn?.(`import-leads: records did not stabilize (transient=${transient}, total=${total}); returning best-effort`);
+      throw client.makeError("IMPORT_NOT_TERMINAL", `Backend hasn't fully settled records within ${budgetMs}ms`, `Retry leadbay_import_leads with the same input in 30s, or split the batch. importId=${importId}.`, `GET /imports/${importId}/records`);
+    }
+    await sleepWithAbort(POLL_INTERVAL_MS, signal);
+  }
+}
+async function runOneChunk(client, chunk, chunkIdx, totalChunks, header, mappings, dryRun, perPhaseBudgetMs, totalDeadline, ctx, signal, onImportId) {
+  const csv = synthesizeCsv(header, chunk.map((c) => c.row));
+  const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const fileName = `mcp-import-${ts}-${chunkIdx}.csv`;
+  ctx?.logger?.info?.(`import-leads: uploading chunk ${chunkIdx + 1}/${totalChunks} (${chunk.length} rows, ${csv.length}B)`);
+  const upload = await client.requestRawBinary("POST", `/imports?file_name=${encodeURIComponent(fileName)}`, "text/csv", csv);
+  const importId = upload.id;
+  onImportId(importId);
+  const phaseBudget = Math.min(perPhaseBudgetMs, Math.max(1, totalDeadline - Date.now()));
+  await pollPreprocess(client, importId, phaseBudget, ctx, signal);
+  ctx?.logger?.info?.(`import-leads: preprocess done for importId=${importId}`);
+  if (dryRun) {
+    return { importId, records: [] };
+  }
+  await client.requestVoid("POST", `/imports/${importId}/update_mappings`, mappings);
+  ctx?.logger?.info?.(`import-leads: mappings committed for importId=${importId}`);
+  const phaseBudget2 = Math.min(perPhaseBudgetMs, Math.max(1, totalDeadline - Date.now()));
+  await pollProcess(client, importId, phaseBudget2, ctx, signal);
+  ctx?.logger?.info?.(`import-leads: process done for importId=${importId}`);
+  const phaseBudget3 = Math.min(perPhaseBudgetMs, Math.max(1, totalDeadline - Date.now()));
+  const records = await pollRecordsToTerminal(client, importId, phaseBudget3, chunk.length, ctx, signal);
+  ctx?.logger?.info?.(`import-leads: ${records.length} records terminal for importId=${importId}`);
+  return { importId, records };
+}
+function reconcileOneChunk(prep, chunk, matched, notImported) {
+  const seenInputIndex = /* @__PURE__ */ new Set();
+  const sortedRecords = [...chunk.records].sort((a, b) => {
+    const aHasLead = a.lead?.id ? 0 : 1;
+    const bHasLead = b.lead?.id ? 0 : 1;
+    return aHasLead - bHasLead;
+  });
+  for (const rec of sortedRecords) {
+    let inputIdx;
+    const rowIdCell = readCell(rec, "MCP_ROW_ID");
+    if (rowIdCell && prep.byRowId.has(rowIdCell)) {
+      inputIdx = prep.byRowId.get(rowIdCell);
+    }
+    if (inputIdx === void 0) {
+      const websiteCell = readCell(rec, "LEAD_WEBSITE");
+      if (websiteCell) {
+        const norm = normalizeDomain(websiteCell);
+        if (norm && prep.byDomain.has(norm)) {
+          inputIdx = prep.byDomain.get(norm);
+        }
+      }
+    }
+    if (inputIdx === void 0 && rec.lead?.website) {
+      const norm = normalizeDomain(rec.lead.website);
+      if (norm && prep.byDomain.has(norm)) {
+        inputIdx = prep.byDomain.get(norm);
+      }
+    }
+    if (inputIdx === void 0)
+      continue;
+    if (seenInputIndex.has(inputIdx)) {
+      if (!matched.has(inputIdx) && !notImported.has(inputIdx)) {
+        const inp2 = prep.validInputs[inputIdx];
+        notImported.set(inputIdx, { domain: inp2.outputDomain, reason: "ambiguous" });
+      }
+      continue;
+    }
+    seenInputIndex.add(inputIdx);
+    const inp = prep.validInputs[inputIdx];
+    const matchType = (rec.match_type ?? rec.matchType ?? "").toString();
+    if (rec.lead?.id) {
+      matched.set(inputIdx, {
+        domain: inp.outputDomain,
+        leadId: rec.lead.id,
+        name: rec.lead.name ?? null
+      });
+    } else if (matchType === "NO_MATCH") {
+      const reason = inp.domain && PUBLIC_MAILBOX_DOMAINS.has(inp.domain) ? "no_match" : "uncrawled";
+      notImported.set(inputIdx, { domain: inp.outputDomain, reason });
+    } else {
+      notImported.set(inputIdx, { domain: inp.outputDomain, reason: "internal_error" });
+    }
+  }
+}
+var importLeads = {
+  name: "leadbay_import_leads",
+  description: "Import leads into Leadbay's CRM via the file-import wizard. Returns stable Leadbay leadIds for downstream chaining into leadbay_bulk_qualify_leads / leadbay_research_lead.\n\nTWO MODES:\n  A) Domain-list shortcut \u2014 pass `domains: [{domain, name?}]`. The tool builds a 2-column CSV (LEAD_NAME, LEAD_WEBSITE) and imports with the default mapping. Output: { leads: [{domain, leadId, name}], not_imported: [{domain, reason}], importIds, _meta }.\n  B) Custom records + mapping \u2014 pass `records: [{Col1, Col2, ...}]` plus `mappings.fields: {Col1: 'LEAD_NAME', Col2: 'LEAD_WEBSITE', ...}`. The tool synthesizes a CSV from the union of record keys (deterministic order) and POSTs the caller-supplied mapping to the wizard. mappings.fields must include LEAD_NAME or LEAD_WEBSITE (the resolver needs at least one). Output: { leads: [{rowId, domain?, leadId, name}], not_imported: [{rowId, domain?, reason}], importIds, _meta }. `rowId` round-trips your input order.\n\nPass exactly one of `domains` / `records`. Reserved column MCP_ROW_ID (any case) cannot appear in records or mappings \u2014 the tool injects it for stable reconciliation.\n\n\u26A0\uFE0F MUTATES USER STATE. Each call:\n  - creates a row in the user's CRM-imports list (visible in the web UI)\n  - touches onboarding state (startFileless, onboarding step \u2192 PROCESSING)\nSuitable for occasional automation. NOT suitable for high-cadence (>5 calls/day) \u2014 wait for the backend programmatic endpoint (issue: leadbay/backend prolonged-import-with-crawl).\n\nWhen to use: you have a list of company domains from another system (CRM, analytics, email correspondents) and need stable Leadbay leadIds; or you have CRM-shaped rows with custom columns (sector, location, status, etc.) and want to drive the wizard with explicit field mappings.\nWhen NOT to use: for prospect discovery (use leadbay_pull_leads); for one specific company's profile (use leadbay_research_company); when you can't tolerate the side effects above.\n\nRequires: LEADBAY_MCP_WRITE=1 (MCP) or exposeWrite=true (OpenClaw); admin role on the Leadbay account; active billing.",
+  write: true,
+  version: "0.2.0",
+  inputSchema: {
+    type: "object",
+    properties: {
+      domains: {
+        type: "array",
+        description: "Mode A: list of company domains to map to Leadbay leadIds. Mutually exclusive with `records`.",
+        items: {
+          type: "object",
+          properties: {
+            domain: {
+              type: "string",
+              description: "Company domain (e.g. 'apple.com'). Protocol/path are stripped."
+            },
+            name: {
+              type: "string",
+              description: "Optional display name override; defaults to the domain."
+            }
+          },
+          required: ["domain"]
+        }
+      },
+      records: {
+        type: "array",
+        description: "Mode B: arbitrary CSV-shaped rows. Each record is an object whose keys are column names and values are scalar (string/number/boolean/null). Mutually exclusive with `domains`. Must be accompanied by `mappings.fields`. The tool synthesizes a CSV from the union of all record keys.",
+        items: { type: "object" }
+      },
+      mappings: {
+        type: "object",
+        description: "Mode B: how each CSV column maps to Leadbay's CRM field schema. Required when `records` is supplied; ignored otherwise.",
+        properties: {
+          fields: {
+            type: "object",
+            description: "Object whose keys are CSV column names (matching keys in `records`) and whose values are Leadbay CRM field types (LEAD_NAME, LEAD_WEBSITE, LEAD_STATUS, LEAD_LOCATION, LEAD_SECTOR, LEAD_SIZE, CRM_ID, LEADBAY_ID, EMAIL, DEAL_CRM_ID, CONTACT_TITLE, LEAD_STATUS_DATE). At least one entry must target LEAD_NAME or LEAD_WEBSITE \u2014 the wizard needs that to find leads."
+          },
+          statuses: {
+            type: "object",
+            description: "Optional status string mapping (rarely needed). Defaults to {}."
+          },
+          default_status: {
+            type: ["string", "null"],
+            description: "Optional default status. Defaults to null."
+          }
+        },
+        required: ["fields"]
+      },
+      dry_run: {
+        type: "boolean",
+        description: "If true, run preprocess only \u2014 do NOT commit lead-CRM linking. Note: an import row still appears in the user's CRM-imports list as 'incomplete'. Use to verify input format / wizard reachability without polluting the CRM."
+      },
+      per_phase_budget_ms: {
+        type: "number",
+        description: `Single poll-loop cap (default ${DEFAULT_PER_PHASE_BUDGET_MS}ms).`
+      },
+      total_budget_ms: {
+        type: "number",
+        description: `Overall cap across all phases (default ${DEFAULT_TOTAL_BUDGET_MS2}ms).`
+      }
+    }
+    // Neither field is "required" at the schema level; xor + presence is
+    // enforced in execute() so we can produce specific error codes.
+  },
+  execute: async (client, params, ctx) => {
+    const signal = ctx?.signal;
+    const dryRun = Boolean(params.dry_run);
+    const perPhaseBudget = params.per_phase_budget_ms ?? DEFAULT_PER_PHASE_BUDGET_MS;
+    const totalBudget = params.total_budget_ms ?? DEFAULT_TOTAL_BUDGET_MS2;
+    const totalDeadline = Date.now() + totalBudget;
+    const hasDomains = Array.isArray(params.domains) && params.domains.length > 0;
+    const hasRecords = Array.isArray(params.records) && params.records.length > 0;
+    if (hasDomains && hasRecords) {
+      throw client.makeError("IMPORT_INPUT_CONFLICT", "Pass exactly one of `domains` or `records`, not both", "Use `domains` for the simple shortcut, or `records`+`mappings` for arbitrary CSV input.", "POST /imports");
+    }
+    if (!hasDomains && !hasRecords) {
+      throw client.makeError("IMPORT_EMPTY_INPUT", "domains[] or records[] must contain at least one entry", "Pass at least one entry. See the tool description for the two input modes.", "POST /imports");
+    }
+    const me = await client.resolveMe();
+    if (!me.admin) {
+      throw client.makeError("IMPORT_ADMIN_REQUIRED", "This tool requires admin role on the Leadbay account", "Ask the account owner to grant import permission, or use a token from an admin user.", "POST /imports");
+    }
+    const prep = hasDomains ? prepareDomainsMode(client, params.domains) : prepareRecordsMode(client, params.records, params.mappings);
+    if (prep.validInputs.length === 0) {
+      const not_imported2 = prep.malformedDomains.map((d) => ({
+        domain: d,
+        reason: "malformed"
+      }));
+      return {
+        leads: [],
+        not_imported: not_imported2,
+        importIds: [],
+        region: client.region,
+        dry_run: dryRun || void 0,
+        _meta: client.lastMeta ?? {
+          region: client.region,
+          endpoint: "POST /imports",
+          latency_ms: null,
+          retry_after: null
+        }
+      };
+    }
+    const chunks = chunkAt100(prep.validInputs);
+    ctx?.logger?.info?.(`import-leads(${prep.mode}): ${prep.validInputs.length} rows \u2192 ${chunks.length} chunk(s); dry_run=${dryRun}, totalBudgetMs=${totalBudget}`);
+    const importIds = [];
+    const matched = /* @__PURE__ */ new Map();
+    const notImported = /* @__PURE__ */ new Map();
+    let cancelled = false;
+    const recordImportId = (id) => {
+      if (!importIds.includes(id))
+        importIds.push(id);
+    };
+    try {
+      for (let i = 0; i < chunks.length; i++) {
+        const chunk = chunks[i];
+        const out = await runOneChunk(client, chunk, i, chunks.length, prep.header, prep.mappings, dryRun, perPhaseBudget, totalDeadline, ctx, signal, recordImportId);
+        if (!dryRun) {
+          reconcileOneChunk(prep, out, matched, notImported);
+        }
+      }
+    } catch (err) {
+      if (err?.name === "AbortError") {
+        cancelled = true;
+        ctx?.logger?.info?.(`import-leads: aborted via signal; importIds=${importIds.join(",")}`);
+      } else if (err?.error === true) {
+        if (err.code === "FORBIDDEN") {
+          throw client.makeError("IMPORT_ADMIN_REQUIRED", err.message || "Insufficient permissions for /imports", "This tool requires admin role on the Leadbay account. Ask the account owner.", err._meta?.endpoint);
+        }
+        if (err.code === "BILLING_SUSPENDED") {
+          throw client.makeError("IMPORT_BILLING_REQUIRED", err.message || "Active billing required for imports", "Upgrade at https://app.leadbay.ai/billing, then retry.", err._meta?.endpoint);
+        }
+        throw err;
+      } else {
+        throw err;
+      }
+    }
+    const leads = [];
+    const not_imported = [];
+    if (dryRun) {
+      for (const inp of prep.validInputs) {
+        if (prep.mode === "domains") {
+          not_imported.push({ domain: inp.outputDomain, reason: "dry_run" });
+        } else {
+          const entry = { rowId: inp.rowId, reason: "dry_run" };
+          if (inp.outputDomain)
+            entry.domain = inp.outputDomain;
+          not_imported.push(entry);
+        }
+      }
+    } else {
+      for (const inp of prep.validInputs) {
+        const m = matched.get(inp.index);
+        if (m) {
+          if (prep.mode === "domains") {
+            leads.push({
+              domain: inp.outputDomain,
+              leadId: m.leadId,
+              name: m.name
+            });
+          } else {
+            const e = {
+              rowId: inp.rowId,
+              leadId: m.leadId,
+              name: m.name
+            };
+            if (m.domain ?? inp.outputDomain)
+              e.domain = m.domain ?? inp.outputDomain;
+            leads.push(e);
+          }
+          continue;
+        }
+        const ni = notImported.get(inp.index);
+        if (ni) {
+          if (prep.mode === "domains") {
+            not_imported.push({ domain: inp.outputDomain, reason: ni.reason });
+          } else {
+            const e = { rowId: inp.rowId, reason: ni.reason };
+            if (ni.domain ?? inp.outputDomain)
+              e.domain = ni.domain ?? inp.outputDomain;
+            not_imported.push(e);
+          }
+          continue;
+        }
+        if (prep.mode === "domains") {
+          not_imported.push({ domain: inp.outputDomain, reason: "internal_error" });
+        } else {
+          const e = { rowId: inp.rowId, reason: "internal_error" };
+          if (inp.outputDomain)
+            e.domain = inp.outputDomain;
+          not_imported.push(e);
+        }
+      }
+    }
+    for (const m of prep.malformedDomains) {
+      not_imported.push({ domain: m, reason: "malformed" });
+    }
+    return {
+      leads,
+      not_imported,
+      importIds,
+      region: client.region,
+      cancelled: cancelled || void 0,
+      dry_run: dryRun || void 0,
+      _meta: client.lastMeta ?? {
+        region: client.region,
+        endpoint: "POST /imports",
+        latency_ms: null,
+        retry_after: null
+      }
+    };
+  }
+};
+
 // ../core/dist/composite/enrich-titles.js
 var DEFAULT_CANDIDATE_COUNT = 25;
 var enrichTitles = {
@@ -2421,7 +3184,7 @@ import { mkdir as mkdirAsync, lstat, open as fsOpen, readFile, rename, stat, unl
 import { constants as fsConstants } from "fs";
 import { dirname, resolve as resolvePath } from "path";
 import { homedir, platform } from "os";
-import { createHash, randomUUID } from "crypto";
+import { createHash, randomUUID as randomUUID2 } from "crypto";
 var DEFAULT_IDEMPOTENCY_WINDOW_MS = 5 * 60 * 1e3;
 var TTL_MS = 30 * 24 * 60 * 60 * 1e3;
 var UUIDV4_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
@@ -2675,7 +3438,7 @@ var LocalBulkStore = class {
         };
       }
       const record = {
-        bulk_id: randomUUID(),
+        bulk_id: randomUUID2(),
         launched_at: new Date(nowMs).toISOString(),
         lead_ids,
         titles,
@@ -3205,14 +3968,14 @@ var refinePrompt = {
         would_call: {
           method: "POST",
           path: `/organizations/${orgId}/user_prompt`,
-          body: { prompt: params.prompt }
+          body: { user_prompt: params.prompt }
         }
       };
     }
     const postedAt = Date.now();
     const STALE_GUARD_MS = 5e3;
     await client.requestVoid("POST", `/organizations/${orgId}/user_prompt`, {
-      prompt: params.prompt
+      user_prompt: params.prompt
     });
     client.invalidateMe();
     const attempts = params.clarification_poll_attempts ?? DEFAULT_POLL_ATTEMPTS;
@@ -3521,7 +4284,8 @@ var compositeWriteTools = [
   adjustAudience,
   refinePrompt,
   answerClarification,
-  reportOutreach
+  reportOutreach,
+  importLeads
 ];
 var compositeTools = [
   ...compositeReadTools,
@@ -3532,6 +4296,7 @@ var tools = [...compositeTools, ...granularTools];
 export {
   REGIONS,
   createClient,
+  formatLoginError,
   resolveRegion,
   getMockJournal,
   clearMockJournal,
@@ -3582,6 +4347,7 @@ export {
   recallOrderedTitles,
   accountStatus,
   bulkQualifyLeads,
+  importLeads,
   enrichTitles,
   isValidBulkId,
   LocalBulkStore,