@mackody/quickenrich-mcp 0.1.0

package/scripts/quickenrich-mcp.mjs

@@ -0,0 +1,201 @@
+#!/usr/bin/env node
+
+import { appendFileSync } from "node:fs";
+import {
+  SERVER_VERSION,
+  TOOL_DEFINITIONS,
+  callQuickEnrichTool,
+  createClient,
+  redact,
+  selectTools,
+  summarizeValue,
+  toolPayloadText,
+} from "./lib/core.mjs";
+
+const SERVER_NAME = process.env.QUICKENRICH_MCP_SERVER_NAME || "quick-enrich";
+const MAX_MESSAGE_BYTES = Number(process.env.QUICKENRICH_MCP_MAX_MESSAGE_BYTES || 8 * 1024 * 1024);
+const DEBUG_LOG = process.env.QUICKENRICH_MCP_DEBUG_LOG;
+const VERBOSE_ERRORS = /^(1|true|yes|debug|verbose)$/i.test(String(process.env.QUICKENRICH_MCP_VERBOSE_ERRORS || ""));
+const PRETTY_TOOL_OUTPUT = /^(1|true|yes|pretty)$/i.test(String(process.env.QUICKENRICH_MCP_PRETTY_JSON || ""));
+
+const client = createClient();
+
+function debugLog(event) {
+  if (!DEBUG_LOG) return;
+  try {
+    appendFileSync(DEBUG_LOG, `${JSON.stringify({ t: new Date().toISOString(), ...event })}\n`, { mode: 0o600 });
+  } catch {
+    // Debug logging must never break MCP transport.
+  }
+}
+
+function writeMessage(message) {
+  let json = JSON.stringify(message);
+  if (Buffer.byteLength(json, "utf8") > MAX_MESSAGE_BYTES) {
+    json = JSON.stringify({
+      jsonrpc: "2.0",
+      id: message?.id ?? null,
+      error: {
+        code: -32000,
+        message: `MCP response exceeded ${MAX_MESSAGE_BYTES} bytes. Use response:{mode:"compact"} or response:{mode:"meta"}.`,
+      },
+    });
+  }
+  const bytes = Buffer.byteLength(json, "utf8");
+  debugLog({ direction: "out", id: message?.id, bytes, error: message?.error?.message, framing: responseFraming });
+  if (responseFraming === "json-lines") {
+    process.stdout.write(`${json}\n`);
+    return;
+  }
+  process.stdout.write(`Content-Length: ${bytes}\r\n\r\n${json}`);
+}
+
+function success(id, result) {
+  writeMessage({ jsonrpc: "2.0", id, result });
+}
+
+function failure(id, error) {
+  debugLog({
+    direction: "error",
+    id,
+    name: error?.name,
+    message: error?.message || String(error),
+    stack: VERBOSE_ERRORS ? error?.stack : undefined,
+    resultShape: error?.result ? summarizeValue(redact(error.result)) : undefined,
+  });
+  writeMessage({
+    jsonrpc: "2.0",
+    id,
+    error: {
+      code: -32000,
+      message: error?.message || String(error),
+      data: {
+        result: error?.result ? redact(error.result) : undefined,
+        debug: VERBOSE_ERRORS ? redact({ name: error?.name, stack: error?.stack }) : undefined,
+      },
+    },
+  });
+}
+
+function textResult(payload) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: toolPayloadText(payload, PRETTY_TOOL_OUTPUT),
+      },
+    ],
+  };
+}
+
+async function handle(message) {
+  if (!message || typeof message !== "object") return;
+  debugLog({
+    direction: "in",
+    id: message.id,
+    method: message.method,
+    paramKeys: message.params && typeof message.params === "object" ? Object.keys(message.params) : undefined,
+  });
+  if (message.method === "initialize") {
+    return success(message.id, {
+      protocolVersion: message.params?.protocolVersion || "2024-11-05",
+      capabilities: { tools: {}, resources: {}, prompts: {} },
+      serverInfo: { name: SERVER_NAME, version: SERVER_VERSION },
+    });
+  }
+  if (message.method === "notifications/initialized") return;
+  if (message.method === "ping") return success(message.id, {});
+  if (message.method === "resources/list") return success(message.id, { resources: [] });
+  if (message.method === "resources/templates/list") return success(message.id, { resourceTemplates: [] });
+  if (message.method === "prompts/list") return success(message.id, { prompts: [] });
+  if (message.method === "tools/list") return success(message.id, { tools: selectTools(TOOL_DEFINITIONS) });
+  if (message.method === "tools/call") {
+    try {
+      const result = await callQuickEnrichTool(message.params?.name, message.params?.arguments || {}, client);
+      return success(message.id, textResult(result));
+    } catch (error) {
+      return failure(message.id, error);
+    }
+  }
+  if (message.id !== undefined) return failure(message.id, new Error(`Unsupported MCP method: ${message.method}`));
+}
+
+let buffer = Buffer.alloc(0);
+let responseFraming = "content-length";
+
+function firstNonWhitespaceBytePosition() {
+  let index = 0;
+  while (index < buffer.length) {
+    const value = buffer[index];
+    if (value === 32 || value === 9 || value === 10 || value === 13) {
+      index += 1;
+      continue;
+    }
+    return index;
+  }
+  return -1;
+}
+
+function parseJsonLineFrame() {
+  const newlineIndex = buffer.indexOf("\n");
+  if (newlineIndex === -1) return false;
+
+  const lineEnd = newlineIndex > 0 && buffer[newlineIndex - 1] === 13 ? newlineIndex - 1 : newlineIndex;
+  const line = buffer.slice(0, lineEnd).toString("utf8");
+  buffer = buffer.slice(newlineIndex + 1);
+  if (!line) return true;
+  responseFraming = "json-lines";
+  try {
+    void handle(JSON.parse(line));
+  } catch (error) {
+    failure(null, error);
+  }
+  return true;
+}
+
+function parseContentLengthFrame() {
+  const headerEnd = buffer.indexOf("\r\n\r\n");
+  if (headerEnd === -1) return false;
+  const header = buffer.slice(0, headerEnd).toString("utf8");
+  const match = header.match(/Content-Length:\s*(\d+)/i);
+  if (!match) {
+    buffer = buffer.slice(headerEnd + 4);
+    return true;
+  }
+  responseFraming = "content-length";
+  const length = Number(match[1]);
+  if (length > MAX_MESSAGE_BYTES) {
+    buffer = Buffer.alloc(0);
+    failure(null, new Error(`MCP message declared ${length} bytes, above ${MAX_MESSAGE_BYTES}.`));
+    return false;
+  }
+  const bodyStart = headerEnd + 4;
+  const bodyEnd = bodyStart + length;
+  if (buffer.length < bodyEnd) return false;
+  const body = buffer.slice(bodyStart, bodyEnd).toString("utf8");
+  buffer = buffer.slice(bodyEnd);
+  try {
+    void handle(JSON.parse(body));
+  } catch (error) {
+    failure(null, error);
+  }
+  return true;
+}
+
+process.stdin.on("data", (chunk) => {
+  buffer = Buffer.concat([buffer, chunk]);
+  if (buffer.length > MAX_MESSAGE_BYTES) {
+    buffer = Buffer.alloc(0);
+    failure(null, new Error(`MCP message exceeded ${MAX_MESSAGE_BYTES} bytes.`));
+    return;
+  }
+  while (true) {
+    const prefixIndex = firstNonWhitespaceBytePosition();
+    if (prefixIndex === -1) return;
+    const first = buffer[prefixIndex];
+    const parsed = first === 0x7b || first === 0x5b ? parseJsonLineFrame() : parseContentLengthFrame();
+    if (!parsed) return;
+  }
+});
+
+process.stdin.resume();

