deepline 0.1.181 → 0.1.182

package/dist/bundling-sources/sdk/src/play.ts

@@ -74,11 +74,20 @@
  */
 import { DeeplineClient } from './client.js';
 import { DeeplineError } from './errors.js';
-import { createToolExecuteResult } from '../../shared_libs/play-runtime/tool-result.js';
+import {
+  attachToolResultListDataset,
+  createToolExecuteResult,
+} from '../../shared_libs/play-runtime/tool-result.js';
 export {
   readValue,
   readList,
 } from '../../shared_libs/play-runtime/tool-result.js';
+import { createDeferredPlayDataset } from '../../shared_libs/plays/dataset.js';
+import {
+  QUERY_RESULT_DATASET_PAGE_SIZE,
+  isCustomerDbDatasetTool,
+  isQueryResultDatasetTool,
+} from '../../shared_libs/play-runtime/query-result-dataset.js';
 import type {
   PlayDataset,
   PlayDatasetInput,
@@ -1473,8 +1482,12 @@ export class DeeplineContext {
       ): Promise<ToolExecuteResult> => {
         const response = await this.client.executeTool(toolId, input, {
           includeToolMetadata: true,
+          responseIntent: 'dataset',
+        });
+        return toolExecutionEnvelopeToResult(toolId, response, {
+          client: this.client,
+          input,
         });
-        return toolExecutionEnvelopeToResult(toolId, response);
       },
     };
   }
@@ -1724,9 +1737,163 @@ function extractorDescriptorRecord(
   );
 }
 
+function rowsFromUnknown(value: unknown): Record<string, unknown>[] {
+  if (!Array.isArray(value)) return [];
+  return value.map((row) => (isRecord(row) ? row : { value: row }));
+}
+
+function finiteNonNegativeInteger(value: unknown): number | null {
+  if (typeof value !== 'number' || !Number.isFinite(value) || value < 0) {
+    return null;
+  }
+  return Math.floor(value);
+}
+
+function finitePositiveInteger(value: unknown): number | null {
+  const integer = finiteNonNegativeInteger(value);
+  return integer !== null && integer > 0 ? integer : null;
+}
+
+function stableHash(value: string): string {
+  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: string,
+  result: ToolExecuteResult,
+  options?: {
+    client: DeeplineClient;
+    input: Record<string, unknown>;
+  },
+): ToolExecuteResult {
+  if (!options || !isQueryResultDatasetTool(toolId)) return result;
+  const raw = isRecord(result.toolResponse.raw)
+    ? result.toolResponse.raw
+    : null;
+  const dataset = isRecord(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: number,
+    limit: number,
+  ): Promise<Record<string, unknown>[]> => {
+    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 = isRecord(response.toolResponse?.raw)
+      ? response.toolResponse.raw
+      : null;
+    return rowsFromUnknown(pageRaw?.rows);
+  };
+  const collectRows = async (
+    limit: number | undefined,
+  ): Promise<Record<string, unknown>[]> => {
+    const target = Math.min(limit ?? totalRows, totalRows, datasetLimit);
+    const collected: Record<string, unknown>[] = [];
+    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),
+              );
+            }
+          },
+        }) as AsyncIterable<Record<string, unknown>>,
+    },
+  });
+  return attachToolResultListDataset(result, {
+    name: 'rows',
+    path: 'toolResponse.raw.rows',
+    dataset: playDataset,
+    count: Math.min(totalRows, datasetLimit),
+  });
+}
+
 function toolExecutionEnvelopeToResult(
   fallbackToolId: string,
   response: ToolExecution,
+  options?: {
+    client: DeeplineClient;
+    input: Record<string, unknown>;
+  },
 ): ToolExecuteResult {
   const raw = response.toolResponse?.raw ?? null;
   const meta = response.toolResponse?.meta;
@@ -1735,30 +1902,37 @@ function toolExecutionEnvelopeToResult(
     : null;
   const toolMetadata = isRecord(metadata) ? metadata : {};
 
-  return createToolExecuteResult({
-    status: typeof response.status === 'string' ? response.status : 'completed',
-    jobId: typeof response.job_id === 'string' ? response.job_id : undefined,
-    result: {
-      data: raw,
-      ...(isRecord(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: isRecord(response.meta) ? response.meta : undefined,
-  });
+  return attachSdkQueryResultDatasetResult(
+    fallbackToolId,
+    createToolExecuteResult({
+      status:
+        typeof response.status === 'string' ? response.status : 'completed',
+      jobId: typeof response.job_id === 'string' ? response.job_id : undefined,
+      result: {
+        data: raw,
+        ...(isRecord(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: isRecord(response.meta) ? response.meta : undefined,
+    }),
+    options,
+  );
 }
 
 export function defineInput<TInput>(

package/dist/bundling-sources/sdk/src/release.ts

@@ -105,10 +105,10 @@ export const 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: [