deepline 0.1.175 → 0.1.176

package/dist/cli/index.js

@@ -622,10 +622,10 @@ var SDK_RELEASE = {
   // 0.1.111 ships dataset-native tool list getters and result row datasets.
   // 0.1.154 removes the short-lived generated enrich StepOptions recompute
   // fields shipped in 0.1.153.
-  version: "0.1.175",
+  version: "0.1.176",
   apiContract: "2026-06-dataset-handle-results-hard-cutover",
   supportPolicy: {
-    latest: "0.1.175",
+    latest: "0.1.176",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53",
     commandMinimumSupported: [
@@ -886,9 +886,10 @@ var HttpClient = class {
       headers["Content-Type"] = "application/json";
     }
     let lastError = null;
-    const candidateUrls = buildCandidateUrls(url);
+    const candidateUrls = options?.exactUrlOnly ? [url] : buildCandidateUrls(url);
     let retryAfterDelayMs = null;
-    for (let attempt = 0; attempt <= this.config.maxRetries; attempt++) {
+    const maxRetries = options?.maxRetries ?? this.config.maxRetries;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
       if (attempt > 0) {
         const backoffMs = Math.min(1e3 * Math.pow(2, attempt - 1), 3e4);
         const delayMs = retryAfterDelayMs === null ? backoffMs : Math.max(backoffMs, retryAfterDelayMs);
@@ -915,7 +916,7 @@ var HttpClient = class {
           if (response.status === 429) {
             const retryAfter = parseRetryAfter(response);
             lastError = new RateLimitError(retryAfter);
-            if (attempt < this.config.maxRetries) {
+            if (attempt < maxRetries) {
               retryAfterDelayMs = retryAfter;
               break;
             }
@@ -945,7 +946,7 @@ var HttpClient = class {
                   ...htmlError.workerThrewException ? { workerThrewException: true } : {}
                 }
               );
-              if (retryableApiError && attempt < this.config.maxRetries) {
+              if (retryableApiError && attempt < maxRetries) {
                 retryAfterDelayMs = parseOptionalRetryAfter(response);
                 break;
               }
@@ -957,7 +958,7 @@ var HttpClient = class {
             lastError = new DeeplineError(msg, response.status, apiErrorCode, {
               response: parsed
             });
-            if (retryableApiError && attempt < this.config.maxRetries) {
+            if (retryableApiError && attempt < maxRetries) {
               retryAfterDelayMs = parseOptionalRetryAfter(response);
               break;
             }
@@ -976,7 +977,7 @@ var HttpClient = class {
           lastError = error instanceof Error ? error : new Error(String(error));
         }
       }
-      if (attempt < this.config.maxRetries) continue;
+      if (attempt < maxRetries) continue;
     }
     if (lastError instanceof DeeplineError) {
       throw lastError;
@@ -2111,6 +2112,7 @@ var COMPILE_MANIFEST_RETRY_DELAYS_MS = [250, 1e3];
 var REGISTER_PLAY_ARTIFACTS_COMPILE_CONCURRENCY = 3;
 var REGISTER_PLAY_ARTIFACTS_MAX_BATCH_COUNT = 3;
 var REGISTER_PLAY_ARTIFACTS_MAX_BATCH_BYTES = 25e5;
+var DEEPLINEAGENT_EXECUTE_TIMEOUT_MS = 15 * 60 * 1e3;
 function normalizePlayRunIntegrationMode(value) {
   if (value === "live" || value === "eval_stub" || value === "fixture") {
     return value;
@@ -2185,6 +2187,10 @@ function chunkRegisterPlayArtifacts(artifacts) {
   }
   return chunks;
 }
+function resolveToolExecuteTimeoutMs(toolId) {
+  const normalized = toolId.trim().toLowerCase();
+  return normalized === "deeplineagent" || normalized === "deeplineagent_deeplineagent" || normalized === "ai_inference" || normalized === "deeplineagent_ai_inference" || normalized === "aiinference" ? DEEPLINEAGENT_EXECUTE_TIMEOUT_MS : void 0;
+}
 var RUN_LOGS_PAGE_LIMIT = 1e3;
 function isRecord3(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
@@ -2624,7 +2630,12 @@ var DeeplineClient = class {
       `/api/v2/integrations/${encodeURIComponent(toolId)}/execute`,
       { payload: input2 },
       headers,
-      { forbiddenAsApiError: true }
+      {
+        forbiddenAsApiError: true,
+        timeout: options?.timeout ?? resolveToolExecuteTimeoutMs(toolId),
+        maxRetries: options?.maxRetries ?? 0,
+        exactUrlOnly: true
+      }
     );
   }
   /**
@@ -4572,10 +4583,21 @@ function failureMessageFromRecord(value) {
   }
   return directError || resultError || `Column status: ${status}`;
 }
-function flattenObjectColumns(row) {
+function shouldPreserveJsonStringColumn(columns, key) {
+  if (!columns) {
+    return false;
+  }
+  if (columns.has(key)) {
+    return true;
+  }
+  const normalizedKey = key.toLowerCase().replace(/[^a-z0-9]/g, "");
+  return normalizedKey ? columns.has(normalizedKey) : false;
+}
+function flattenObjectColumns(row, options = {}) {
   const flattened = {};
   for (const [key, rawValue] of Object.entries(row)) {
     const value = parseMaybeJsonObject(rawValue);
+    const parsedFromString = typeof rawValue === "string" && value !== rawValue;
     if (key === "_metadata") {
       flattened[key] = value && typeof value === "object" ? JSON.stringify(value) : value;
       continue;
@@ -4586,6 +4608,10 @@ function flattenObjectColumns(row) {
       if (hasMatchedEnvelope) {
         flattened[key] = JSON.stringify(record);
         continue;
+      }
+      if (parsedFromString && shouldPreserveJsonStringColumn(options.preserveJsonStringColumns, key)) {
+        flattened[key] = rawValue;
+        continue;
       } else {
         const failureMessage = failureMessageFromRecord(record);
         if (failureMessage) {
@@ -4610,8 +4636,8 @@ function recordRows(value) {
     (row) => Boolean(row) && typeof row === "object" && !Array.isArray(row)
   );
 }
-function dataExportRows(rows) {
-  return rows.map((row) => flattenObjectColumns(row));
+function dataExportRows(rows, options = {}) {
+  return rows.map((row) => flattenObjectColumns(row, options));
 }
 function dataExportColumns(rows, preferredColumns = []) {
   const discoveredColumns = [
@@ -16883,7 +16909,8 @@ function helperSource() {
 // src/cli/commands/enrich.ts
 var ENRICH_EXPORT_PAGE_SIZE = 5e3;
 var ENRICH_AUTO_BATCH_ROWS = 250;
-var ENRICH_HEAVY_PLAY_AUTO_BATCH_ROWS = 40;
+var ENRICH_HEAVY_PLAY_AUTO_BATCH_ROWS = 25;
+var ENRICH_NESTED_PROVIDER_AUTO_BATCH_ROWS = 50;
 var ENRICH_EXPORT_BACKING_ROWS_WAIT_MS = 6e4;
 var ENRICH_EXPORT_BACKING_ROWS_POLL_MS = 1e3;
 var ENRICH_SOURCE_ROW_INDEX_COLUMN = "__deeplineSourceRowIndex";
@@ -16898,6 +16925,12 @@ var HEAVY_ENRICH_AUTO_BATCH_PLAYS = /* @__PURE__ */ new Set([
   "company-to-contact-by-role-waterfall",
   "company_to_contact_by_role_waterfall"
 ]);
+var HEAVY_ENRICH_AUTO_BATCH_TOOLS = /* @__PURE__ */ new Set([
+  "ai_inference",
+  "aiinference",
+  "deeplineagent"
+]);
+var ENRICH_TEST_AI_INFERENCE_PAYLOAD_MARKER = "__deeplineTestAiInference";
 var PLAN_SHAPING_OPTION_NAMES = [
   "with",
   "withWaterfall",
@@ -16915,6 +16948,15 @@ function normalizeAlias2(value) {
 function hasPlanShapingArgs(args) {
   return optionWasProvided(args, "--with") || optionWasProvided(args, "--with-waterfall") || optionWasProvided(args, "--min-results") || optionWasProvided(args, "--end-waterfall");
 }
+function isMarkedTestAiInferenceCommand(command) {
+  if ("with_waterfall" in command) {
+    return false;
+  }
+  if (normalizeEnrichPlayRef(command.tool) !== "run_javascript") {
+    return false;
+  }
+  return isRecord7(command.payload) && command.payload[ENRICH_TEST_AI_INFERENCE_PAYLOAD_MARKER] === true;
+}
 function enrichDebugEnabled(env = process.env) {
   const raw = String(env.DEEPLINE_DEBUG_ENRICH ?? "").trim().toLowerCase();
   if (["1", "true", "yes", "on"].includes(raw)) {
@@ -17682,8 +17724,6 @@ function normalizeEnrichPlayRef(value) {
   return normalized || null;
 }
 function configContainsHeavyEnrichPlay(config) {
-  let hasNestedPlayStep = false;
-  let hasSubrequestProviderStep = false;
   const visit = (commands) => {
     for (const command of commands) {
       if ("with_waterfall" in command) {
@@ -17707,18 +17747,67 @@ function configContainsHeavyEnrichPlay(config) {
         return true;
       }
       const normalizedTool = normalizeEnrichPlayRef(command.tool);
+      const normalizedOperation = normalizeEnrichPlayRef(command.operation);
+      if (isMarkedTestAiInferenceCommand(command) || normalizedTool && HEAVY_ENRICH_AUTO_BATCH_TOOLS.has(normalizedTool) || normalizedOperation && HEAVY_ENRICH_AUTO_BATCH_TOOLS.has(normalizedOperation)) {
+        return true;
+      }
+    }
+    return false;
+  };
+  return visit(config.commands);
+}
+function configContainsNestedProviderEnrichWorkload(config) {
+  let hasNestedPlayStep = false;
+  let hasSubrequestProviderStep = false;
+  const visit = (commands) => {
+    for (const command of commands) {
+      if ("with_waterfall" in command) {
+        visit(command.commands);
+        continue;
+      }
+      if (command.disabled) {
+        continue;
+      }
+      const normalizedTool = normalizeEnrichPlayRef(command.tool);
       if (command.play || normalizedTool === "test-play") {
         hasNestedPlayStep = true;
       } else if (normalizedTool !== null && normalizedTool !== "run_javascript") {
         hasSubrequestProviderStep = true;
       }
     }
-    return false;
   };
-  return visit(config.commands) || hasNestedPlayStep && hasSubrequestProviderStep;
+  visit(config.commands);
+  return hasNestedPlayStep && hasSubrequestProviderStep;
 }
 function enrichAutoBatchRowsForConfig(config) {
-  return configContainsHeavyEnrichPlay(config) ? ENRICH_HEAVY_PLAY_AUTO_BATCH_ROWS : ENRICH_AUTO_BATCH_ROWS;
+  if (configContainsHeavyEnrichPlay(config)) {
+    return ENRICH_HEAVY_PLAY_AUTO_BATCH_ROWS;
+  }
+  if (configContainsNestedProviderEnrichWorkload(config)) {
+    return ENRICH_NESTED_PROVIDER_AUTO_BATCH_ROWS;
+  }
+  return ENRICH_AUTO_BATCH_ROWS;
+}
+function enrichAiRuntimeCompactAliases(config) {
+  const aliases = /* @__PURE__ */ new Set();
+  const visit = (commands) => {
+    for (const command of commands) {
+      if ("with_waterfall" in command) {
+        visit(command.commands);
+        continue;
+      }
+      if (command.disabled) {
+        continue;
+      }
+      const normalizedTool = normalizeEnrichPlayRef(command.tool);
+      const normalizedOperation = normalizeEnrichPlayRef(command.operation);
+      if (isMarkedTestAiInferenceCommand(command) || normalizedTool && HEAVY_ENRICH_AUTO_BATCH_TOOLS.has(normalizedTool) || normalizedOperation && HEAVY_ENRICH_AUTO_BATCH_TOOLS.has(normalizedOperation)) {
+        aliases.add(normalizeAlias2(command.alias));
+      }
+    }
+  };
+  visit(config.commands);
+  return aliases;
 }
 async function maybeWriteOutputCsv(input2) {
   if (!input2.outputPath) return null;
@@ -17814,6 +17903,52 @@ function selectedSourceCsvRange(sourceCsvPath, rows) {
     sourceRows
   };
 }
+function compactRuntimeCsvCell(value) {
+  const parsed = parseMaybeJsonObject(value);
+  const compacted = compactAiInferenceCellForCsv(parsed);
+  return materializeCsvCellValue(compacted);
+}
+async function writeSlimBatchedRuntimeCsv(input2) {
+  const cleanRows = readCsvRows(input2.cleanSourceCsvPath).map(
+    (row) => ({ ...row })
+  );
+  const mergeRows = readCsvRows(input2.mergeSourceCsvPath);
+  const preserveJsonStringColumns = /* @__PURE__ */ new Set([
+    ...cleanRows.flatMap((row) => Object.keys(row)),
+    ...mergeRows.flatMap((row) => Object.keys(row))
+  ]);
+  const selectedRange = selectedSourceCsvRange(
+    input2.mergeSourceCsvPath,
+    input2.rows
+  );
+  for (let rowIndex = selectedRange.start; rowIndex <= selectedRange.end; rowIndex += 1) {
+    const mergeRow = mergeRows[rowIndex];
+    if (!mergeRow) {
+      continue;
+    }
+    const baseRow = cleanRows[rowIndex] ?? {};
+    const compactOverlayCell = ([key, value]) => {
+      return [
+        key,
+        input2.compactAliases.has(normalizeAlias2(key)) ? compactRuntimeCsvCell(value) : value
+      ];
+    };
+    cleanRows[rowIndex] = {
+      ...baseRow,
+      ...Object.fromEntries(
+        Object.entries(mergeRow).map(compactOverlayCell)
+      )
+    };
+  }
+  const columns = dataExportColumns(
+    dataExportRows(cleanRows, { preserveJsonStringColumns })
+  );
+  await (0, import_promises3.writeFile)(
+    input2.outputPath,
+    csvStringFromRows(cleanRows, columns),
+    "utf8"
+  );
+}
 function selectedSourceCsvRowCount(options) {
   if (!options?.sourceCsvPath) {
     return null;
@@ -18120,6 +18255,22 @@ function mergeExportedSheetRow(target, next) {
     target._metadata = metadata;
   }
 }
+function countEnrichedRowsInSourceRange(exportResult, rows) {
+  const start = Math.max(0, rows.rowStart ?? 0);
+  const end = rows.rowEnd === null || rows.rowEnd === void 0 ? Number.MAX_SAFE_INTEGER : Math.max(start, rows.rowEnd);
+  const rowIndexes = /* @__PURE__ */ new Set();
+  for (const row of exportResult.enrichedDataRows) {
+    const rowIndex = sourceRowIndexFromEnrichRow(row, start, end);
+    if (rowIndex !== null) {
+      rowIndexes.add(rowIndex);
+    }
+  }
+  if (rowIndexes.size > 0) {
+    return rowIndexes.size;
+  }
+  const selectedRows = end === Number.MAX_SAFE_INTEGER ? exportResult.enrichedRows : end - start + 1;
+  return Math.min(exportResult.enrichedRows, Math.max(0, selectedRows));
+}
 function coalesceExportableSheetRows(rows, sourceRowStart = 0) {
   const mergedRows = [];
   const bySourceRowIndex = /* @__PURE__ */ new Map();
@@ -18751,10 +18902,12 @@ async function fetchBackingRowsForCsvExport(input2) {
   };
 }
 function mergeRowsForCsvExport(enrichedRows, options) {
+  const compactAliases = options?.config ? enrichAiRuntimeCompactAliases(options.config) : /* @__PURE__ */ new Set();
   const rows = dataExportRows(
     normalizeEnrichRowsForCsvExport(enrichedRows, options?.config, {
       statusFailureMessages: options?.statusFailureMessages
-    })
+    }),
+    { preserveJsonStringColumns: compactAliases }
   );
   const range = options?.rows;
   if (!options?.sourceCsvPath) {
@@ -18774,16 +18927,16 @@ function mergeRowsForCsvExport(enrichedRows, options) {
   const maxEnd = Math.max(start, baseRows.length - 1);
   const inclusiveEnd = range?.rowEnd === null || range?.rowEnd === void 0 ? maxEnd : Math.min(maxEnd, range.rowEnd);
   const expectedSelectedRows = baseRows.length === 0 ? 0 : Math.max(0, inclusiveEnd - start + 1);
-  const canMergeSparseBySourceIndex = rows.length > 0 && rows.every(
+  const hasRowsInSelectedRange = rows.some(
     (row) => sourceRowIndexFromEnrichRow(row, start, inclusiveEnd) !== null
   );
-  if (options.inPlace && rows.length < expectedSelectedRows && !options.allowPartial && !canMergeSparseBySourceIndex) {
+  if (options.inPlace && rows.length < expectedSelectedRows && !options.allowPartial && !hasRowsInSelectedRange) {
     throw new Error(
       `Refusing to write a partial in-place CSV export: the run returned ${rows.length} row(s) for ${expectedSelectedRows} selected source row(s).`
     );
   }
   const merged = [...baseRows];
-  if (canMergeSparseBySourceIndex) {
+  if (hasRowsInSelectedRange) {
     for (const rawEnriched of rows) {
       const rowIndex = sourceRowIndexFromEnrichRow(
         rawEnriched,
@@ -18918,9 +19071,45 @@ function materializeCsvCellValue(value) {
   }
   return value;
 }
-function materializeAliasSuccessCell(row, alias) {
+function disambiguateCompactAiInferencePayload(value) {
+  const parsed = parseMaybeJsonObject(value);
+  if (!isRecord7(parsed) || !cellFailureError(parsed)) {
+    return value;
+  }
+  return {
+    status: "completed",
+    extracted_json: parsed
+  };
+}
+function compactAiInferenceCellForCsv(value) {
+  if (!isRecord7(value)) {
+    return value;
+  }
+  const extractedJson = value.extracted_json;
+  if (extractedJson !== null && extractedJson !== void 0) {
+    return disambiguateCompactAiInferencePayload(extractedJson);
+  }
+  const result = isRecord7(value.result) ? value.result : null;
+  const object = result?.object;
+  if (object !== null && object !== void 0) {
+    return disambiguateCompactAiInferencePayload(object);
+  }
+  const text = result?.text;
+  if (typeof text === "string" && text.trim()) {
+    return disambiguateCompactAiInferencePayload(text);
+  }
+  const output2 = value.output;
+  if (typeof output2 === "string" && output2.trim()) {
+    return disambiguateCompactAiInferencePayload(output2);
+  }
+  return value;
+}
+function materializeEnrichAliasCellForCsv(row, alias, options) {
   const direct = row[alias];
   if (isRecord7(direct)) {
+    if (options?.compactAiCell && direct.status === "completed" && (isRecord7(direct.result) || Object.prototype.hasOwnProperty.call(direct, "extracted_json") || typeof direct.output === "string")) {
+      return materializeCsvCellValue(compactAiInferenceCellForCsv(direct));
+    }
     if (Object.prototype.hasOwnProperty.call(direct, "matched_result") || Object.prototype.hasOwnProperty.call(direct, "matchedResult") || Object.prototype.hasOwnProperty.call(direct, "result")) {
       return materializeCsvCellValue(direct);
     }
@@ -18979,6 +19168,7 @@ function materializeAliasSuccessCell(row, alias) {
 }
 function normalizeEnrichRowsForCsvExport(rows, config, options) {
   const aliases = config ? collectConfigScalarAliasOrder(config) : [];
+  const aiCompactAliases = config ? enrichAiRuntimeCompactAliases(config) : null;
   const failureOperationByAlias = hardFailureOperationByAlias(config);
   return rows.map((row) => {
     const metadata = legacyMetadataFromRow(row);
@@ -19021,7 +19211,9 @@ function normalizeEnrichRowsForCsvExport(rows, config, options) {
       }
     }
     for (const alias of aliases) {
-      const value = materializeAliasSuccessCell(normalized, alias);
+      const value = materializeEnrichAliasCellForCsv(normalized, alias, {
+        compactAiCell: aiCompactAliases?.has(normalizeAlias2(alias)) ?? false
+      });
       if (value !== void 0) {
         normalized[alias] = value;
         continue;
@@ -19346,7 +19538,7 @@ function registerEnrichCommand(program) {
           capturedResult: captured2.result,
           client: client2,
           config,
-          sourceCsvPath: input2.sourceCsvPath,
+          sourceCsvPath: input2.mergeSourceCsvPath ?? input2.sourceCsvPath,
           rows: input2.rows,
           inPlace: Boolean(options.inPlace)
         });
@@ -19362,11 +19554,12 @@ function registerEnrichCommand(program) {
 `
           );
         }
-        let workingSourceCsvPath = sourceCsvPath;
+        let workingMergeSourceCsvPath = sourceCsvPath;
         let lastStatus = null;
         let finalExportResult = null;
         let totalEnrichedRows = 0;
         const batchFailureRows = [];
+        const runtimeCompactAliases = enrichAiRuntimeCompactAliases(config);
         for (let chunkStart = selectedRange.start, chunkIndex = 0; chunkStart <= selectedRange.end; chunkStart += autoBatchRows, chunkIndex += 1) {
           const chunkRows = {
             rowStart: chunkStart,
@@ -19381,8 +19574,19 @@ function registerEnrichCommand(program) {
 `
             );
           }
+          const runtimeSourceCsvPath = options.inPlace ? sourceCsvPath : workingMergeSourceCsvPath === inputCsv ? inputCsv : (0, import_node_path12.join)(tempDir, `runtime-batch-${chunkIndex}.csv`);
+          if (!options.inPlace && runtimeSourceCsvPath !== inputCsv) {
+            await writeSlimBatchedRuntimeCsv({
+              cleanSourceCsvPath: inputCsv,
+              mergeSourceCsvPath: workingMergeSourceCsvPath,
+              rows: chunkRows,
+              compactAliases: runtimeCompactAliases,
+              outputPath: runtimeSourceCsvPath
+            });
+          }
           const chunk = await runOne({
-            sourceCsvPath: workingSourceCsvPath,
+            sourceCsvPath: runtimeSourceCsvPath,
+            mergeSourceCsvPath: workingMergeSourceCsvPath,
             rows: chunkRows,
             json: true,
             passthroughStdout: false,
@@ -19392,7 +19596,10 @@ function registerEnrichCommand(program) {
           if (chunk.captured.result !== 0) {
             if (chunk.exportResult) {
               finalExportResult = chunk.exportResult;
-              totalEnrichedRows += chunk.exportResult.enrichedRows;
+              totalEnrichedRows += countEnrichedRowsInSourceRange(
+                chunk.exportResult,
+                chunkRows
+              );
               batchFailureRows.push(...chunk.exportResult.enrichedDataRows);
             }
             const failureReport3 = await maybeEmitEnrichFailureReport({
@@ -19453,9 +19660,12 @@ function registerEnrichCommand(program) {
           }
           if (chunk.exportResult) {
             finalExportResult = chunk.exportResult;
-            totalEnrichedRows += chunk.exportResult.enrichedRows;
+            totalEnrichedRows += countEnrichedRowsInSourceRange(
+              chunk.exportResult,
+              chunkRows
+            );
             batchFailureRows.push(...chunk.exportResult.enrichedDataRows);
-            workingSourceCsvPath = outputPath;
+            workingMergeSourceCsvPath = outputPath;
           }
         }
         const outputRows = readCsvRows(outputPath);