package/scripts/quickenrich-token.mjs

@@ -0,0 +1,175 @@
+#!/usr/bin/env node
+
+import { statSync } from "node:fs";
+import { stdin as input, stdout as output } from "node:process";
+import { createInterface } from "node:readline/promises";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  DEFAULT_DATA_DIR,
+  TOOL_DEFINITIONS,
+  agentGraph,
+  authStatus,
+  defaultConfigPath,
+  removeToken,
+  selectTools,
+  writeToken,
+} from "./lib/core.mjs";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const serverPath = join(__dirname, "quickenrich-mcp.mjs");
+
+function usage() {
+  return `Usage:
+  quickenrich-token status [--json] [--config <path>]
+  quickenrich-token set [token] [--config <path>]
+  quickenrich-token remove [--config <path>]
+  quickenrich-token test [--json] [--config <path>]
+  quickenrich-token doctor [--json] [--config <path>]
+  quickenrich-token install-config [--json]
+`;
+}
+
+function parseArgs(argv) {
+  const args = { _: [] };
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === "--json") args.json = true;
+    else if (arg === "--config") {
+      args.config = argv[i + 1];
+      i += 1;
+    } else args._.push(arg);
+  }
+  return args;
+}
+
+async function readTokenFromStdin() {
+  if (!input.isTTY) {
+    const chunks = [];
+    for await (const chunk of input) chunks.push(chunk);
+    return Buffer.concat(chunks).toString("utf8").trim();
+  }
+  const rl = createInterface({ input, output });
+  try {
+    return (await rl.question("Quick Enrich API key: ")).trim();
+  } finally {
+    rl.close();
+  }
+}
+
+function printStatus(json = false) {
+  const status = authStatus();
+  if (json) {
+    console.log(JSON.stringify(status, null, 2));
+    return;
+  }
+  console.log(`Quick Enrich API key: ${status.configured ? "configured" : "not configured"}`);
+  console.log(`Source: ${status.source}`);
+  console.log(`Config: ${status.configPath}`);
+  console.log(`API base: ${status.apiBaseUrl}`);
+}
+
+function doctorPayload() {
+  const status = authStatus();
+  const defaultTools = selectTools(TOOL_DEFINITIONS);
+  const fullTools = selectTools(TOOL_DEFINITIONS, "full");
+  const graph = agentGraph();
+  return {
+    ok: true,
+    auth: {
+      configured: status.configured,
+      source: status.source,
+      apiBaseUrl: status.apiBaseUrl,
+      configPath: status.configPath,
+    },
+    tools: {
+      defaultCount: defaultTools.length,
+      defaultBytes: Buffer.byteLength(JSON.stringify({ tools: defaultTools }), "utf8"),
+      fullCount: fullTools.length,
+      defaultBudgetBytes: graph.evalBudgets.toolsListBytes,
+    },
+    artifacts: {
+      dataDir: DEFAULT_DATA_DIR,
+      cacheDir: graph.cacheLedger.paths.cacheDir,
+      ledgerPath: graph.cacheLedger.paths.ledgerPath,
+      sharedThrottleDir: process.env.QUICKENRICH_MCP_SHARED_THROTTLE_DIR || join(DEFAULT_DATA_DIR, "throttle"),
+    },
+    server: {
+      command: process.execPath,
+      args: [serverPath],
+    },
+  };
+}
+
+function printDoctor(json = false) {
+  const payload = doctorPayload();
+  if (json) {
+    console.log(JSON.stringify(payload, null, 2));
+    return;
+  }
+  console.log(`Quick Enrich MCP doctor: ok`);
+  console.log(`Auth: ${payload.auth.configured ? "configured" : "not configured"} (${payload.auth.source})`);
+  console.log(`Default tools: ${payload.tools.defaultCount}, ${payload.tools.defaultBytes} bytes`);
+  console.log(`Cache: ${payload.artifacts.cacheDir}`);
+}
+
+function installConfigPayload() {
+  return {
+    mcpServers: {
+      "quick-enrich": {
+        command: process.execPath,
+        args: [serverPath],
+        env: {
+          QUICKENRICH_MCP_TOOL_MODE: "agent",
+        },
+      },
+    },
+  };
+}
+
+const args = parseArgs(process.argv.slice(2));
+const command = args._[0] || "status";
+if (args.config) process.env.QUICKENRICH_MCP_CONFIG = args.config;
+
+try {
+  if (command === "status") {
+    printStatus(Boolean(args.json));
+  } else if (command === "set") {
+    const token = args._[1] || await readTokenFromStdin();
+    const path = writeToken(token, args.config || defaultConfigPath());
+    const mode = statSync(path).mode & 0o777;
+    if (mode !== 0o600) throw new Error(`Config permissions are ${mode.toString(8)}, expected 600.`);
+    console.log(`Saved Quick Enrich API key to ${path}`);
+  } else if (command === "remove" || command === "rm") {
+    const path = removeToken(args.config || defaultConfigPath());
+    console.log(`Removed Quick Enrich API key from ${path}`);
+  } else if (command === "test") {
+    const status = authStatus();
+    const payload = {
+      ok: true,
+      configured: status.configured,
+      source: status.source,
+      apiBaseUrl: status.apiBaseUrl,
+      note: "Non-spend local auth/config test only. Use an MCP lookup call to verify network access.",
+    };
+    if (args.json) console.log(JSON.stringify(payload, null, 2));
+    else {
+      console.log(`Quick Enrich config test: ${payload.configured ? "configured" : "not configured"}`);
+      console.log(payload.note);
+    }
+  } else if (command === "doctor") {
+    printDoctor(Boolean(args.json));
+  } else if (command === "install-config") {
+    const payload = installConfigPayload();
+    if (args.json) console.log(JSON.stringify(payload, null, 2));
+    else console.log(JSON.stringify(payload, null, 2));
+  } else if (command === "help" || command === "--help" || command === "-h") {
+    process.stdout.write(usage());
+  } else {
+    process.stderr.write(usage());
+    process.exitCode = 2;
+  }
+} catch (error) {
+  console.error(error.message || String(error));
+  process.exitCode = 1;
+}

