dataiku-sdk 3.6.0 → 3.7.0

package/dist/src/resources/datasets.js

@@ -1,15 +1,13 @@
 import * as fs from "node:fs";
 import * as nodePath from "node:path";
-import { Readable, Transform, } from "node:stream";
-import { pipeline, } from "node:stream/promises";
 import { StringDecoder, } from "node:string_decoder";
-import { createGzip, } from "node:zlib";
 import { ClientValidationError, DataikuError, } from "../errors.js";
 import { DatasetDetailsSchema, DatasetSchemaSchema, DatasetSummaryArraySchema, } from "../schemas.js";
 import { deepMerge, } from "../utils/deep-merge.js";
 import { sanitizeFileName, } from "../utils/sanitize.js";
 import { BaseResource, } from "./base.js";
 import { resolveAdminManagedStorageConnection, } from "./connections.js";
+import { buildDatasetCreateBody, } from "./dataset-create.js";
 // ---------------------------------------------------------------------------
 // Helpers: TSV → CSV streaming conversion
 // ---------------------------------------------------------------------------
@@ -404,13 +402,14 @@ const CSV_BATCH_BYTES = 64 * 1024;
 function tsvToCsvTransform(maxDataRows, stats, onHeader, spreadsheetSafe = true) {
     const state = createTsvStreamState();
     const decoder = new StringDecoder("utf-8");
+    const encoder = new TextEncoder();
     const maxRows = Math.max(1, maxDataRows);
     let headerSeen = false;
     let done = false;
     // Bounded CSV output batching: emitted rows accumulate here and are joined
-    // into a single push once the batch reaches CSV_BATCH_BYTES, so memory stays
-    // bounded by the batch budget plus one escaped row (the join briefly holds a
-    // second copy of the batch) while per-row push/callback overhead disappears.
+    // into a single enqueue once the batch reaches CSV_BATCH_BYTES, so memory
+    // stays bounded by the batch budget plus one escaped row (the join briefly
+    // holds a second copy of the batch) while per-row chunk overhead disappears.
     let batchLines = [];
     let batchBytes = 0;
     const flushBatch = (target) => {
@@ -419,7 +418,7 @@ function tsvToCsvTransform(maxDataRows, stats, onHeader, spreadsheetSafe = true)
         const csv = batchLines.join("");
         batchLines = [];
         batchBytes = 0;
-        target.push(csv);
+        target.enqueue(encoder.encode(csv));
     };
     const queueLine = (target, line) => {
         batchLines.push(line);
@@ -450,48 +449,27 @@ function tsvToCsvTransform(maxDataRows, stats, onHeader, spreadsheetSafe = true)
         push(`${rowToCsv(row, spreadsheetSafe)}\n`);
         stats.rows += 1;
     };
-    return new Transform({
-        transform(chunk, _encoding, callback) {
+    // A byte-limit overflow throws out of transform/flush: the stream errors,
+    // which cancels the response and makes download() remove the partial file.
+    return new TransformStream({
+        transform(chunk, controller) {
+            consumeTsvChunk(decoder.write(chunk), state, (row) => handleRow(row, (line) => queueLine(controller, line)));
             if (done) {
-                callback();
-                return;
-            }
-            try {
-                consumeTsvChunk(decoder.write(chunk), state, (row) => handleRow(row, (line) => queueLine(this, line)));
-            }
-            catch (error) {
-                // Byte-limit overflow: destroy the transform so the pipeline
-                // cancels the response and the partial file is removed.
-                callback(error instanceof Error ? error : new ClientValidationError(String(error), "internal_error"));
-                return;
-            }
-            if (done) {
-                // Truncation reached: emit the batch queued so far before EOF.
-                flushBatch(this);
-                this.push(null);
+                // Truncation reached: emit the batch queued so far, end the output,
+                // and cancel the rest of the response.
+                flushBatch(controller);
+                controller.terminate();
             }
-            callback();
         },
-        flush(callback) {
-            if (done) {
-                callback();
-                return;
-            }
-            try {
-                const tail = decoder.end();
-                if (tail !== "") {
-                    consumeTsvChunk(tail, state, (row) => handleRow(row, (line) => queueLine(this, line)));
-                }
-                flushTsvStream(state, (row) => handleRow(row, (line) => queueLine(this, line)));
-            }
-            catch (error) {
-                callback(error instanceof Error ? error : new ClientValidationError(String(error), "internal_error"));
-                return;
+        flush(controller) {
+            const tail = decoder.end();
+            if (tail !== "") {
+                consumeTsvChunk(tail, state, (row) => handleRow(row, (line) => queueLine(controller, line)));
             }
+            flushTsvStream(state, (row) => handleRow(row, (line) => queueLine(controller, line)));
             // Emit the trailing partial batch; without this the last rows of a
             // download (below the batch budget) would be silently dropped.
-            flushBatch(this);
-            callback();
+            flushBatch(controller);
         },
     });
 }
@@ -518,60 +496,6 @@ function isMissingUploadedFilesTargetConnection(error) {
     return (detail.includes("without a target connection")
         || detail.includes("target connection is required"));
 }
-/** Wire body for POST /datasets/; shared with `dataset create --plan` so the plan matches the request. */
-export function buildDatasetCreateBody(opts) {
-    if (opts.dsType.toLowerCase() === "uploadedfiles") {
-        return {
-            projectKey: opts.projectKey,
-            name: opts.datasetName,
-            type: opts.dsType,
-            params: opts.connection ? { uploadConnection: opts.connection, } : {},
-        };
-    }
-    if (!opts.connection) {
-        throw new ClientValidationError("connection is required unless dsType is UploadedFiles.");
-    }
-    if (opts.table) {
-        const params = {
-            connection: opts.connection,
-            mode: "table",
-            table: opts.table,
-        };
-        if (opts.dbSchema)
-            params.schema = opts.dbSchema;
-        if (opts.catalog)
-            params.catalog = opts.catalog;
-        return {
-            projectKey: opts.projectKey,
-            name: opts.datasetName,
-            type: opts.dsType,
-            params,
-            managed: opts.managed ?? false,
-        };
-    }
-    return {
-        projectKey: opts.projectKey,
-        name: opts.datasetName,
-        type: opts.dsType,
-        params: {
-            connection: opts.connection,
-            path: `/dataiku/${opts.projectKey}/${opts.datasetName}`,
-        },
-        formatType: opts.formatType ?? "csv",
-        formatParams: opts.formatParams ?? {
-            style: "excel",
-            charset: "utf8",
-            separator: "\t",
-            quoteChar: '"',
-            escapeChar: "\\",
-            dateSerializationFormat: "ISO",
-            arrayMapFormat: "json",
-            parseHeaderRow: true,
-            compress: "gz",
-        },
-        managed: opts.managed ?? true,
-    };
-}
 const DATASET_CLONE_PARAM_KEYS = [
     "connection",
     "uploadConnection",
@@ -676,6 +600,23 @@ export class DatasetsResource extends BaseResource {
         const dsEnc = encodeURIComponent(datasetName);
         return this.client.get(`/public/api/projects/${this.enc(projectKey)}/datasets/${dsEnc}/schema`);
     }
+    /**
+     * TSV data stream of at most `limit` rows. A column or partition selection
+     * uses the documented POST variant of the data endpoint (body `columns`,
+     * `partitions`, `format`, `sampling`); otherwise the GET endpoint.
+     */
+    async dataStream(datasetName, limit, projectKey, selection) {
+        const path = `/public/api/projects/${this.enc(projectKey)}/datasets/${encodeURIComponent(datasetName)}/data/`;
+        if (!selection?.columns?.length && !selection?.partitions) {
+            return this.client.stream(`${path}?format=tsv-excel-header&limit=${limit}`);
+        }
+        return this.client.postStream(path, {
+            format: "tsv-excel-header",
+            ...(selection.columns?.length ? { columns: selection.columns, } : {}),
+            ...(selection.partitions ? { partitions: selection.partitions, } : {}),
+            sampling: { samplingMethod: "HEAD_SEQUENTIAL", maxRecords: limit, },
+        });
+    }
     /**
      * Preview dataset rows as structured data: column names plus row arrays,
      * mirroring the sql query shape ({ columns, rows, rowCount }). Streams TSV
@@ -691,10 +632,9 @@ export class DatasetsResource extends BaseResource {
     async preview(datasetName, opts) {
         const maxRows = Math.max(1, Math.min(opts?.maxRows ?? 50, 500));
         const timeoutMs = Math.max(1, opts?.timeoutMs ?? this.client.getRequestTimeoutMs());
-        const dsEnc = encodeURIComponent(datasetName);
         // Probe one row past the cap so callers learn whether the dataset holds
         // more rows than requested without materializing the full dataset.
-        const res = await this.client.stream(`/public/api/projects/${this.enc(opts?.projectKey)}/datasets/${dsEnc}/data/?format=tsv-excel-header&limit=${maxRows + 1}`);
+        const res = await this.dataStream(datasetName, maxRows + 1, opts?.projectKey, opts);
         const onHeader = opts?.validateColumns
             ? (headerRow) => {
                 const warnings = validateStreamColumns(headerRow, opts.validateColumns);
@@ -761,6 +701,20 @@ export class DatasetsResource extends BaseResource {
         const dsEnc = encodeURIComponent(datasetName);
         return this.client.put(`/public/api/projects/${this.enc(projectKey)}/datasets/${dsEnc}/metadata`, metadata);
     }
+    /**
+     * Create or update the Hive table of an HDFS dataset so it matches the
+     * dataset schema (POST /actions/synchronizeHiveMetastore).
+     */
+    async synchronizeHiveMetastore(datasetName, projectKey) {
+        await this.client.post(`/public/api/projects/${this.enc(projectKey)}/datasets/${encodeURIComponent(datasetName)}/actions/synchronizeHiveMetastore`);
+    }
+    /**
+     * Update an HDFS dataset (path, schema, partitioning, format) from its
+     * Hive table (POST /actions/updateFromHive).
+     */
+    async updateFromHive(datasetName, projectKey) {
+        await this.client.post(`/public/api/projects/${this.enc(projectKey)}/datasets/${encodeURIComponent(datasetName)}/actions/updateFromHive`);
+    }
     /**
      * Create a managed dataset through the dedicated
      * `POST /projects/{projectKey}/datasets/managed` endpoint. DSS handles the
@@ -862,8 +816,7 @@ export class DatasetsResource extends BaseResource {
      */
     async download(datasetName, opts) {
         const limit = Math.max(1, opts?.limit ?? 100_000);
-        const dsEnc = encodeURIComponent(datasetName);
-        const res = await this.client.stream(`/public/api/projects/${this.enc(opts?.projectKey)}/datasets/${dsEnc}/data/?format=tsv-excel-header&limit=${limit + 1}`);
+        const res = await this.dataStream(datasetName, limit + 1, opts?.projectKey, opts);
         const safeDatasetName = sanitizeFileName(datasetName, "dataset");
         const filePath = opts?.outputPath?.endsWith(".gz") || opts?.outputPath?.endsWith(".csv")
             ? nodePath.resolve(opts.outputPath)
@@ -878,18 +831,13 @@ export class DatasetsResource extends BaseResource {
             : undefined;
         const shouldGzip = filePath.endsWith(".gz");
         const stats = { rows: 0, truncated: false, };
-        const nodeStream = Readable.from(res.body, { objectMode: false, });
-        const csvTransform = tsvToCsvTransform(limit, stats, onHeader, opts?.rawData !== true);
+        let csv = res.body.pipeThrough(tsvToCsvTransform(limit, stats, onHeader, opts?.rawData !== true));
+        if (shouldGzip)
+            csv = csv.pipeThrough(new CompressionStream("gzip"));
         fs.mkdirSync(nodePath.dirname(filePath), { recursive: true, });
-        const fileOut = fs.createWriteStream(filePath);
         try {
-            if (shouldGzip) {
-                const gzip = createGzip();
-                await pipeline(nodeStream, csvTransform, gzip, fileOut);
-            }
-            else {
-                await pipeline(nodeStream, csvTransform, fileOut);
-            }
+            // Native streaming write with backpressure; no Node stream layer.
+            await Bun.write(filePath, new Response(csv));
         }
         catch (error) {
             // A failed export (byte-limit overflow, network error) must never

package/dist/src/resources/discussions.d.ts

@@ -21,6 +21,11 @@ export declare class DiscussionsResource extends BaseResource {
     create(objectType: string, objectId: string, topic: string, reply: string, projectKey?: string): Promise<Discussion>;
     /** Add a reply to an existing discussion. */
     reply(objectType: string, objectId: string, discussionId: string, text: string, projectKey?: string): Promise<Discussion>;
+    /**
+     * Update a discussion (topic, or the object it is attached to within the
+     * project): PUT the full discussion object obtained from `get`, edited.
+     */
+    update(objectType: string, objectId: string, discussionId: string, discussion: Record<string, unknown>, projectKey?: string): Promise<Discussion>;
     private objectDiscussionsPath;
     private discussionPath;
 }

package/dist/src/resources/discussions.js

@@ -16,6 +16,13 @@ export class DiscussionsResource extends BaseResource {
     async reply(objectType, objectId, discussionId, text, projectKey) {
         return this.client.post(`${this.discussionPath(objectType, objectId, discussionId, projectKey)}/replies/`, { reply: text, });
     }
+    /**
+     * Update a discussion (topic, or the object it is attached to within the
+     * project): PUT the full discussion object obtained from `get`, edited.
+     */
+    async update(objectType, objectId, discussionId, discussion, projectKey) {
+        return this.client.put(this.discussionPath(objectType, objectId, discussionId, projectKey), discussion);
+    }
     objectDiscussionsPath(objectType, objectId, projectKey) {
         const pk = this.enc(projectKey);
         const encodedType = encodeURIComponent(objectType);

package/dist/src/resources/documentation.d.ts

@@ -0,0 +1,25 @@
+import type { DataikuClient } from "../client.js";
+import { type DssTask } from "./futures.js";
+/** Documentation template: the DSS default, an uploaded docx, or a docx in a managed folder. */
+export type DocumentationTemplate = {
+    kind: "default";
+} | {
+    kind: "file";
+    filePath: string;
+} | {
+    kind: "folder";
+    folderId: string;
+    path: string;
+};
+/** The three generation endpoints of one documented object (flow, lab model, saved-model version). */
+export interface DocumentationRoutes {
+    default: string;
+    file: string;
+    folder: string;
+}
+/**
+ * Start a DSS documentation export (docx): POST the default route, upload the
+ * template as multipart `file`, or POST the folder route with `folderId` and
+ * `path`. The finished task's result carries the `exportId` to download.
+ */
+export declare function startDocumentation(client: DataikuClient, routes: DocumentationRoutes, template: DocumentationTemplate, operation: string): Promise<DssTask>;

package/dist/src/resources/documentation.js

@@ -0,0 +1,16 @@
+import { dssTask, } from "./futures.js";
+/**
+ * Start a DSS documentation export (docx): POST the default route, upload the
+ * template as multipart `file`, or POST the folder route with `folderId` and
+ * `path`. The finished task's result carries the `exportId` to download.
+ */
+export async function startDocumentation(client, routes, template, operation) {
+    if (template.kind === "file") {
+        return dssTask(await client.uploadJson(routes.file, template.filePath), operation);
+    }
+    if (template.kind === "folder") {
+        const query = new URLSearchParams({ folderId: template.folderId, path: template.path, });
+        return dssTask(await client.post(`${routes.folder}?${query}`), operation);
+    }
+    return dssTask(await client.post(routes.default), operation);
+}

package/dist/src/resources/flow.d.ts

@@ -0,0 +1,48 @@
+import type { FutureWaitResult } from "../schemas.js";
+import { BaseResource } from "./base.js";
+import { type DocumentationTemplate } from "./documentation.js";
+import { type DssTask, type FutureWaitOptions } from "./futures.js";
+/** Schema propagation options (dataikuapi `DSSSchemaPropagationRunBuilder` settings). */
+export interface SchemaPropagationOptions {
+    projectKey?: string;
+    /** Rebuild datasets when propagation needs their data (DSS default: true). */
+    autoRebuild?: boolean;
+    /** Recipes where propagation stops (dataikuapi `stop_at`). */
+    excludedRecipes?: string[];
+    /** Recipes always considered OK (dataikuapi `mark_recipe_as_ok`). */
+    markAsOkRecipes?: string[];
+    /** Partitioned flows: default partition value per dimension when rebuilding. */
+    defaultPartitionValuesByDimension?: Record<string, string>;
+    /** Partitioned flows: partition per computable, keyed `PROJECTKEY.id`. */
+    partitionsByComputable?: Record<string, string>;
+    /** Per-recipe-type and per-recipe update options, as dataikuapi sends them. */
+    recipeUpdateOptions?: {
+        byType?: Record<string, unknown>;
+        byName?: Record<string, unknown>;
+    };
+}
+/**
+ * Flow-wide tools: schema propagation from a dataset through every downstream
+ * recipe, and flow documentation export. Zones and the flow graph live on
+ * `flowZones`; per-recipe schema updates on `recipes.updateSchema`.
+ */
+export declare class FlowResource extends BaseResource {
+    private flowPath;
+    /**
+     * Start propagating `datasetName`'s schema through the flow
+     * (POST /flow/tools/propagate-schema/, dataikuapi
+     * `new_schema_propagation(...).start()`). Returns the DSS future.
+     */
+    propagateSchema(datasetName: string, opts?: SchemaPropagationOptions): Promise<DssTask>;
+    propagateSchemaAndWait(datasetName: string, opts?: SchemaPropagationOptions & FutureWaitOptions): Promise<FutureWaitResult | DssTask>;
+    /**
+     * Start generating the flow documentation (docx) from the DSS default
+     * template, an uploaded docx template, or a docx in a managed folder.
+     * The finished future's result carries the `exportId` to download.
+     */
+    generateDocumentation(template?: DocumentationTemplate, projectKey?: string): Promise<DssTask>;
+    /** GET a generated flow documentation (docx) as a binary stream. */
+    downloadDocumentation(exportId: string, projectKey?: string): Promise<Response>;
+}
+/** Request body of POST /flow/tools/propagate-schema/ (pure; shared with `--plan`). */
+export declare function schemaPropagationBody(projectKey: string, datasetName: string, opts: SchemaPropagationOptions): Record<string, unknown>;

package/dist/src/resources/flow.js

@@ -0,0 +1,65 @@
+import { ClientValidationError, } from "../errors.js";
+import { BaseResource, } from "./base.js";
+import { startDocumentation, } from "./documentation.js";
+import { dssTask, } from "./futures.js";
+/**
+ * Flow-wide tools: schema propagation from a dataset through every downstream
+ * recipe, and flow documentation export. Zones and the flow graph live on
+ * `flowZones`; per-recipe schema updates on `recipes.updateSchema`.
+ */
+export class FlowResource extends BaseResource {
+    flowPath(projectKey) {
+        return `/public/api/projects/${this.enc(projectKey)}/flow`;
+    }
+    /**
+     * Start propagating `datasetName`'s schema through the flow
+     * (POST /flow/tools/propagate-schema/, dataikuapi
+     * `new_schema_propagation(...).start()`). Returns the DSS future.
+     */
+    async propagateSchema(datasetName, opts = {}) {
+        const name = datasetName.trim();
+        if (name.length === 0) {
+            throw new ClientValidationError("propagateSchema requires a dataset name.", "validation_failed");
+        }
+        const pk = this.resolveProjectKey(opts.projectKey);
+        const raw = await this.client.post(`${this.flowPath(pk)}/tools/propagate-schema/`, schemaPropagationBody(pk, name, opts));
+        return dssTask(raw, "Schema propagation");
+    }
+    async propagateSchemaAndWait(datasetName, opts = {}) {
+        return this.client.futures.waitTask(await this.propagateSchema(datasetName, opts), opts);
+    }
+    /**
+     * Start generating the flow documentation (docx) from the DSS default
+     * template, an uploaded docx template, or a docx in a managed folder.
+     * The finished future's result carries the `exportId` to download.
+     */
+    async generateDocumentation(template = { kind: "default", }, projectKey) {
+        const base = `${this.flowPath(projectKey)}/documentation`;
+        return startDocumentation(this.client, {
+            default: `${base}/generate`,
+            file: `${base}/generate-with-template`,
+            folder: `${base}/generate-with-template-in-folder`,
+        }, template, "Flow documentation generation");
+    }
+    /** GET a generated flow documentation (docx) as a binary stream. */
+    async downloadDocumentation(exportId, projectKey) {
+        return this.client.stream(`${this.flowPath(projectKey)}/documentation/generated/${encodeURIComponent(exportId)}`);
+    }
+}
+/** Request body of POST /flow/tools/propagate-schema/ (pure; shared with `--plan`). */
+export function schemaPropagationBody(projectKey, datasetName, opts) {
+    return {
+        options: {
+            recipeUpdateOptions: {
+                byType: opts.recipeUpdateOptions?.byType ?? {},
+                byName: opts.recipeUpdateOptions?.byName ?? {},
+            },
+            defaultPartitionValuesByDimension: opts.defaultPartitionValuesByDimension ?? {},
+            partitionsByComputable: opts.partitionsByComputable ?? {},
+            excludedRecipes: opts.excludedRecipes ?? [],
+            markAsOkRecipes: opts.markAsOkRecipes ?? [],
+            autoRebuild: opts.autoRebuild ?? true,
+        },
+        sources: [{ projectKey, id: datasetName, },],
+    };
+}

package/dist/src/resources/futures.d.ts

@@ -4,7 +4,30 @@ export interface FutureWaitOptions {
     pollIntervalMs?: number;
     timeoutMs?: number;
 }
+/**
+ * A DSS long task as started (dataikuapi `DSSFuture.from_resp`): `jobId`
+ * addresses a running task in `futures.wait`; a task DSS finished inline comes
+ * back without one, as its final state (`hasResult`, `result`).
+ */
+export interface DssTask {
+    jobId?: string;
+    hasResult?: boolean;
+    result?: unknown;
+    [key: string]: unknown;
+}
+/** Validate a task-start response: an object whose `jobId`, when present, is a string. */
+export declare function dssTask(raw: unknown, operation: string): DssTask;
 export declare class FuturesResource extends BaseResource {
+    /**
+     * Long tasks in progress (GET /futures/): the caller's own by default,
+     * every user's with `allUsers`, running scenarios too with `withScenarios`.
+     */
+    list(opts?: {
+        allUsers?: boolean;
+        withScenarios?: boolean;
+    }): Promise<FutureState[]>;
+    /** Wait for a started task; a task DSS already finished inline is returned as is. */
+    waitTask(task: DssTask, opts?: FutureWaitOptions): Promise<FutureWaitResult | DssTask>;
     get(futureId: string, opts?: {
         timeoutMs?: number;
         noRetry?: boolean;

package/dist/src/resources/futures.js

@@ -1,6 +1,18 @@
+import { unexpectedResponseError, } from "../errors.js";
 import { FutureStateSchema, FutureWaitResultSchema, } from "../schemas.js";
 import { computeNextPollDelayMs, DEFAULT_POLL_INTERVAL_MS, DEFAULT_TIMEOUT_MS, isRequestDeadlineError, } from "../utils/polling.js";
 import { BaseResource, } from "./base.js";
+/** Validate a task-start response: an object whose `jobId`, when present, is a string. */
+export function dssTask(raw, operation) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        throw unexpectedResponseError(`${operation} returned no task state.`);
+    }
+    const state = { ...raw, };
+    if (state.jobId !== undefined && typeof state.jobId !== "string") {
+        throw unexpectedResponseError(`${operation} returned a non-string jobId.`);
+    }
+    return state;
+}
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -22,6 +34,26 @@ function waitState(state) {
     return "RUNNING";
 }
 export class FuturesResource extends BaseResource {
+    /**
+     * Long tasks in progress (GET /futures/): the caller's own by default,
+     * every user's with `allUsers`, running scenarios too with `withScenarios`.
+     */
+    async list(opts = {}) {
+        const query = new URLSearchParams({
+            allUsers: String(opts.allUsers === true),
+            withScenarios: String(opts.withScenarios === true),
+        });
+        return this.client.get(`/public/api/futures/?${query}`);
+    }
+    /** Wait for a started task; a task DSS already finished inline is returned as is. */
+    async waitTask(task, opts = {}) {
+        if (task.jobId === undefined)
+            return task;
+        return this.wait(task.jobId, {
+            pollIntervalMs: opts.pollIntervalMs,
+            timeoutMs: opts.timeoutMs,
+        });
+    }
     async get(futureId, opts = {}) {
         return this.state(futureId, {
             peek: false,

package/dist/src/resources/jobs.js

@@ -73,6 +73,36 @@ function jobLogLines(log) {
  */
 const LEGACY_STDOUT_RECORD = /^\s*stdout:/i;
 const LEGACY_STDERR_RECORD = /^\s*stderr:/i;
+/**
+ * A DSS backend log record starts with a timestamped header line
+ * (`[YYYY/MM/DD-HH:MM:SS.mmm]`); every following non-timestamped line is a
+ * continuation of that record (exception chain, JVM frames, ...).
+ */
+const DSS_RECORD_HEADER = /^\[\d{4}\/\d{2}\/\d{2}-\d{2}:\d{2}:\d{2}\.\d{3}\]/;
+const ERROR_KEYWORDS = /\b(error|failed|failure|exception|traceback)\b/i;
+/**
+ * Exception class names ending in the `Exception`/`Error` suffix (e.g.
+ * `java.lang.ClassCastException`, `ValueError`): no word boundary precedes the
+ * suffix inside a compound name, so the keyword regex alone misses them.
+ */
+const ERROR_CLASS_NAME = /\b\w*(?:Exception|Error)\b/;
+const PY_TRACEBACK_HEAD = /^\s*Traceback \(most recent call last\):$/;
+const PY_FILE_FRAME = /^\s*File "(?:[^"\\]|\\.)*", line \d+/;
+const JVM_STACK_FRAME = /^\s+at\s/;
+const JVM_MORE_FRAMES = /^\s*\.\.\. \d+ more\b/;
+/**
+ * Message payload of a DSS record line: timestamp header and the
+ * `[thread] [LEVEL] [logger] -` prefix stripped, so continuation logic can be
+ * shared between timestamped records and raw log lines.
+ */
+function dssRecordMessage(line) {
+    return line
+        .replace(/^\[\d{4}\/\d{2}\/\d{2}-\d{2}:\d{2}:\d{2}\.\d{3}\]\s?/, "")
+        .replace(/^\[[^\]]*\] \[[^\]]*\] \[[^\]]*\]\s+-\s?/, "");
+}
+function isErrorContent(line) {
+    return ERROR_KEYWORDS.test(line) || ERROR_CLASS_NAME.test(line) || PY_FILE_FRAME.test(line);
+}
 function lineMatchesLogFilter(line, filter) {
     const normalized = line.toLowerCase();
     switch (filter) {
@@ -82,17 +112,87 @@ function lineMatchesLogFilter(line, filter) {
         case "stderr":
             return normalized.includes("[null-err-") || LEGACY_STDERR_RECORD.test(line);
         case "errors":
-            return /\b(error|failed|failure|exception|traceback)\b/i.test(line);
+            return isErrorContent(line);
         case "user":
             return !/^\d{4}[-/]\d{2}[-/]\d{2}/.test(line)
                 && !normalized.includes("backend-log")
                 && !normalized.includes("debug");
     }
 }
+/**
+ * Errors filter over DSS records. A record's exception spans lines: the
+ * timestamped header carries the level/message, untimestamped continuations
+ * carry the exception chain. A record whose header matches the error keywords
+ * keeps its cause-bearing continuation lines (exception headers like
+ * `pkg.FooException: msg`, `Caused by:` chains, Python `Traceback` essentials)
+ * and drops bare JVM stack frames. A Python traceback body is tracked as state,
+ * so `File "..."` frames and the user-code source line survive even though they
+ * carry no error keyword — including when DSS re-logs each child-stderr line as
+ * its own timestamped record.
+ */
+function filterJobLogToErrors(lines) {
+    const kept = [];
+    let recordMatches = false;
+    let pyTraceback = false;
+    for (const line of lines) {
+        const isHeader = DSS_RECORD_HEADER.test(line);
+        const message = dssRecordMessage(line);
+        if (pyTraceback) {
+            if (JVM_STACK_FRAME.test(line) || JVM_MORE_FRAMES.test(line)) {
+                if (isHeader)
+                    recordMatches = false;
+                continue;
+            }
+            if (/^\s+\S/.test(message)) {
+                kept.push(line); // `File "..."` frame or user-code source line
+                if (isHeader)
+                    recordMatches = false;
+                continue;
+            }
+            if (ERROR_CLASS_NAME.test(message)) {
+                kept.push(line); // terminating exception line
+                pyTraceback = false;
+                if (isHeader)
+                    recordMatches = false;
+                continue;
+            }
+            pyTraceback = false;
+        }
+        if (isHeader) {
+            recordMatches = isErrorContent(line) || PY_FILE_FRAME.test(message);
+            if (recordMatches && (PY_TRACEBACK_HEAD.test(message) || PY_FILE_FRAME.test(message))) {
+                pyTraceback = true;
+            }
+            if (recordMatches)
+                kept.push(line);
+            continue;
+        }
+        if (PY_TRACEBACK_HEAD.test(message)) {
+            kept.push(line);
+            pyTraceback = true;
+            continue;
+        }
+        if (recordMatches
+            && !JVM_STACK_FRAME.test(line)
+            && !JVM_MORE_FRAMES.test(line)
+            && isErrorContent(line))
+            kept.push(line);
+    }
+    return kept.join("\n");
+}
+/**
+ * Filter a job log. DSS logs (any timestamped record) use the record-aware
+ * errors pass; untimestamped (non-DSS) logs keep the per-line behaviour, since
+ * no record structure can be inferred.
+ */
 function filterJobLog(log, filter) {
     if (!filter)
         return log;
-    return jobLogLines(log).filter((line) => lineMatchesLogFilter(line, filter)).join("\n");
+    const lines = jobLogLines(log);
+    if (filter !== "errors" || !lines.some((line) => DSS_RECORD_HEADER.test(line))) {
+        return lines.filter((line) => lineMatchesLogFilter(line, filter)).join("\n");
+    }
+    return filterJobLogToErrors(lines);
 }
 function limitJobLog(log, maxLines) {
     if (!log)

package/dist/src/resources/metrics.d.ts

@@ -37,6 +37,16 @@ export declare class MetricsResource extends BaseResource {
     getDatasetMetrics(datasetName: string, projectKey?: string): Promise<MetricValues>;
     /** Compute the dataset metrics configured in DSS for the default partition. */
     computeDatasetMetrics(datasetName: string, projectKey?: string): Promise<MetricComputationReport>;
+    /**
+     * Run the dataset's checks (POST /actions/runChecks/{?partitions}). Without
+     * `checks` DSS runs the checks configured on the dataset; with `checks` it
+     * runs those definitions instead (body `{"checks": [...]}`).
+     */
+    runDatasetChecks(datasetName: string, opts?: {
+        projectKey?: string;
+        partitions?: string;
+        checks?: unknown[];
+    }): Promise<MetricComputationReport>;
     /** Get the last metric values for a managed folder. */
     getFolderMetrics(folderId: string, projectKey?: string): Promise<MetricValues>;
     /** Get the metric history for a dataset's global partition. */