deepline 0.1.181 → 0.1.182

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.182",
   apiContract: "2026-06-dataset-handle-results-hard-cutover",
   supportPolicy: {
-    latest: "0.1.181",
+    latest: "0.1.182",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53",
     commandMinimumSupported: [
@@ -2471,11 +2471,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,
@@ -5280,6 +5283,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 +5525,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 +5726,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/package.json

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