deepline 0.1.181 → 0.1.183

package/dist/index.mjs

@@ -352,10 +352,10 @@ var SDK_RELEASE = {
   // 0.1.154 removes the short-lived generated enrich StepOptions recompute
   // fields shipped in 0.1.153.
   // 0.1.175 ships loud `deepline enrich` empty-waterfall reporting.
-  version: "0.1.181",
+  version: "0.1.183",
   apiContract: "2026-06-dataset-handle-results-hard-cutover",
   supportPolicy: {
-    latest: "0.1.181",
+    latest: "0.1.183",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53",
     commandMinimumSupported: [
@@ -513,6 +513,10 @@ var WORKER_CALLBACK_URL_OVERRIDE_HEADER = "x-deepline-worker-callback-url";
 var RUNTIME_SCHEDULER_SCHEMA_OVERRIDE_HEADER = "x-deepline-runtime-scheduler-schema";
 var SYNTHETIC_RUN_HEADER = "x-deepline-synthetic-run";
 
+// ../shared_libs/play-runtime/test-runtime-seams.ts
+var PLAY_RUNTIME_TEST_FAULT_HEADER = "x-deepline-test-fault";
+var MAX_RUNTIME_TEST_POLICY_MS = 10 * 6e4;
+
 // src/http.ts
 var MAX_DIAGNOSTIC_HEADER_LENGTH = 120;
 var COWORK_NETWORK_HINT = "Claude Cowork appears to be running Deepline in a network-restricted sandbox. In Claude Desktop, open Settings > Capabilities, turn on Allow network egress, and set Domain allowlist to All domains for the Cowork session.";
@@ -627,12 +631,9 @@ var HttpClient = class {
       headers["x-deepline-play-artifact-r2-prefix"] = playArtifactR2Prefix;
     }
     const coordinatorUrl = typeof process !== "undefined" ? process.env?.DEEPLINE_COORDINATOR_URL : void 0;
+    const coordinatorInternalToken = typeof process !== "undefined" ? process.env?.DEEPLINE_INTERNAL_TOKEN : void 0;
     if (coordinatorUrl?.trim()) {
       headers[COORDINATOR_URL_OVERRIDE_HEADER] = coordinatorUrl.trim();
-      const coordinatorInternalToken = typeof process !== "undefined" ? process.env?.DEEPLINE_INTERNAL_TOKEN : void 0;
-      if (coordinatorInternalToken?.trim()) {
-        headers[COORDINATOR_INTERNAL_TOKEN_HEADER] = coordinatorInternalToken.trim();
-      }
     }
     const workerCallbackUrl = typeof process !== "undefined" ? process.env?.DEEPLINE_WORKER_CALLBACK_URL : void 0;
     if (workerCallbackUrl?.trim()) {
@@ -646,6 +647,13 @@ var HttpClient = class {
     if (syntheticRun && syntheticRun.trim() && syntheticRun.trim() !== "0") {
       headers[SYNTHETIC_RUN_HEADER] = "1";
     }
+    const runtimeTestFault = typeof process !== "undefined" ? process.env?.DEEPLINE_TEST_RUNTIME_FAULT : void 0;
+    if (runtimeTestFault?.trim()) {
+      headers[PLAY_RUNTIME_TEST_FAULT_HEADER] = runtimeTestFault.trim();
+    }
+    if (coordinatorInternalToken?.trim() && (coordinatorUrl?.trim() || workerCallbackUrl?.trim() || runtimeTestFault?.trim())) {
+      headers[COORDINATOR_INTERNAL_TOKEN_HEADER] = coordinatorInternalToken.trim();
+    }
     return headers;
   }
   /**
@@ -1059,6 +1067,20 @@ function resolveTimingWindow(input) {
   };
 }
 
+// ../shared_libs/play-runtime/run-terminal-source.ts
+var PLAY_RUN_LEDGER_EVENT_SOURCES = [
+  "worker",
+  "temporal",
+  "convex",
+  "coordinator",
+  "system"
+];
+function normalizePlayRunLedgerTerminalSource(value) {
+  return PLAY_RUN_LEDGER_EVENT_SOURCES.includes(
+    value
+  ) ? value : null;
+}
+
 // ../shared_libs/play-runtime/run-ledger.ts
 var LOG_TAIL_LIMIT = 100;
 function isRecord(value) {
@@ -1195,7 +1217,8 @@ function normalizePlayRunLedgerSnapshot(value, fallback) {
     ),
     resultTableNamespace: optionalNullableString(value.resultTableNamespace),
     resultSummary: value.resultSummary,
-    result: value.result
+    result: value.result,
+    terminalSource: normalizePlayRunLedgerTerminalSource(value.terminalSource)
   };
 }
 function normalizeStepStatus(value) {
@@ -1920,6 +1943,33 @@ function resolvePlayRunIntegrationMode(request) {
     request.integrationMode ?? process.env.DEEPLINE_EVAL_INTEGRATION_MODE
   );
 }
+function normalizeTestPolicyOverrides(value, source) {
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    return value;
+  }
+  throw new DeeplineError(
+    `${source} must be a JSON object.`,
+    void 0,
+    "INVALID_TEST_POLICY_OVERRIDES"
+  );
+}
+function parseEnvTestPolicyOverrides() {
+  const raw = typeof process !== "undefined" ? process.env?.DEEPLINE_TEST_POLICY_OVERRIDES : void 0;
+  const trimmed = raw?.trim();
+  if (!trimmed) return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch (error) {
+    const detail = error instanceof Error ? ` ${error.message}` : "";
+    throw new DeeplineError(
+      `DEEPLINE_TEST_POLICY_OVERRIDES must be valid JSON.${detail}`,
+      void 0,
+      "INVALID_TEST_POLICY_OVERRIDES"
+    );
+  }
+  return normalizeTestPolicyOverrides(parsed, "DEEPLINE_TEST_POLICY_OVERRIDES");
+}
 function sleep2(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
@@ -2471,11 +2521,14 @@ var DeeplineClient = class {
     const headers = {
       [EXECUTE_RESPONSE_CONTRACT_HEADER]: V2_EXECUTE_RESPONSE_CONTRACT,
       ...options?.includeToolMetadata ? { [INCLUDE_TOOL_METADATA_HEADER]: "true" } : {},
-      ...options?.responseIntent ? { [EXECUTE_RESPONSE_INTENT_HEADER]: options.responseIntent } : {}
+      [EXECUTE_RESPONSE_INTENT_HEADER]: options?.responseIntent ?? "raw"
     };
     return this.http.post(
       `/api/v2/integrations/${encodeURIComponent(toolId)}/execute`,
-      { payload: input },
+      {
+        payload: input,
+        ...options?.metadata ? { metadata: options.metadata } : {}
+      },
       headers,
       {
         forbiddenAsApiError: true,
@@ -2559,6 +2612,7 @@ var DeeplineClient = class {
    */
   async startPlayRun(request) {
     const integrationMode = resolvePlayRunIntegrationMode(request);
+    const testPolicyOverrides = request.testPolicyOverrides ?? parseEnvTestPolicyOverrides();
     const forceToolRefresh = request.forceToolRefresh === true;
     const response = await this.http.post(
       "/api/v2/plays/run",
@@ -2586,7 +2640,8 @@ var DeeplineClient = class {
         // defaults to workers_edge; tests and runtime probes that want a
         // different profile pass `request.profile` explicitly.
         ...request.profile ? { profile: request.profile } : {},
-        ...integrationMode ? { integrationMode } : {}
+        ...integrationMode ? { integrationMode } : {},
+        ...testPolicyOverrides ? { testPolicyOverrides } : {}
       }
     );
     return normalizePlayRunStart(response);
@@ -2604,6 +2659,7 @@ var DeeplineClient = class {
    */
   async *startPlayRunStream(request, options) {
     const integrationMode = resolvePlayRunIntegrationMode(request);
+    const testPolicyOverrides = request.testPolicyOverrides ?? parseEnvTestPolicyOverrides();
     const forceToolRefresh = request.forceToolRefresh === true;
     const body = {
       ...request.name ? { name: request.name } : {},
@@ -2626,7 +2682,8 @@ var DeeplineClient = class {
       ...forceToolRefresh ? { forceToolRefresh: true } : {},
       ...typeof request.waitForCompletionMs === "number" ? { waitForCompletionMs: request.waitForCompletionMs } : {},
       ...request.profile ? { profile: request.profile } : {},
-      ...integrationMode ? { integrationMode } : {}
+      ...integrationMode ? { integrationMode } : {},
+      ...testPolicyOverrides ? { testPolicyOverrides } : {}
     };
     for await (const event of this.http.streamSse(
       "/api/v2/plays/run?stream=true",
@@ -5280,6 +5337,73 @@ function createToolExecuteResult(input) {
   });
   return wrapper;
 }
+function attachToolResultListDataset(result, input) {
+  const existing = result._metadata.lists[input.name];
+  result._metadata.lists[input.name] = {
+    path: input.path,
+    count: input.count,
+    keys: input.keys ?? existing?.keys ?? {}
+  };
+  const accessor = {
+    path: input.path,
+    count: input.count,
+    keys: result._metadata.lists[input.name].keys
+  };
+  Object.defineProperty(accessor, "get", {
+    value() {
+      return input.dataset;
+    },
+    enumerable: false
+  });
+  result.extractedLists[input.name] = accessor;
+  const serialized = input.dataset.toJSON();
+  let root = { toolResponse: { raw: result.toolResponse.raw } };
+  const candidates = [...candidateResultPaths(input.path)].filter(
+    (candidate, index, all) => all.indexOf(candidate) === index
+  );
+  for (const candidate of candidates) {
+    if (!Array.isArray(getAtPath(root, candidate))) continue;
+    root = replaceAtPath(root, candidate, serialized.preview);
+    break;
+  }
+  if (isRecord4(root) && isRecord4(root.toolResponse) && Object.prototype.hasOwnProperty.call(root.toolResponse, "raw")) {
+    result.toolResponse.raw = root.toolResponse.raw;
+    result.toolOutput.raw = root.toolResponse.raw;
+  }
+  return result;
+}
+function replaceAtPath(root, path, replacement) {
+  const segments = parsePath(path);
+  if (segments.length === 0 || segments.includes("*")) return root;
+  const replace = (current, index) => {
+    if (index >= segments.length) return replacement;
+    const segment = segments[index];
+    if (typeof segment === "number") {
+      if (!Array.isArray(current)) return current;
+      const copy = [...current];
+      copy[segment] = replace(copy[segment], index + 1);
+      return copy;
+    }
+    if (!isRecord4(current)) return current;
+    return {
+      ...current,
+      [segment]: replace(current[segment], index + 1)
+    };
+  };
+  return replace(root, 0);
+}
+
+// ../shared_libs/play-runtime/query-result-dataset.ts
+var QUERY_RESULT_DATASET_PAGE_SIZE = 1e3;
+function isCustomerDbDatasetTool(toolId) {
+  return /^(?:customer_db_)?query_customer_db$/.test(toolId);
+}
+function isSnowflakeQueryDatasetTool(toolId) {
+  return /^snowflake_(?:snowflake_)?run_(?:semantic_)?query$/.test(toolId);
+}
+function isQueryResultDatasetTool(toolId) {
+  return isCustomerDbDatasetTool(toolId) || isSnowflakeQueryDatasetTool(toolId);
+}
 
 // src/play.ts
 var DeeplineConditionalStepResolver = class _DeeplineConditionalStepResolver {
@@ -5455,9 +5579,13 @@ var DeeplineContext = class {
       /** Execute a tool and return the standard execution envelope. */
       execute: async (toolId, input) => {
         const response = await this.client.executeTool(toolId, input, {
-          includeToolMetadata: true
+          includeToolMetadata: true,
+          responseIntent: "dataset"
+        });
+        return toolExecutionEnvelopeToResult(toolId, response, {
+          client: this.client,
+          input
         });
-        return toolExecutionEnvelopeToResult(toolId, response);
       }
     };
   }
@@ -5652,32 +5780,143 @@ function extractorDescriptorRecord(value) {
     })
   );
 }
-function toolExecutionEnvelopeToResult(fallbackToolId, response) {
+function rowsFromUnknown(value) {
+  if (!Array.isArray(value)) return [];
+  return value.map((row) => isRecord5(row) ? row : { value: row });
+}
+function finiteNonNegativeInteger(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    return null;
+  }
+  return Math.floor(value);
+}
+function finitePositiveInteger(value) {
+  const integer = finiteNonNegativeInteger(value);
+  return integer !== null && integer > 0 ? integer : null;
+}
+function stableHash(value) {
+  let hash = 0;
+  for (let index = 0; index < value.length; index += 1) {
+    hash = Math.imul(31, hash) + value.charCodeAt(index);
+    hash |= 0;
+  }
+  return Math.abs(hash).toString(36);
+}
+function attachSdkQueryResultDatasetResult(toolId, result, options) {
+  if (!options || !isQueryResultDatasetTool(toolId)) return result;
+  const raw = isRecord5(result.toolResponse.raw) ? result.toolResponse.raw : null;
+  const dataset = isRecord5(raw?.dataset) ? raw.dataset : null;
+  const totalRows = finiteNonNegativeInteger(dataset?.total_rows);
+  const sql = typeof options.input.sql === "string" ? options.input.sql : typeof options.input.query === "string" ? options.input.query : typeof raw?.sql === "string" ? raw.sql : null;
+  if (!dataset || totalRows === null || !sql) {
+    return result;
+  }
+  const datasetLimit = finitePositiveInteger(dataset.returned_limit) ?? totalRows;
+  const previewRows = rowsFromUnknown(raw?.rows).slice(0, 25);
+  const fetchPage = async (offset, limit) => {
+    if (limit <= 0 || offset >= totalRows) return [];
+    const response = await options.client.executeTool(toolId, options.input, {
+      includeToolMetadata: true,
+      responseIntent: "dataset",
+      metadata: {
+        query_result_dataset: {
+          limit: datasetLimit,
+          offset,
+          page_size: Math.min(limit, QUERY_RESULT_DATASET_PAGE_SIZE),
+          total_rows: totalRows
+        },
+        ...isCustomerDbDatasetTool(toolId) ? {
+          customer_db_dataset: {
+            limit: datasetLimit,
+            offset,
+            page_size: Math.min(limit, QUERY_RESULT_DATASET_PAGE_SIZE),
+            total_rows: totalRows
+          }
+        } : {}
+      }
+    });
+    const pageRaw = isRecord5(response.toolResponse?.raw) ? response.toolResponse.raw : null;
+    return rowsFromUnknown(pageRaw?.rows);
+  };
+  const collectRows = async (limit) => {
+    const target = Math.min(limit ?? totalRows, totalRows, datasetLimit);
+    const collected = [];
+    for (let offset = 0; offset < target; offset += QUERY_RESULT_DATASET_PAGE_SIZE) {
+      collected.push(
+        ...await fetchPage(
+          offset,
+          Math.min(QUERY_RESULT_DATASET_PAGE_SIZE, target - offset)
+        )
+      );
+    }
+    return collected.slice(0, target);
+  };
+  const executionNonce = typeof result.job_id === "string" && result.job_id.trim() ? result.job_id.trim() : `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+  const safeNonce = executionNonce.replace(/[^A-Za-z0-9_.:-]/g, "_").slice(0, 64);
+  const datasetScope = `${options.client.baseUrl}:${toolId}:${sql}:${datasetLimit}`;
+  const playDataset = createDeferredPlayDataset({
+    datasetKind: "csv",
+    datasetId: `sdk-tool-list:${toolId}:${stableHash(datasetScope)}:${datasetLimit}:${safeNonce}`,
+    count: Math.min(totalRows, datasetLimit),
+    previewRows,
+    sourceLabel: "query result rows",
+    tableNamespace: null,
+    resolvers: {
+      count: async () => Math.min(totalRows, datasetLimit),
+      peek: async (limit) => collectRows(limit),
+      materialize: async (limit) => collectRows(limit),
+      iterate: () => ({
+        async *[Symbol.asyncIterator]() {
+          const count = Math.min(totalRows, datasetLimit);
+          for (let offset = 0; offset < count; offset += QUERY_RESULT_DATASET_PAGE_SIZE) {
+            yield* await fetchPage(
+              offset,
+              Math.min(QUERY_RESULT_DATASET_PAGE_SIZE, count - offset)
+            );
+          }
+        }
+      })
+    }
+  });
+  return attachToolResultListDataset(result, {
+    name: "rows",
+    path: "toolResponse.raw.rows",
+    dataset: playDataset,
+    count: Math.min(totalRows, datasetLimit)
+  });
+}
+function toolExecutionEnvelopeToResult(fallbackToolId, response, options) {
   const raw = response.toolResponse?.raw ?? null;
   const meta = response.toolResponse?.meta;
   const metadata = isRecord5(response._metadata) ? response._metadata.tool : null;
   const toolMetadata = isRecord5(metadata) ? metadata : {};
-  return createToolExecuteResult({
-    status: typeof response.status === "string" ? response.status : "completed",
-    jobId: typeof response.job_id === "string" ? response.job_id : void 0,
-    result: {
-      data: raw,
-      ...isRecord5(meta) ? { meta } : {}
-    },
-    metadata: {
-      toolId: typeof toolMetadata.toolId === "string" ? toolMetadata.toolId : fallbackToolId,
-      extractors: extractorDescriptorRecord(toolMetadata.extractors),
-      targetGetters: stringArrayRecord(toolMetadata.targetGetters),
-      listExtractorPaths: stringArray(toolMetadata.listExtractorPaths),
-      listIdentityGetters: stringArrayRecord(toolMetadata.listIdentityGetters)
-    },
-    execution: {
-      idempotent: true,
-      cached: false,
-      source: "live"
-    },
-    meta: isRecord5(response.meta) ? response.meta : void 0
-  });
+  return attachSdkQueryResultDatasetResult(
+    fallbackToolId,
+    createToolExecuteResult({
+      status: typeof response.status === "string" ? response.status : "completed",
+      jobId: typeof response.job_id === "string" ? response.job_id : void 0,
+      result: {
+        data: raw,
+        ...isRecord5(meta) ? { meta } : {}
+      },
+      metadata: {
+        toolId: typeof toolMetadata.toolId === "string" ? toolMetadata.toolId : fallbackToolId,
+        extractors: extractorDescriptorRecord(toolMetadata.extractors),
+        targetGetters: stringArrayRecord(toolMetadata.targetGetters),
+        listExtractorPaths: stringArray(toolMetadata.listExtractorPaths),
+        listIdentityGetters: stringArrayRecord(
+          toolMetadata.listIdentityGetters
+        )
+      },
+      execution: {
+        idempotent: true,
+        cached: false,
+        source: "live"
+      },
+      meta: isRecord5(response.meta) ? response.meta : void 0
+    }),
+    options
+  );
 }
 function defineInput(schema) {
   if (!schema || typeof schema !== "object" || Array.isArray(schema)) {

package/dist/plays/bundle-play-file.mjs

@@ -1749,9 +1749,9 @@ var PLAY_RUNTIME_PROVIDERS = {
     id: PLAY_RUNTIME_PROVIDER_IDS.hatchet,
     scheduler: PLAY_SCHEDULER_BACKENDS.hatchet,
     runner: PLAY_RUNTIME_BACKENDS.daytona,
-    dedup: PLAY_DEDUP_BACKENDS.durableObject,
+    dedup: PLAY_DEDUP_BACKENDS.inMemory,
     artifactKind: PLAY_ARTIFACT_KINDS.cjsNode20,
-    label: "Hatchet scheduler + one-shot Daytona runner + DO dedup"
+    label: "Hatchet scheduler + one-shot Daytona runner + receipt-backed in-process dedup"
   },
   local: {
     id: PLAY_RUNTIME_PROVIDER_IDS.local,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepline",
-  "version": "0.1.181",
+  "version": "0.1.183",
   "description": "Deepline SDK + CLI — B2B data enrichment powered by durable cloud execution",
   "license": "MIT",
   "repository": {