@signaliz/sdk 1.0.30 → 1.0.32

package/README.md

@@ -77,9 +77,12 @@ resumes long-running research through the same `/company-signals` endpoint;
 callers never need an internal Trigger.dev status URL. The SDK follows the
 server's adaptive polling hints by default and still honors `pollIntervalMs`
 when a caller explicitly overrides the cadence.
-All four products are transported in 25-row REST chunks. Exact duplicate tasks
-are single-flighted without changing input order or result cardinality, and
-Signal to Copy also shares company research across copy recipients.
+Exact duplicate tasks are single-flighted across each full batch without
+changing input order or result cardinality. Find Email, Verify Email, and
+Company Signal Enrichment use 25-row REST chunks. Signal to Copy batches larger
+than 25 use one recoverable REST job when they can reuse available signal data;
+fresh or deep-search requests keep the 25-row path. Signal to Copy also shares
+company research across copy recipients.
 
 Company Signal Enrichment defaults `online` and `enableDeepSearch` to `true`
 unless the caller explicitly disables them. Signal to Copy AI returns three

package/dist/{chunk-INM326KO.mjs → chunk-JO4MYKSK.mjs}

@@ -511,9 +511,34 @@ var Signaliz = class {
   async createSignalCopyBatch(requests, options) {
     validateBatchSize(requests);
     const startedAt = Date.now();
+    const deduplicated = dedupeExactBatchItems(requests, (params) => JSON.stringify({
+      request: signalToCopyRequestBody(params),
+      wait_for_result: params.waitForResult,
+      max_wait_ms: params.maxWaitMs,
+      poll_interval_ms: params.pollIntervalMs
+    }));
+    const uniqueRequests = deduplicated.uniqueItems;
+    const canUseRecoverableAvailableDataJob = uniqueRequests.length > 25 && uniqueRequests.every(
+      (params) => params.waitForResult !== false && params.skipCache !== true && params.enableDeepSearch !== true && params.maxWaitMs === void 0 && params.pollIntervalMs === void 0
+    );
+    const uniqueResults = canUseRecoverableAvailableDataJob ? await this.runAvailableSignalCopyBatchJob(uniqueRequests) : await this.runSignalCopyBatchChunks(uniqueRequests, options);
+    const results = requests.map((_, index) => ({
+      ...uniqueResults[deduplicated.sourceIndexByInput[index]],
+      index
+    }));
+    const succeeded = results.filter((item) => item.success).length;
+    return {
+      total: requests.length,
+      succeeded,
+      failed: requests.length - succeeded,
+      durationMs: Date.now() - startedAt,
+      results
+    };
+  }
+  async runSignalCopyBatchChunks(uniqueRequests, options) {
     const chunks = [];
-    for (let offset = 0; offset < requests.length; offset += 25) {
-      chunks.push({ offset, requests: requests.slice(offset, offset + 25) });
+    for (let offset = 0; offset < uniqueRequests.length; offset += 25) {
+      chunks.push({ offset, requests: uniqueRequests.slice(offset, offset + 25) });
     }
     const { serverConcurrency, chunkConcurrency } = batchConcurrencyPlan(options);
     const chunkBatch = await runBatch(
@@ -521,12 +546,12 @@ var Signaliz = class {
       (chunk) => this.runSignalCopyBatchChunk(chunk.requests, serverConcurrency),
       { concurrency: chunkConcurrency }
     );
-    const results = new Array(requests.length);
+    const uniqueResults = new Array(uniqueRequests.length);
     for (const chunkResult of chunkBatch.results) {
       const chunk = chunks[chunkResult.index];
       if (!chunkResult.success || !chunkResult.data) {
         for (let index = 0; index < chunk.requests.length; index += 1) {
-          results[chunk.offset + index] = {
+          uniqueResults[chunk.offset + index] = {
             index: chunk.offset + index,
             success: false,
             error: chunkResult.error || "Signal to Copy batch request failed"
@@ -535,17 +560,58 @@ var Signaliz = class {
         continue;
       }
       for (const item of chunkResult.data) {
-        results[chunk.offset + item.index] = { ...item, index: chunk.offset + item.index };
+        uniqueResults[chunk.offset + item.index] = { ...item, index: chunk.offset + item.index };
       }
     }
-    const succeeded = results.filter((item) => item.success).length;
-    return {
-      total: requests.length,
-      succeeded,
-      failed: requests.length - succeeded,
-      durationMs: Date.now() - startedAt,
-      results
-    };
+    return uniqueResults;
+  }
+  async runAvailableSignalCopyBatchJob(requests) {
+    const startedAt = Date.now();
+    const maxWaitMs = 20 * 6e4;
+    let status = await this.client.post("api/v1/signal-to-copy", {
+      requests: requests.map(signalToCopyRequestBody)
+    });
+    const jobId = String(status.job_id || "").trim();
+    if (!jobId) throw new Error("Signal to Copy batch did not return a recoverable job_id");
+    while (!["completed", "partial", "failed"].includes(String(status.status || "").toLowerCase())) {
+      if (Date.now() - startedAt >= maxWaitMs) {
+        throw new Error(`Signal to Copy batch ${jobId} did not complete within ${maxWaitMs}ms`);
+      }
+      const retryAfterMs = Number(status.next_poll_after_seconds || 2) * 1e3;
+      await sleep2(Math.min(Math.max(250, retryAfterMs), maxWaitMs - (Date.now() - startedAt)));
+      status = await this.client.post("api/v1/signal-to-copy", {
+        job_id: jobId,
+        page: 1,
+        page_size: 500
+      });
+    }
+    const totalPages = Math.max(1, Number(status.total_pages || 1));
+    const pages = [Array.isArray(status.results) ? status.results : []];
+    if (totalPages > 1) {
+      const remainingPages = await Promise.all(Array.from(
+        { length: totalPages - 1 },
+        (_, index) => this.client.post("api/v1/signal-to-copy", {
+          job_id: jobId,
+          page: index + 2,
+          page_size: 500
+        })
+      ));
+      for (const page of remainingPages) pages.push(Array.isArray(page.results) ? page.results : []);
+    }
+    const rows = pages.flat();
+    if (rows.length !== requests.length) {
+      throw new Error(`Signal to Copy batch returned ${rows.length} results for ${requests.length} requests`);
+    }
+    const results = new Array(requests.length);
+    for (const row of rows) {
+      const index = Number(row.index);
+      if (!Number.isInteger(index) || index < 0 || index >= requests.length) {
+        throw new Error("Signal to Copy batch returned an invalid result index");
+      }
+      results[index] = row.success === false ? { index, success: false, error: row.error || row.message || "Signal to Copy failed" } : { index, success: true, data: normalizeSignalToCopyResult(row) };
+    }
+    if (results.some((item) => !item)) throw new Error("Signal to Copy batch returned incomplete indexed results");
+    return results;
   }
   async runSignalCopyBatchChunk(requests, concurrency) {
     const startedAt = Date.now();
@@ -611,9 +677,11 @@ var Signaliz = class {
   }
   async runCoreBatchRound(path, tasks, options) {
     const { serverConcurrency, chunkConcurrency } = batchConcurrencyPlan(options);
+    const deduplicated = dedupeExactBatchItems(tasks, (task) => JSON.stringify(task.request));
+    const uniqueTasks = deduplicated.uniqueItems;
     const chunks = [];
-    for (let offset = 0; offset < tasks.length; offset += 25) {
-      chunks.push({ offset, tasks: tasks.slice(offset, offset + 25) });
+    for (let offset = 0; offset < uniqueTasks.length; offset += 25) {
+      chunks.push({ offset, tasks: uniqueTasks.slice(offset, offset + 25) });
     }
     const chunkBatch = await runBatch(chunks, async (chunk) => {
       const data = await this.client.post(path, {
@@ -628,12 +696,12 @@ var Signaliz = class {
       }
       return data.results;
     }, { concurrency: chunkConcurrency });
-    const results = new Array(tasks.length);
+    const uniqueResults = new Array(uniqueTasks.length);
     for (const chunkResult of chunkBatch.results) {
       const chunk = chunks[chunkResult.index];
       if (!chunkResult.success || !chunkResult.data) {
         for (let index = 0; index < chunk.tasks.length; index += 1) {
-          results[chunk.offset + index] = {
+          uniqueResults[chunk.offset + index] = {
             index: chunk.tasks[index].index,
             success: false,
             error: chunkResult.error || `${path} batch request failed`
@@ -643,7 +711,7 @@ var Signaliz = class {
       }
       for (let index = 0; index < chunkResult.data.length; index += 1) {
         const raw = chunkResult.data[index];
-        results[chunk.offset + index] = {
+        uniqueResults[chunk.offset + index] = {
           index: chunk.tasks[index].index,
           success: raw.success !== false,
           raw,
@@ -651,7 +719,10 @@ var Signaliz = class {
         };
       }
     }
-    return results;
+    return tasks.map((task, index) => ({
+      ...uniqueResults[deduplicated.sourceIndexByInput[index]],
+      index: task.index
+    }));
   }
   async listTools() {
     const result = await this.client.mcp("tools/list");
@@ -808,6 +879,22 @@ function batchConcurrencyPlan(options) {
     chunkConcurrency: Math.max(1, Math.floor(concurrency / serverConcurrency))
   };
 }
+function dedupeExactBatchItems(items, keyForItem) {
+  const uniqueItems = [];
+  const sourceIndexByInput = [];
+  const uniqueIndexByKey = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const key = keyForItem(item);
+    let uniqueIndex = uniqueIndexByKey.get(key);
+    if (uniqueIndex === void 0) {
+      uniqueIndex = uniqueItems.length;
+      uniqueIndexByKey.set(key, uniqueIndex);
+      uniqueItems.push(item);
+    }
+    sourceIndexByInput.push(uniqueIndex);
+  }
+  return { uniqueItems, sourceIndexByInput };
+}
 function finalizeCoreBatch(total, startedAt, round, normalize) {
   const results = new Array(total);
   for (const item of round) {

package/dist/index.d.mts

@@ -203,6 +203,8 @@ declare class Signaliz {
     enrichCompanies(companies: CompanySignalEnrichmentParams[], options?: BatchOptions): Promise<BatchResult<CompanySignalEnrichmentResult>>;
     signalToCopy(params: SignalToCopyParams): Promise<SignalToCopyResult>;
     createSignalCopyBatch(requests: SignalToCopyParams[], options?: BatchOptions): Promise<BatchResult<SignalToCopyResult>>;
+    private runSignalCopyBatchChunks;
+    private runAvailableSignalCopyBatchJob;
     private runSignalCopyBatchChunk;
     private runCoreBatchRound;
     listTools(): Promise<MCPToolInfo[]>;

package/dist/index.d.ts

@@ -203,6 +203,8 @@ declare class Signaliz {
     enrichCompanies(companies: CompanySignalEnrichmentParams[], options?: BatchOptions): Promise<BatchResult<CompanySignalEnrichmentResult>>;
     signalToCopy(params: SignalToCopyParams): Promise<SignalToCopyResult>;
     createSignalCopyBatch(requests: SignalToCopyParams[], options?: BatchOptions): Promise<BatchResult<SignalToCopyResult>>;
+    private runSignalCopyBatchChunks;
+    private runAvailableSignalCopyBatchJob;
     private runSignalCopyBatchChunk;
     private runCoreBatchRound;
     listTools(): Promise<MCPToolInfo[]>;

package/dist/index.js

@@ -538,9 +538,34 @@ var Signaliz = class {
   async createSignalCopyBatch(requests, options) {
     validateBatchSize(requests);
     const startedAt = Date.now();
+    const deduplicated = dedupeExactBatchItems(requests, (params) => JSON.stringify({
+      request: signalToCopyRequestBody(params),
+      wait_for_result: params.waitForResult,
+      max_wait_ms: params.maxWaitMs,
+      poll_interval_ms: params.pollIntervalMs
+    }));
+    const uniqueRequests = deduplicated.uniqueItems;
+    const canUseRecoverableAvailableDataJob = uniqueRequests.length > 25 && uniqueRequests.every(
+      (params) => params.waitForResult !== false && params.skipCache !== true && params.enableDeepSearch !== true && params.maxWaitMs === void 0 && params.pollIntervalMs === void 0
+    );
+    const uniqueResults = canUseRecoverableAvailableDataJob ? await this.runAvailableSignalCopyBatchJob(uniqueRequests) : await this.runSignalCopyBatchChunks(uniqueRequests, options);
+    const results = requests.map((_, index) => ({
+      ...uniqueResults[deduplicated.sourceIndexByInput[index]],
+      index
+    }));
+    const succeeded = results.filter((item) => item.success).length;
+    return {
+      total: requests.length,
+      succeeded,
+      failed: requests.length - succeeded,
+      durationMs: Date.now() - startedAt,
+      results
+    };
+  }
+  async runSignalCopyBatchChunks(uniqueRequests, options) {
     const chunks = [];
-    for (let offset = 0; offset < requests.length; offset += 25) {
-      chunks.push({ offset, requests: requests.slice(offset, offset + 25) });
+    for (let offset = 0; offset < uniqueRequests.length; offset += 25) {
+      chunks.push({ offset, requests: uniqueRequests.slice(offset, offset + 25) });
     }
     const { serverConcurrency, chunkConcurrency } = batchConcurrencyPlan(options);
     const chunkBatch = await runBatch(
@@ -548,12 +573,12 @@ var Signaliz = class {
       (chunk) => this.runSignalCopyBatchChunk(chunk.requests, serverConcurrency),
       { concurrency: chunkConcurrency }
     );
-    const results = new Array(requests.length);
+    const uniqueResults = new Array(uniqueRequests.length);
     for (const chunkResult of chunkBatch.results) {
       const chunk = chunks[chunkResult.index];
       if (!chunkResult.success || !chunkResult.data) {
         for (let index = 0; index < chunk.requests.length; index += 1) {
-          results[chunk.offset + index] = {
+          uniqueResults[chunk.offset + index] = {
             index: chunk.offset + index,
             success: false,
             error: chunkResult.error || "Signal to Copy batch request failed"
@@ -562,17 +587,58 @@ var Signaliz = class {
         continue;
       }
       for (const item of chunkResult.data) {
-        results[chunk.offset + item.index] = { ...item, index: chunk.offset + item.index };
+        uniqueResults[chunk.offset + item.index] = { ...item, index: chunk.offset + item.index };
       }
     }
-    const succeeded = results.filter((item) => item.success).length;
-    return {
-      total: requests.length,
-      succeeded,
-      failed: requests.length - succeeded,
-      durationMs: Date.now() - startedAt,
-      results
-    };
+    return uniqueResults;
+  }
+  async runAvailableSignalCopyBatchJob(requests) {
+    const startedAt = Date.now();
+    const maxWaitMs = 20 * 6e4;
+    let status = await this.client.post("api/v1/signal-to-copy", {
+      requests: requests.map(signalToCopyRequestBody)
+    });
+    const jobId = String(status.job_id || "").trim();
+    if (!jobId) throw new Error("Signal to Copy batch did not return a recoverable job_id");
+    while (!["completed", "partial", "failed"].includes(String(status.status || "").toLowerCase())) {
+      if (Date.now() - startedAt >= maxWaitMs) {
+        throw new Error(`Signal to Copy batch ${jobId} did not complete within ${maxWaitMs}ms`);
+      }
+      const retryAfterMs = Number(status.next_poll_after_seconds || 2) * 1e3;
+      await sleep2(Math.min(Math.max(250, retryAfterMs), maxWaitMs - (Date.now() - startedAt)));
+      status = await this.client.post("api/v1/signal-to-copy", {
+        job_id: jobId,
+        page: 1,
+        page_size: 500
+      });
+    }
+    const totalPages = Math.max(1, Number(status.total_pages || 1));
+    const pages = [Array.isArray(status.results) ? status.results : []];
+    if (totalPages > 1) {
+      const remainingPages = await Promise.all(Array.from(
+        { length: totalPages - 1 },
+        (_, index) => this.client.post("api/v1/signal-to-copy", {
+          job_id: jobId,
+          page: index + 2,
+          page_size: 500
+        })
+      ));
+      for (const page of remainingPages) pages.push(Array.isArray(page.results) ? page.results : []);
+    }
+    const rows = pages.flat();
+    if (rows.length !== requests.length) {
+      throw new Error(`Signal to Copy batch returned ${rows.length} results for ${requests.length} requests`);
+    }
+    const results = new Array(requests.length);
+    for (const row of rows) {
+      const index = Number(row.index);
+      if (!Number.isInteger(index) || index < 0 || index >= requests.length) {
+        throw new Error("Signal to Copy batch returned an invalid result index");
+      }
+      results[index] = row.success === false ? { index, success: false, error: row.error || row.message || "Signal to Copy failed" } : { index, success: true, data: normalizeSignalToCopyResult(row) };
+    }
+    if (results.some((item) => !item)) throw new Error("Signal to Copy batch returned incomplete indexed results");
+    return results;
   }
   async runSignalCopyBatchChunk(requests, concurrency) {
     const startedAt = Date.now();
@@ -638,9 +704,11 @@ var Signaliz = class {
   }
   async runCoreBatchRound(path, tasks, options) {
     const { serverConcurrency, chunkConcurrency } = batchConcurrencyPlan(options);
+    const deduplicated = dedupeExactBatchItems(tasks, (task) => JSON.stringify(task.request));
+    const uniqueTasks = deduplicated.uniqueItems;
     const chunks = [];
-    for (let offset = 0; offset < tasks.length; offset += 25) {
-      chunks.push({ offset, tasks: tasks.slice(offset, offset + 25) });
+    for (let offset = 0; offset < uniqueTasks.length; offset += 25) {
+      chunks.push({ offset, tasks: uniqueTasks.slice(offset, offset + 25) });
     }
     const chunkBatch = await runBatch(chunks, async (chunk) => {
       const data = await this.client.post(path, {
@@ -655,12 +723,12 @@ var Signaliz = class {
       }
       return data.results;
     }, { concurrency: chunkConcurrency });
-    const results = new Array(tasks.length);
+    const uniqueResults = new Array(uniqueTasks.length);
     for (const chunkResult of chunkBatch.results) {
       const chunk = chunks[chunkResult.index];
       if (!chunkResult.success || !chunkResult.data) {
         for (let index = 0; index < chunk.tasks.length; index += 1) {
-          results[chunk.offset + index] = {
+          uniqueResults[chunk.offset + index] = {
             index: chunk.tasks[index].index,
             success: false,
             error: chunkResult.error || `${path} batch request failed`
@@ -670,7 +738,7 @@ var Signaliz = class {
       }
       for (let index = 0; index < chunkResult.data.length; index += 1) {
         const raw = chunkResult.data[index];
-        results[chunk.offset + index] = {
+        uniqueResults[chunk.offset + index] = {
           index: chunk.tasks[index].index,
           success: raw.success !== false,
           raw,
@@ -678,7 +746,10 @@ var Signaliz = class {
         };
       }
     }
-    return results;
+    return tasks.map((task, index) => ({
+      ...uniqueResults[deduplicated.sourceIndexByInput[index]],
+      index: task.index
+    }));
   }
   async listTools() {
     const result = await this.client.mcp("tools/list");
@@ -835,6 +906,22 @@ function batchConcurrencyPlan(options) {
     chunkConcurrency: Math.max(1, Math.floor(concurrency / serverConcurrency))
   };
 }
+function dedupeExactBatchItems(items, keyForItem) {
+  const uniqueItems = [];
+  const sourceIndexByInput = [];
+  const uniqueIndexByKey = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const key = keyForItem(item);
+    let uniqueIndex = uniqueIndexByKey.get(key);
+    if (uniqueIndex === void 0) {
+      uniqueIndex = uniqueItems.length;
+      uniqueIndexByKey.set(key, uniqueIndex);
+      uniqueItems.push(item);
+    }
+    sourceIndexByInput.push(uniqueIndex);
+  }
+  return { uniqueItems, sourceIndexByInput };
+}
 function finalizeCoreBatch(total, startedAt, round, normalize) {
   const results = new Array(total);
   for (const item of round) {

package/dist/index.mjs

@@ -1,7 +1,7 @@
 import {
   Signaliz,
   SignalizError
-} from "./chunk-INM326KO.mjs";
+} from "./chunk-JO4MYKSK.mjs";
 export {
   Signaliz,
   SignalizError

package/dist/mcp-config.js

@@ -542,9 +542,34 @@ var Signaliz = class {
   async createSignalCopyBatch(requests, options) {
     validateBatchSize(requests);
     const startedAt = Date.now();
+    const deduplicated = dedupeExactBatchItems(requests, (params) => JSON.stringify({
+      request: signalToCopyRequestBody(params),
+      wait_for_result: params.waitForResult,
+      max_wait_ms: params.maxWaitMs,
+      poll_interval_ms: params.pollIntervalMs
+    }));
+    const uniqueRequests = deduplicated.uniqueItems;
+    const canUseRecoverableAvailableDataJob = uniqueRequests.length > 25 && uniqueRequests.every(
+      (params) => params.waitForResult !== false && params.skipCache !== true && params.enableDeepSearch !== true && params.maxWaitMs === void 0 && params.pollIntervalMs === void 0
+    );
+    const uniqueResults = canUseRecoverableAvailableDataJob ? await this.runAvailableSignalCopyBatchJob(uniqueRequests) : await this.runSignalCopyBatchChunks(uniqueRequests, options);
+    const results = requests.map((_, index) => ({
+      ...uniqueResults[deduplicated.sourceIndexByInput[index]],
+      index
+    }));
+    const succeeded = results.filter((item) => item.success).length;
+    return {
+      total: requests.length,
+      succeeded,
+      failed: requests.length - succeeded,
+      durationMs: Date.now() - startedAt,
+      results
+    };
+  }
+  async runSignalCopyBatchChunks(uniqueRequests, options) {
     const chunks = [];
-    for (let offset = 0; offset < requests.length; offset += 25) {
-      chunks.push({ offset, requests: requests.slice(offset, offset + 25) });
+    for (let offset = 0; offset < uniqueRequests.length; offset += 25) {
+      chunks.push({ offset, requests: uniqueRequests.slice(offset, offset + 25) });
     }
     const { serverConcurrency, chunkConcurrency } = batchConcurrencyPlan(options);
     const chunkBatch = await runBatch(
@@ -552,12 +577,12 @@ var Signaliz = class {
       (chunk) => this.runSignalCopyBatchChunk(chunk.requests, serverConcurrency),
       { concurrency: chunkConcurrency }
     );
-    const results = new Array(requests.length);
+    const uniqueResults = new Array(uniqueRequests.length);
     for (const chunkResult of chunkBatch.results) {
       const chunk = chunks[chunkResult.index];
       if (!chunkResult.success || !chunkResult.data) {
         for (let index = 0; index < chunk.requests.length; index += 1) {
-          results[chunk.offset + index] = {
+          uniqueResults[chunk.offset + index] = {
             index: chunk.offset + index,
             success: false,
             error: chunkResult.error || "Signal to Copy batch request failed"
@@ -566,17 +591,58 @@ var Signaliz = class {
         continue;
       }
       for (const item of chunkResult.data) {
-        results[chunk.offset + item.index] = { ...item, index: chunk.offset + item.index };
+        uniqueResults[chunk.offset + item.index] = { ...item, index: chunk.offset + item.index };
       }
     }
-    const succeeded = results.filter((item) => item.success).length;
-    return {
-      total: requests.length,
-      succeeded,
-      failed: requests.length - succeeded,
-      durationMs: Date.now() - startedAt,
-      results
-    };
+    return uniqueResults;
+  }
+  async runAvailableSignalCopyBatchJob(requests) {
+    const startedAt = Date.now();
+    const maxWaitMs = 20 * 6e4;
+    let status = await this.client.post("api/v1/signal-to-copy", {
+      requests: requests.map(signalToCopyRequestBody)
+    });
+    const jobId = String(status.job_id || "").trim();
+    if (!jobId) throw new Error("Signal to Copy batch did not return a recoverable job_id");
+    while (!["completed", "partial", "failed"].includes(String(status.status || "").toLowerCase())) {
+      if (Date.now() - startedAt >= maxWaitMs) {
+        throw new Error(`Signal to Copy batch ${jobId} did not complete within ${maxWaitMs}ms`);
+      }
+      const retryAfterMs = Number(status.next_poll_after_seconds || 2) * 1e3;
+      await sleep2(Math.min(Math.max(250, retryAfterMs), maxWaitMs - (Date.now() - startedAt)));
+      status = await this.client.post("api/v1/signal-to-copy", {
+        job_id: jobId,
+        page: 1,
+        page_size: 500
+      });
+    }
+    const totalPages = Math.max(1, Number(status.total_pages || 1));
+    const pages = [Array.isArray(status.results) ? status.results : []];
+    if (totalPages > 1) {
+      const remainingPages = await Promise.all(Array.from(
+        { length: totalPages - 1 },
+        (_, index) => this.client.post("api/v1/signal-to-copy", {
+          job_id: jobId,
+          page: index + 2,
+          page_size: 500
+        })
+      ));
+      for (const page of remainingPages) pages.push(Array.isArray(page.results) ? page.results : []);
+    }
+    const rows = pages.flat();
+    if (rows.length !== requests.length) {
+      throw new Error(`Signal to Copy batch returned ${rows.length} results for ${requests.length} requests`);
+    }
+    const results = new Array(requests.length);
+    for (const row of rows) {
+      const index = Number(row.index);
+      if (!Number.isInteger(index) || index < 0 || index >= requests.length) {
+        throw new Error("Signal to Copy batch returned an invalid result index");
+      }
+      results[index] = row.success === false ? { index, success: false, error: row.error || row.message || "Signal to Copy failed" } : { index, success: true, data: normalizeSignalToCopyResult(row) };
+    }
+    if (results.some((item) => !item)) throw new Error("Signal to Copy batch returned incomplete indexed results");
+    return results;
   }
   async runSignalCopyBatchChunk(requests, concurrency) {
     const startedAt = Date.now();
@@ -642,9 +708,11 @@ var Signaliz = class {
   }
   async runCoreBatchRound(path2, tasks, options) {
     const { serverConcurrency, chunkConcurrency } = batchConcurrencyPlan(options);
+    const deduplicated = dedupeExactBatchItems(tasks, (task) => JSON.stringify(task.request));
+    const uniqueTasks = deduplicated.uniqueItems;
     const chunks = [];
-    for (let offset = 0; offset < tasks.length; offset += 25) {
-      chunks.push({ offset, tasks: tasks.slice(offset, offset + 25) });
+    for (let offset = 0; offset < uniqueTasks.length; offset += 25) {
+      chunks.push({ offset, tasks: uniqueTasks.slice(offset, offset + 25) });
     }
     const chunkBatch = await runBatch(chunks, async (chunk) => {
       const data = await this.client.post(path2, {
@@ -659,12 +727,12 @@ var Signaliz = class {
       }
       return data.results;
     }, { concurrency: chunkConcurrency });
-    const results = new Array(tasks.length);
+    const uniqueResults = new Array(uniqueTasks.length);
     for (const chunkResult of chunkBatch.results) {
       const chunk = chunks[chunkResult.index];
       if (!chunkResult.success || !chunkResult.data) {
         for (let index = 0; index < chunk.tasks.length; index += 1) {
-          results[chunk.offset + index] = {
+          uniqueResults[chunk.offset + index] = {
             index: chunk.tasks[index].index,
             success: false,
             error: chunkResult.error || `${path2} batch request failed`
@@ -674,7 +742,7 @@ var Signaliz = class {
       }
       for (let index = 0; index < chunkResult.data.length; index += 1) {
         const raw = chunkResult.data[index];
-        results[chunk.offset + index] = {
+        uniqueResults[chunk.offset + index] = {
           index: chunk.tasks[index].index,
           success: raw.success !== false,
           raw,
@@ -682,7 +750,10 @@ var Signaliz = class {
         };
       }
     }
-    return results;
+    return tasks.map((task, index) => ({
+      ...uniqueResults[deduplicated.sourceIndexByInput[index]],
+      index: task.index
+    }));
   }
   async listTools() {
     const result = await this.client.mcp("tools/list");
@@ -839,6 +910,22 @@ function batchConcurrencyPlan(options) {
     chunkConcurrency: Math.max(1, Math.floor(concurrency / serverConcurrency))
   };
 }
+function dedupeExactBatchItems(items, keyForItem) {
+  const uniqueItems = [];
+  const sourceIndexByInput = [];
+  const uniqueIndexByKey = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const key = keyForItem(item);
+    let uniqueIndex = uniqueIndexByKey.get(key);
+    if (uniqueIndex === void 0) {
+      uniqueIndex = uniqueItems.length;
+      uniqueIndexByKey.set(key, uniqueIndex);
+      uniqueItems.push(item);
+    }
+    sourceIndexByInput.push(uniqueIndex);
+  }
+  return { uniqueItems, sourceIndexByInput };
+}
 function finalizeCoreBatch(total, startedAt, round, normalize) {
   const results = new Array(total);
   for (const item of round) {

package/dist/mcp-config.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   Signaliz
-} from "./chunk-INM326KO.mjs";
+} from "./chunk-JO4MYKSK.mjs";
 
 // src/mcp-config.ts
 import * as fs from "fs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signaliz/sdk",
-  "version": "1.0.30",
+  "version": "1.0.32",
   "description": "Signaliz SDK for Find Email, Verify Email, Company Signal Enrichment, and Signal to Copy AI.",
   "main": "dist/index.js",
   "module": "dist/index.mjs",