package/scripts/rate-limit-contract-smoke.mjs

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+
+import { createServer } from "node:http";
+import { performance } from "node:perf_hooks";
+import { callQuickEnrichTool, createClient } from "./lib/core.mjs";
+
+function assert(condition, message) {
+  if (!condition) throw new Error(message);
+}
+
+const startedAt = performance.now();
+const starts = [];
+
+const server = createServer(async (req, res) => {
+  const url = new URL(req.url, "http://127.0.0.1");
+  if (url.pathname === "/api/employees/dataset-search") {
+    starts.push(performance.now() - startedAt);
+    res.setHeader("content-type", "application/json");
+    res.end(JSON.stringify({
+      success: true,
+      data: [],
+      meta: { page: 1, per_page: 5, total: 0, last_page: 1, credits_used: 0, remaining_credits: 9999 },
+    }));
+    return;
+  }
+  res.statusCode = 404;
+  res.end(JSON.stringify({ error: "not found" }));
+});
+
+await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+const { port } = server.address();
+
+try {
+  process.env.QUICKENRICH_API_KEY = "rate-limit-test-key";
+  process.env.QUICKENRICH_API_BASE_URL = `http://127.0.0.1:${port}`;
+  const result = await callQuickEnrichTool("quickenrich_batch_pull_leads", {
+    companies: [
+      { company_url: "one.example", title: "Founder" },
+      { company_url: "two.example", title: "Founder" },
+      { company_url: "three.example", title: "Founder" },
+    ],
+    pages_per_company: 1,
+    per_page: 5,
+    concurrency: 3,
+    requests_per_minute: 300,
+    burst_size: 1,
+    response: { mode: "full" },
+  }, createClient());
+
+  assert(result.ok === true, "Batch should succeed.");
+  assert(result.requestCount === 3, `Expected 3 requests, got ${result.requestCount}.`);
+  assert(result.throttle?.requestsPerMinute === 300, `Expected 300 rpm throttle, got ${result.throttle?.requestsPerMinute}.`);
+  assert(result.throttle?.burstSize === 1, `Expected burstSize=1, got ${result.throttle?.burstSize}.`);
+  assert(starts.length === 3, `Expected 3 request starts, got ${starts.length}.`);
+
+  const firstGap = starts[1] - starts[0];
+  const secondGap = starts[2] - starts[1];
+  assert(firstGap >= 170, `Expected first paced gap >=170ms, got ${firstGap.toFixed(1)}ms.`);
+  assert(secondGap >= 170, `Expected second paced gap >=170ms, got ${secondGap.toFixed(1)}ms.`);
+
+  console.log(JSON.stringify({
+    ok: true,
+    starts: starts.map((value) => Math.round(value)),
+    firstGap: Math.round(firstGap),
+    secondGap: Math.round(secondGap),
+    throttle: result.throttle,
+  }, null, 2));
+} finally {
+  server.close();
+}

package/scripts/reverse-concurrency-floor-smoke.mjs

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+
+import { createServer } from "node:http";
+import { performance } from "node:perf_hooks";
+import { callQuickEnrichTool, createClient } from "./lib/core.mjs";
+
+function assert(condition, message) {
+  if (!condition) throw new Error(message);
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+let active = 0;
+let maxActive = 0;
+let requestCount = 0;
+
+const server = createServer(async (req, res) => {
+  const url = new URL(req.url, "http://127.0.0.1");
+  if (url.pathname !== "/api/employees/email-search") {
+    res.statusCode = 404;
+    res.end(JSON.stringify({ error: "not found" }));
+    return;
+  }
+  active += 1;
+  requestCount += 1;
+  maxActive = Math.max(maxActive, active);
+  try {
+    await sleep(45);
+    const email = url.searchParams.get("email");
+    res.setHeader("content-type", "application/json");
+    res.end(JSON.stringify({
+      success: true,
+      data: {
+        first_name: "Fast",
+        last_name: "Reverse",
+        email,
+        company_url: "floor.dev",
+      },
+      meta: { credits_used: 1, remaining_credits: 9999 },
+    }));
+  } finally {
+    active -= 1;
+  }
+});
+
+await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+const { port } = server.address();
+
+try {
+  process.env.QUICKENRICH_API_KEY = "reverse-concurrency-floor-key";
+  process.env.QUICKENRICH_API_BASE_URL = `http://127.0.0.1:${port}`;
+  const client = createClient();
+  const startedAt = performance.now();
+  const result = await callQuickEnrichTool("quickenrich_batch_reverse_email", {
+    emails: Array.from({ length: 64 }, (_, index) => `fast-${index}@floor.dev`),
+    concurrency: 64,
+    requests_per_minute: 100_000,
+    burst_size: 128,
+    export_format: "jsonl",
+    response: { mode: "full", maxOutputChars: 1_000_000 },
+  }, client);
+  const durationMs = performance.now() - startedAt;
+
+  assert(result.ok === true, "Reverse concurrency floor batch should succeed.");
+  assert(result.requestCount === 64, `Expected 64 reverse requests, got ${result.requestCount}.`);
+  assert(result.foundCount === 64, `Expected 64 found rows, got ${result.foundCount}.`);
+  assert(requestCount === 64, `Expected mock server to receive 64 requests, got ${requestCount}.`);
+  assert(maxActive >= 60, `Reverse batch should run as one high-concurrency wave, maxActive=${maxActive}.`);
+  assert(durationMs < 95, `Reverse high-concurrency wave should stay near one request-latency hop, got ${durationMs.toFixed(1)}ms.`);
+
+  console.log(JSON.stringify({
+    ok: true,
+    durationMs: Math.round(durationMs),
+    requestCount: result.requestCount,
+    maxActive,
+    exportBytes: Buffer.byteLength(result.export?.text || ""),
+  }, null, 2));
+} finally {
+  server.close();
+}

package/scripts/serialization-floor-smoke.mjs

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+
+import { compactToolPayload, toolPayloadText } from "./lib/core.mjs";
+
+function assert(condition, message) {
+  if (!condition) throw new Error(message);
+}
+
+const payload = {
+  ok: true,
+  rows: Array.from({ length: 750 }, (_, index) => ({
+    index,
+    first_name: `First${index}`,
+    last_name: `Last${index}`,
+    email: `person-${index}@example.com`,
+    company_url: `company-${index}.example`,
+    title: "Founder",
+  })),
+};
+
+const compacted = compactToolPayload(payload, { mode: "full", maxOutputChars: 1_000_000 });
+const first = toolPayloadText(compacted);
+const second = toolPayloadText(compacted);
+
+assert(first === second, "Tool payload serialization should be stable.");
+assert(first.includes("\"rows\""), "Serialized payload should include full rows.");
+assert(!Object.getOwnPropertySymbols(compacted).some((symbol) => symbol.description?.includes("secret")), "Serialization cache must not expose secret-like symbols.");
+
+const redacted = compactToolPayload({
+  ok: true,
+  Authorization: "Bearer secret-token",
+  nested: { api_key: "secret-key" },
+}, { mode: "full" });
+const redactedText = toolPayloadText(redacted);
+assert(!redactedText.includes("secret-token"), "Cached serialization must preserve bearer redaction.");
+assert(!redactedText.includes("secret-key"), "Cached serialization must preserve api_key redaction.");
+
+console.log(JSON.stringify({
+  ok: true,
+  bytes: Buffer.byteLength(first),
+  rows: compacted.rows.length,
+}, null, 2));

package/scripts/token-bucket-contract-smoke.mjs

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+
+import { createServer } from "node:http";
+import { performance } from "node:perf_hooks";
+import { callQuickEnrichTool, createClient } from "./lib/core.mjs";
+
+function assert(condition, message) {
+  if (!condition) throw new Error(message);
+}
+
+const startedAt = performance.now();
+const starts = [];
+
+const server = createServer(async (req, res) => {
+  const url = new URL(req.url, "http://127.0.0.1");
+  if (url.pathname === "/api/employees/email-search") {
+    starts.push({ email: url.searchParams.get("email"), t: performance.now() - startedAt });
+    res.setHeader("content-type", "application/json");
+    res.end(JSON.stringify({
+      success: true,
+      data: [],
+      meta: { credits_used: 0, remaining_credits: 9999 },
+    }));
+    return;
+  }
+  if (url.pathname === "/api/employees/dataset-search") {
+    starts.push({ domain: url.searchParams.get("company_url"), t: performance.now() - startedAt });
+    res.setHeader("content-type", "application/json");
+    res.end(JSON.stringify({
+      success: true,
+      data: [],
+      meta: { page: 1, per_page: 5, total: 0, last_page: 1, credits_used: 0, remaining_credits: 9999 },
+    }));
+    return;
+  }
+  res.statusCode = 404;
+  res.end(JSON.stringify({ error: "not found" }));
+});
+
+await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+const { port } = server.address();
+
+try {
+  process.env.QUICKENRICH_API_KEY = "token-bucket-test-key";
+  process.env.QUICKENRICH_API_BASE_URL = `http://127.0.0.1:${port}`;
+  const client = createClient();
+
+  const burstResult = await callQuickEnrichTool("quickenrich_batch_pull_leads", {
+    companies: [
+      { company_url: "burst-one.example", title: "Founder" },
+      { company_url: "burst-two.example", title: "Founder" },
+      { company_url: "burst-three.example", title: "Founder" },
+      { company_url: "burst-four.example", title: "Founder" },
+    ],
+    pages_per_company: 1,
+    per_page: 5,
+    concurrency: 4,
+    requests_per_minute: 300,
+    response: { mode: "full" },
+  }, client);
+
+  const burstStarts = starts.filter((entry) => entry.domain?.startsWith("burst-"));
+  const burstSpan = Math.max(...burstStarts.map((entry) => entry.t)) - Math.min(...burstStarts.map((entry) => entry.t));
+  assert(burstResult.ok === true, "Burst batch should succeed.");
+  assert(burstResult.requestCount === 4, `Expected 4 burst requests, got ${burstResult.requestCount}.`);
+  assert(burstResult.throttle?.burstSize >= 4, `Default domain-search burst should allow at least 4 starts, got ${burstResult.throttle?.burstSize}.`);
+  assert(burstSpan < 100, `Default compliant burst should start 4 requests within 100ms, got ${burstSpan.toFixed(1)}ms.`);
+
+  await callQuickEnrichTool("quickenrich_batch_pull_leads", {
+    companies: [{ company_url: "strict-one.example", title: "Founder" }],
+    pages_per_company: 1,
+    per_page: 5,
+    concurrency: 1,
+    requests_per_minute: 300,
+    burst_size: 1,
+    response: { mode: "full" },
+  }, client);
+
+  await callQuickEnrichTool("quickenrich_batch_pull_leads", {
+    companies: [{ company_url: "strict-two.example", title: "Founder" }],
+    pages_per_company: 1,
+    per_page: 5,
+    concurrency: 1,
+    requests_per_minute: 300,
+    burst_size: 1,
+    response: { mode: "full" },
+  }, client);
+
+  const strictStarts = starts.filter((entry) => entry.domain?.startsWith("strict-"));
+  assert(strictStarts.length === 2, `Expected 2 strict starts, got ${strictStarts.length}.`);
+  const strictGap = strictStarts[1].t - strictStarts[0].t;
+  assert(strictGap >= 170, `Strict burst_size=1 should be shared across calls and wait >=170ms, got ${strictGap.toFixed(1)}ms.`);
+
+  const reverseResult = await callQuickEnrichTool("quickenrich_batch_reverse_email", {
+    emails: [
+      "burst-email-one@gmail.com",
+      "burst-email-two@gmail.com",
+      "burst-email-three@gmail.com",
+    ],
+    concurrency: 3,
+    requests_per_minute: 1000,
+    response: { mode: "full" },
+  }, client);
+
+  const reverseStarts = starts.filter((entry) => entry.email?.startsWith("burst-email-"));
+  const reverseSpan = Math.max(...reverseStarts.map((entry) => entry.t)) - Math.min(...reverseStarts.map((entry) => entry.t));
+  assert(reverseResult.ok === true, "Reverse-email burst batch should succeed.");
+  assert(reverseResult.throttle?.burstSize >= 3, `Default reverse-email burst should allow at least 3 starts, got ${reverseResult.throttle?.burstSize}.`);
+  assert(reverseSpan < 100, `Default reverse-email burst should start 3 requests within 100ms, got ${reverseSpan.toFixed(1)}ms.`);
+
+  console.log(JSON.stringify({
+    ok: true,
+    burstSpan: Math.round(burstSpan),
+    strictGap: Math.round(strictGap),
+    reverseSpan: Math.round(reverseSpan),
+    burstThrottle: burstResult.throttle,
+    reverseThrottle: reverseResult.throttle,
+  }, null, 2));
+} finally {
+  server.close();
+}