dataiku-sdk 0.5.1 → 0.6.1

package/dist/src/errors.js

@@ -71,6 +71,18 @@ export function classifyDataikuError(status, body) {
             retryHint: "Requested object was not found. Verify projectKey and object identifiers before retrying.",
         };
     }
+    const isSqlEngineValidation = status >= 400
+        && (lowerBody.includes("column_not_found")
+            || lowerBody.includes("table_not_found")
+            || lowerBody.includes("no_such_table")
+            || lowerBody.includes("column does not exist"));
+    if (isSqlEngineValidation) {
+        return {
+            category: "validation",
+            retryable: false,
+            retryHint: "Athena/SQL engine rejected the query: check column names, table names, and schema with dss dataset schema or dss connection tables. Do not retry unchanged SQL.",
+        };
+    }
     const isServerValidationLike = status >= 500
         && (lowerBody.includes("invalid")
             || lowerBody.includes("validation")

package/dist/src/index.d.ts

@@ -3,19 +3,19 @@ export { type CredentialValidationOptions, type CredentialValidationResult, vali
 export { deleteCredentials, type DssCredentials, getConfigDir, getCredentialsPath, loadCredentials, maskApiKey, saveCredentials, } from "./config.js";
 export { DataikuError, type DataikuErrorCategory, type DataikuErrorTaxonomy, type DataikuRetryMetadata, } from "./errors.js";
 export { CodeEnvsResource, } from "./resources/code-envs.js";
-export { ConnectionsResource, } from "./resources/connections.js";
+export { type ConnectionSchemaListOptions, ConnectionsResource, type ConnectionTableListOptions, } from "./resources/connections.js";
 export { DashboardsResource, } from "./resources/dashboards.js";
 export { DataQualityResource, } from "./resources/data-quality.js";
-export { DatasetsResource, } from "./resources/datasets.js";
+export { type DatasetBuildValidationResult, type DatasetCloneOptions, type DatasetCloneResult, type DatasetSchemaColumnInput, DatasetsResource, } from "./resources/datasets.js";
 export { type FlowZoneItemInput, FlowZonesResource, } from "./resources/flow-zones.js";
 export { FoldersResource, } from "./resources/folders.js";
 export { FuturesResource, } from "./resources/futures.js";
 export { InsightsResource, } from "./resources/insights.js";
-export { computeNextPollDelayMs, type JobBuildTargetType, JobsResource, } from "./resources/jobs.js";
+export { computeNextPollDelayMs, type JobBuildAndWaitOptions, type JobBuildOptions, type JobBuildTarget, type JobBuildTargetType, type JobLogFilter, type JobLogProgress, type JobLogSummary, JobsResource, parseJobLogProgress, } from "./resources/jobs.js";
 export { NotebooksResource, } from "./resources/notebooks.js";
 export { type FlowMapResult, ProjectsResource, } from "./resources/projects.js";
-export { RecipesResource, } from "./resources/recipes.js";
-export { ScenariosResource, } from "./resources/scenarios.js";
+export { type RecipeCloneOptions, type RecipeCloneResult, type RecipeGraphReference, type RecipeGraphValidationResult, type RecipeRunOptions, type RecipeRunOutput, type RecipeRunResult, RecipesResource, } from "./resources/recipes.js";
+export { normalizeScenarioUpdateData, SCENARIO_CANONICAL_EDITABLE_FIELDS, type ScenarioFieldChange, type ScenarioFieldMismatch, ScenariosResource, type ScenarioUpdateNormalization, type ScenarioUpdatePreview, scenarioUpdatePreview, type ScenarioUpdateResult, } from "./resources/scenarios.js";
 export { SqlResource, } from "./resources/sql.js";
 export { VariablesResource, } from "./resources/variables.js";
 export { WikiResource, } from "./resources/wiki.js";

package/dist/src/index.js

@@ -15,11 +15,11 @@ export { FlowZonesResource, } from "./resources/flow-zones.js";
 export { FoldersResource, } from "./resources/folders.js";
 export { FuturesResource, } from "./resources/futures.js";
 export { InsightsResource, } from "./resources/insights.js";
-export { computeNextPollDelayMs, JobsResource, } from "./resources/jobs.js";
+export { computeNextPollDelayMs, JobsResource, parseJobLogProgress, } from "./resources/jobs.js";
 export { NotebooksResource, } from "./resources/notebooks.js";
 export { ProjectsResource, } from "./resources/projects.js";
 export { RecipesResource, } from "./resources/recipes.js";
-export { ScenariosResource, } from "./resources/scenarios.js";
+export { normalizeScenarioUpdateData, SCENARIO_CANONICAL_EDITABLE_FIELDS, ScenariosResource, scenarioUpdatePreview, } from "./resources/scenarios.js";
 export { SqlResource, } from "./resources/sql.js";
 export { VariablesResource, } from "./resources/variables.js";
 export { WikiResource, } from "./resources/wiki.js";

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

@@ -1,5 +1,13 @@
 import type { ConnectionSummary } from "../schemas.js";
 import { BaseResource } from "./base.js";
+export interface ConnectionSchemaListOptions {
+    connection: string;
+    projectKey?: string;
+}
+export interface ConnectionTableListOptions extends ConnectionSchemaListOptions {
+    catalog?: string;
+    schema?: string;
+}
 export declare class ConnectionsResource extends BaseResource {
     /**
      * Returns sorted list of all connection names visible to the current user.
@@ -19,4 +27,6 @@ export declare class ConnectionsResource extends BaseResource {
         mode?: "fast" | "rich";
         projectKey?: string;
     }): Promise<ConnectionSummary[]>;
+    schemas(opts: ConnectionSchemaListOptions): Promise<string[]>;
+    tables(opts: ConnectionTableListOptions): Promise<Record<string, unknown>>;
 }

package/dist/src/resources/connections.js

@@ -79,4 +79,20 @@ export class ConnectionsResource extends BaseResource {
         }
         return inferRichConnectionsFromDatasets(this.client, projectEnc);
     }
+    async schemas(opts) {
+        const pk = this.resolveProjectKey(opts.projectKey);
+        const params = new URLSearchParams();
+        params.set("connectionName", opts.connection);
+        return this.client.get(`/public/api/projects/${encodeURIComponent(pk)}/datasets/tables-import/actions/list-schemas?${params.toString()}`);
+    }
+    async tables(opts) {
+        const pk = this.resolveProjectKey(opts.projectKey);
+        const params = new URLSearchParams();
+        params.set("connectionName", opts.connection);
+        if (opts.catalog !== undefined)
+            params.set("catalogName", opts.catalog);
+        if (opts.schema !== undefined)
+            params.set("schemaName", opts.schema);
+        return this.client.get(`/public/api/projects/${encodeURIComponent(pk)}/datasets/tables-import/actions/list-tables?${params.toString()}`);
+    }
 }

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

@@ -1,5 +1,34 @@
 import { BaseResource } from "./base.js";
 import type { DatasetCreateOptions, DatasetDetails, DatasetSchema, DatasetSummary } from "../schemas.js";
+export interface DatasetBuildValidationResult {
+    valid: boolean;
+    datasetName: string;
+    projectKey: string;
+    type: string | null;
+    path: string | null;
+    formatType: string | null;
+    warnings: string[];
+}
+export interface DatasetSchemaColumnInput {
+    name: string;
+    type: string;
+    comment?: string;
+}
+export interface DatasetCloneOptions {
+    projectKey?: string;
+    path?: string;
+    table?: string;
+    metastoreTableName?: string;
+    overrides?: Record<string, unknown>;
+    allowSamePath?: boolean;
+}
+export interface DatasetCloneResult {
+    source: string;
+    target: string;
+    projectKey: string;
+    created: Record<string, unknown>;
+    settings: Record<string, unknown>;
+}
 /**
  * Compare streamed TSV header columns against a known dataset schema.
  * Returns an array of warning strings (empty if all columns match).
@@ -7,6 +36,7 @@ import type { DatasetCreateOptions, DatasetDetails, DatasetSchema, DatasetSummar
 export declare function validateStreamColumns(headerRow: string[], expectedColumns: {
     name: string;
 }[]): string[];
+export declare function buildDatasetCloneSettings(source: DatasetDetails, targetName: string, projectKey: string, opts: DatasetCloneOptions): Record<string, unknown>;
 export declare class DatasetsResource extends BaseResource {
     /** List all datasets in a project. */
     list(projectKey?: string): Promise<DatasetSummary[]>;
@@ -14,6 +44,8 @@ export declare class DatasetsResource extends BaseResource {
     get(datasetName: string, projectKey?: string): Promise<DatasetDetails>;
     /** Get dataset schema (column names and types). */
     schema(datasetName: string, projectKey?: string): Promise<DatasetSchema>;
+    /** Replace dataset schema columns directly through the schema endpoint. */
+    updateSchema(datasetName: string, columns: DatasetSchemaColumnInput[], projectKey?: string): Promise<void>;
     /**
      * Preview dataset data as CSV text.
      * Streams TSV from the API, converts to CSV, and returns up to `maxRows`
@@ -51,6 +83,10 @@ export declare class DatasetsResource extends BaseResource {
      * from existing datasets on the same connection.
      */
     create(opts: DatasetCreateOptions): Promise<Record<string, unknown>>;
+    /** Validate common build blockers before running a dataset build. */
+    validateBuildSettings(datasetName: string, projectKey?: string): Promise<DatasetBuildValidationResult>;
+    /** Clone dataset settings, preserving connection/storage, format, and schema fields. */
+    clone(sourceName: string, targetName: string, opts?: DatasetCloneOptions): Promise<DatasetCloneResult>;
     /** Update a dataset by deep-merging a patch into the current definition. */
     update(datasetName: string, data: Record<string, unknown>, projectKey?: string): Promise<void>;
     /** Delete a dataset. */

package/dist/src/resources/datasets.js

@@ -306,6 +306,38 @@ function buildDatasetCreateBody(opts) {
         managed: opts.managed ?? true,
     };
 }
+export function buildDatasetCloneSettings(source, targetName, projectKey, opts) {
+    const params = {
+        ...source.params,
+        ...(opts.path !== undefined ? { path: opts.path, } : {}),
+        ...(opts.table !== undefined ? { table: opts.table, mode: "table", } : {}),
+        ...(opts.metastoreTableName !== undefined
+            ? { metastoreTableName: opts.metastoreTableName, }
+            : {}),
+    };
+    const cloned = {
+        name: targetName,
+        projectKey,
+        ...(source.type !== undefined ? { type: source.type, } : {}),
+        ...(source.managed !== undefined ? { managed: source.managed, } : {}),
+        ...(Object.keys(params).length > 0 ? { params, } : {}),
+        ...(source.formatType !== undefined ? { formatType: source.formatType, } : {}),
+        ...(source.formatParams !== undefined ? { formatParams: source.formatParams, } : {}),
+        ...(source.schema !== undefined ? { schema: source.schema, } : {}),
+    };
+    const settings = opts.overrides ? deepMerge(cloned, opts.overrides) : cloned;
+    const settingsParams = settings.params && typeof settings.params === "object" && !Array.isArray(settings.params)
+        ? settings.params
+        : {};
+    const sourcePath = typeof source.params?.path === "string" ? source.params.path : undefined;
+    if (opts.allowSamePath !== true
+        && source.managed === true
+        && sourcePath !== undefined
+        && settingsParams.path === sourcePath) {
+        throw new Error(`Refusing to clone managed dataset "${source.name}" with the same storage path. Pass a new path or allowSamePath: true.`);
+    }
+    return settings;
+}
 // ---------------------------------------------------------------------------
 // Resource
 // ---------------------------------------------------------------------------
@@ -327,6 +359,11 @@ export class DatasetsResource extends BaseResource {
         const raw = await this.client.get(`/public/api/projects/${this.enc(projectKey)}/datasets/${dsEnc}/schema`);
         return this.client.safeParse(DatasetSchemaSchema, raw, "datasets.schema");
     }
+    /** Replace dataset schema columns directly through the schema endpoint. */
+    async updateSchema(datasetName, columns, projectKey) {
+        const dsEnc = encodeURIComponent(datasetName);
+        await this.client.put(`/public/api/projects/${this.enc(projectKey)}/datasets/${dsEnc}/schema`, { columns, });
+    }
     /**
      * Preview dataset data as CSV text.
      * Streams TSV from the API, converts to CSV, and returns up to `maxRows`
@@ -444,6 +481,49 @@ export class DatasetsResource extends BaseResource {
             return this.client.post(`/public/api/projects/${enc}/datasets/`, body);
         }
     }
+    /** Validate common build blockers before running a dataset build. */
+    async validateBuildSettings(datasetName, projectKey) {
+        const pk = this.resolveProjectKey(projectKey);
+        const details = await this.get(datasetName, pk);
+        const params = details.params ?? {};
+        const type = details.type ?? null;
+        const path = typeof params.path === "string" && params.path.trim().length > 0
+            ? params.path
+            : null;
+        const table = typeof params.table === "string" && params.table.trim().length > 0
+            ? params.table
+            : null;
+        const normalizedType = (type ?? "").toLowerCase();
+        const fileBacked = !table
+            && (normalizedType.includes("filesystem")
+                || normalizedType.includes("uploaded")
+                || normalizedType.includes("s3")
+                || path !== null);
+        const formatType = details.formatType ?? null;
+        const warnings = [];
+        if (fileBacked && !path) {
+            warnings.push("File-backed dataset has no writable storage path configured.");
+        }
+        if (fileBacked && !formatType) {
+            warnings.push("File-backed dataset has no formatType configured.");
+        }
+        return {
+            valid: warnings.length === 0,
+            datasetName,
+            projectKey: pk,
+            type,
+            path,
+            formatType,
+            warnings,
+        };
+    }
+    /** Clone dataset settings, preserving connection/storage, format, and schema fields. */
+    async clone(sourceName, targetName, opts = {}) {
+        const pk = this.resolveProjectKey(opts.projectKey);
+        const settings = buildDatasetCloneSettings(await this.get(sourceName, pk), targetName, pk, opts);
+        const created = await this.client.post(`/public/api/projects/${encodeURIComponent(pk)}/datasets/`, settings);
+        return { source: sourceName, target: targetName, projectKey: pk, created, settings, };
+    }
     /** Update a dataset by deep-merging a patch into the current definition. */
     async update(datasetName, data, projectKey) {
         const dsEnc = encodeURIComponent(datasetName);

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

@@ -1,6 +1,42 @@
 import type { BuildMode, JobSummary, JobWaitResult } from "../schemas.js";
 import { BaseResource } from "./base.js";
 export type JobBuildTargetType = "DATASET" | "MANAGED_FOLDER";
+export type JobLogFilter = "stdout" | "stderr" | "user" | "errors";
+export interface JobLogProgress {
+    lastProgressLine?: string;
+    doneLine?: string;
+    counters: Record<string, number>;
+    rowsPerMinute?: number;
+}
+export interface JobLogSummary {
+    state: string;
+    lineCount: number;
+    lines: string[];
+    progress?: JobLogProgress;
+}
+export interface JobBuildTarget {
+    id: string;
+    type?: JobBuildTargetType;
+    projectKey?: string;
+    partition?: string;
+}
+export interface JobBuildOptions {
+    buildMode?: BuildMode;
+    autoUpdateSchema?: boolean;
+    projectKey?: string;
+    targetType?: JobBuildTargetType;
+    partition?: string;
+}
+export interface JobBuildAndWaitOptions extends JobBuildOptions {
+    activity?: string;
+    includeLogs?: boolean;
+    maxLogLines?: number;
+    pollIntervalMs?: number;
+    timeoutMs?: number;
+    logFilter?: JobLogFilter;
+    logId?: string;
+    summary?: boolean;
+}
 interface ComputeNextPollDelayMsOptions {
     pollCount: number;
     baseIntervalMs: number;
@@ -12,6 +48,7 @@ interface ComputeNextPollDelayMsOptions {
  * capped at MAX_POLL_INTERVAL_MS (or baseIntervalMs if it's larger).
  */
 export declare function computeNextPollDelayMs({ pollCount, baseIntervalMs, adaptiveEnabled, }: ComputeNextPollDelayMsOptions): number;
+export declare function parseJobLogProgress(log: string, elapsedMs?: number): JobLogProgress | undefined;
 export declare class JobsResource extends BaseResource {
     /** List jobs in a project. */
     list(projectKey?: string): Promise<JobSummary[]>;
@@ -24,36 +61,41 @@ export declare class JobsResource extends BaseResource {
      */
     log(jobId: string, opts?: {
         activity?: string;
+        logId?: string;
         maxLogLines?: number;
         projectKey?: string;
     }): Promise<string>;
+    logFromUrl(logUrl: string, opts?: {
+        maxLogLines?: number;
+    }): Promise<string>;
     /**
-     * Start a build job for a dataset or managed folder.
+     * Start a build job for one or more dataset or managed-folder outputs.
      * Returns the new job's ID.
      */
-    build(targetId: string, opts?: {
-        buildMode?: BuildMode;
-        autoUpdateSchema?: boolean;
-        projectKey?: string;
-        targetType?: JobBuildTargetType;
-    }): Promise<{
+    buildOutputs(targets: JobBuildTarget[], opts?: JobBuildOptions): Promise<{
+        jobId: string;
+    }>;
+    /**
+     * Start a build job for a single dataset or managed folder.
+     * Returns the new job's ID.
+     */
+    build(targetId: string, opts?: JobBuildOptions): Promise<{
         jobId: string;
     }>;
+    /**
+     * Build one or more dataset or managed-folder outputs and wait for a terminal state.
+     * Combines {@link buildOutputs} then {@link wait}.
+     */
+    buildAndWaitOutputs(targets: JobBuildTarget[], opts?: JobBuildAndWaitOptions): Promise<JobWaitResult & {
+        logSummary?: JobLogSummary;
+    }>;
     /**
      * Build a dataset or managed folder and wait for the job to reach a terminal state.
      * Combines {@link build} then {@link wait}.
      */
-    buildAndWait(targetId: string, opts?: {
-        buildMode?: BuildMode;
-        autoUpdateSchema?: boolean;
-        activity?: string;
-        includeLogs?: boolean;
-        maxLogLines?: number;
-        pollIntervalMs?: number;
-        timeoutMs?: number;
-        projectKey?: string;
-        targetType?: JobBuildTargetType;
-    }): Promise<JobWaitResult>;
+    buildAndWait(targetId: string, opts?: JobBuildAndWaitOptions): Promise<JobWaitResult & {
+        logSummary?: JobLogSummary;
+    }>;
     /**
      * Poll a job until it reaches a terminal state or times out.
      *
@@ -65,11 +107,16 @@ export declare class JobsResource extends BaseResource {
     wait(jobId: string, opts?: {
         activity?: string;
         includeLogs?: boolean;
+        logFilter?: JobLogFilter;
+        logId?: string;
         maxLogLines?: number;
         pollIntervalMs?: number;
+        summary?: boolean;
         timeoutMs?: number;
         projectKey?: string;
-    }): Promise<JobWaitResult>;
+    }): Promise<JobWaitResult & {
+        logSummary?: JobLogSummary;
+    }>;
     /** Request a job abort. */
     abort(jobId: string, projectKey?: string): Promise<void>;
 }

package/dist/src/resources/jobs.js

@@ -35,6 +35,129 @@ export function computeNextPollDelayMs({ pollCount, baseIntervalMs, adaptiveEnab
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
+const DEFAULT_TARGET_PARTITION = "NP";
+function jobBuildOutput(target, defaultProjectKey, defaultPartition, defaultTargetType) {
+    const targetType = target.type ?? defaultTargetType ?? "DATASET";
+    const projectKey = target.projectKey ?? defaultProjectKey;
+    const partition = target.partition ?? defaultPartition;
+    const output = { projectKey, id: target.id, type: targetType, };
+    if (targetType === "DATASET") {
+        if (partition !== undefined)
+            output.partition = partition;
+    }
+    else {
+        output.targetManagedFolderProjectKey = projectKey;
+        output.targetManagedFolder = target.id;
+        output.targetPartition = partition ?? DEFAULT_TARGET_PARTITION;
+    }
+    return output;
+}
+function jobBuildDefinition(targets, defaultProjectKey, opts) {
+    if (targets.length === 0) {
+        throw new Error("At least one build target is required.");
+    }
+    const payload = {
+        outputs: targets.map((target) => jobBuildOutput(target, defaultProjectKey, opts?.partition, opts?.targetType)),
+        type: opts?.buildMode ?? "NON_RECURSIVE_FORCED_BUILD",
+    };
+    if (opts?.autoUpdateSchema
+        && targets.every((target) => (target.type ?? opts?.targetType ?? "DATASET") === "DATASET")) {
+        payload.autoUpdateSchemaBeforeEachRecipeRun = true;
+    }
+    return payload;
+}
+function jobLogLines(log) {
+    return log.split(/\r?\n/).map((line) => line.trimEnd());
+}
+function lineMatchesLogFilter(line, filter) {
+    const normalized = line.toLowerCase();
+    switch (filter) {
+        case "stdout":
+            return normalized.includes("stdout") || line.startsWith(">>> ");
+        case "stderr":
+            return normalized.includes("stderr");
+        case "errors":
+            return /\b(error|failed|failure|exception|traceback)\b/i.test(line);
+        case "user":
+            return !/^\d{4}[-/]\d{2}[-/]\d{2}/.test(line)
+                && !normalized.includes("backend-log")
+                && !normalized.includes("debug");
+    }
+}
+function filterJobLog(log, filter) {
+    if (!filter)
+        return log;
+    return jobLogLines(log).filter((line) => lineMatchesLogFilter(line, filter)).join("\n");
+}
+function limitJobLog(log, maxLines) {
+    if (!log)
+        return "";
+    const limit = maxLines ?? DEFAULT_MAX_LOG_LINES;
+    if (limit === 0 || limit === -1)
+        return log;
+    const lines = log.split(/\r?\n/);
+    const hasTrailingLineBreak = lines.length > 0 && lines[lines.length - 1] === "";
+    if (hasTrailingLineBreak)
+        lines.pop();
+    if (lines.length <= limit)
+        return log;
+    const tail = lines.slice(-Math.max(1, limit)).join("\n");
+    return hasTrailingLineBreak ? `${tail}\n` : tail;
+}
+function parsedCounterValue(value) {
+    return Number(value.replace(/,/g, ""));
+}
+export function parseJobLogProgress(log, elapsedMs) {
+    const counters = {};
+    let lastProgressLine;
+    let doneLine;
+    for (const line of jobLogLines(log)) {
+        const normalized = line.trim();
+        if (!normalized)
+            continue;
+        const lower = normalized.toLowerCase();
+        let matched = false;
+        for (const match of normalized.matchAll(/\b(scanned|matched|joined|written|emitted)\s+([0-9][0-9,]*)/gi)) {
+            counters[match[1].toLowerCase()] = parsedCounterValue(match[2]);
+            matched = true;
+        }
+        const written = normalized.match(/\b([0-9][0-9,]*)\s+rows\s+successfully\s+written\b/i);
+        if (written) {
+            counters.written = parsedCounterValue(written[1]);
+            doneLine = normalized;
+            matched = true;
+        }
+        if (lower.includes("done!")) {
+            doneLine = normalized;
+            matched = true;
+        }
+        if (matched)
+            lastProgressLine = normalized;
+    }
+    if (lastProgressLine === undefined && doneLine === undefined)
+        return undefined;
+    const writtenRows = counters.written ?? counters.emitted;
+    const rowsPerMinute = writtenRows !== undefined && elapsedMs !== undefined && elapsedMs > 0
+        ? writtenRows / (elapsedMs / 60_000)
+        : undefined;
+    return {
+        ...(lastProgressLine ? { lastProgressLine, } : {}),
+        ...(doneLine ? { doneLine, } : {}),
+        counters,
+        ...(rowsPerMinute !== undefined ? { rowsPerMinute, } : {}),
+    };
+}
+function summarizeJobLog(state, log, maxLines, elapsedMs) {
+    const lines = jobLogLines(log).map((line) => line.trim()).filter((line) => line.length > 0);
+    const summaryLines = lines.slice(-Math.max(1, maxLines));
+    const progress = parseJobLogProgress(log, elapsedMs);
+    return {
+        state,
+        lineCount: lines.length,
+        lines: summaryLines,
+        ...(progress ? { progress, } : {}),
+    };
+}
 export class JobsResource extends BaseResource {
     /** List jobs in a project. */
     async list(projectKey) {
@@ -55,57 +178,72 @@ export class JobsResource extends BaseResource {
     async log(jobId, opts) {
         const jobEnc = encodeURIComponent(jobId);
         const query = opts?.activity ? `?activity=${encodeURIComponent(opts.activity)}` : "";
-        const log = await this.client.getText(`/public/api/projects/${this.enc(opts?.projectKey)}/jobs/${jobEnc}/log/${query}`);
-        if (!log)
-            return "";
-        const limit = opts?.maxLogLines ?? DEFAULT_MAX_LOG_LINES;
-        if (limit === 0 || limit === -1) {
-            return log;
-        }
-        const lines = log.split("\n");
-        if (lines.length > limit) {
-            return lines.slice(-limit).join("\n");
+        // DSS cat-activity-log URLs require a browser session; API-key callers must use the public log endpoint.
+        const path = `/public/api/projects/${this.enc(opts?.projectKey)}/jobs/${jobEnc}/log/${query}`;
+        const log = await this.client.getText(path);
+        return limitJobLog(log, opts?.maxLogLines);
+    }
+    async logFromUrl(logUrl, opts) {
+        const parsed = new URL(logUrl, "http://dss.local");
+        const projectKey = parsed.searchParams.get("projectKey") ?? undefined;
+        const jobId = parsed.searchParams.get("jobId") ?? undefined;
+        const activity = parsed.searchParams.get("activityId") ?? undefined;
+        if (!projectKey || !jobId || !activity) {
+            throw new Error("Log URL must include projectKey, jobId, and activityId query parameters.");
         }
-        return log;
+        return this.log(jobId, { activity, projectKey, maxLogLines: opts?.maxLogLines, });
     }
     /**
-     * Start a build job for a dataset or managed folder.
+     * Start a build job for one or more dataset or managed-folder outputs.
      * Returns the new job's ID.
      */
-    async build(targetId, opts) {
+    async buildOutputs(targets, opts) {
         const pk = this.resolveProjectKey(opts?.projectKey);
         const enc = encodeURIComponent(pk);
-        const targetType = opts?.targetType ?? "DATASET";
-        const jobDef = {
-            outputs: [{ projectKey: pk, id: targetId, type: targetType, },],
-            type: opts?.buildMode ?? "NON_RECURSIVE_FORCED_BUILD",
-        };
-        if (opts?.autoUpdateSchema && targetType === "DATASET") {
-            jobDef.autoUpdateSchemaBeforeEachRecipeRun = true;
-        }
+        const jobDef = jobBuildDefinition(targets, pk, opts);
         const job = await this.client.post(`/public/api/projects/${enc}/jobs/`, jobDef);
         return { jobId: job.id, };
     }
     /**
-     * Build a dataset or managed folder and wait for the job to reach a terminal state.
-     * Combines {@link build} then {@link wait}.
+     * Start a build job for a single dataset or managed folder.
+     * Returns the new job's ID.
      */
-    async buildAndWait(targetId, opts) {
-        const { jobId, } = await this.build(targetId, {
-            buildMode: opts?.buildMode,
-            autoUpdateSchema: opts?.autoUpdateSchema,
-            projectKey: opts?.projectKey,
-            targetType: opts?.targetType,
-        });
+    async build(targetId, opts) {
+        return this.buildOutputs([{
+                id: targetId,
+                type: opts?.targetType,
+                partition: opts?.partition,
+            },], opts);
+    }
+    /**
+     * Build one or more dataset or managed-folder outputs and wait for a terminal state.
+     * Combines {@link buildOutputs} then {@link wait}.
+     */
+    async buildAndWaitOutputs(targets, opts) {
+        const { jobId, } = await this.buildOutputs(targets, opts);
         return this.wait(jobId, {
             activity: opts?.activity,
             includeLogs: opts?.includeLogs,
+            logFilter: opts?.logFilter,
+            logId: opts?.logId,
             maxLogLines: opts?.maxLogLines,
             pollIntervalMs: opts?.pollIntervalMs,
+            summary: opts?.summary,
             timeoutMs: opts?.timeoutMs,
             projectKey: opts?.projectKey,
         });
     }
+    /**
+     * Build a dataset or managed folder and wait for the job to reach a terminal state.
+     * Combines {@link build} then {@link wait}.
+     */
+    async buildAndWait(targetId, opts) {
+        return this.buildAndWaitOutputs([{
+                id: targetId,
+                type: opts?.targetType,
+                partition: opts?.partition,
+            },], opts);
+    }
     /**
      * Poll a job until it reaches a terminal state or times out.
      *
@@ -133,12 +271,20 @@ export class JobsResource extends BaseResource {
             if (isTerminalState(state)) {
                 const success = isSuccessfulTerminalState(state);
                 let log;
-                if (opts?.includeLogs) {
-                    log = await this.log(jobId, {
+                let logSummary;
+                if (opts?.includeLogs || opts?.summary) {
+                    const rawLog = await this.log(jobId, {
                         activity: opts.activity,
-                        maxLogLines: opts.maxLogLines,
+                        maxLogLines: opts.summary ? 0 : opts.maxLogLines,
+                        logId: opts.logId,
                         projectKey: opts.projectKey,
                     });
+                    const filteredLog = filterJobLog(rawLog, opts.logFilter);
+                    if (opts.includeLogs)
+                        log = limitJobLog(filteredLog, opts.maxLogLines);
+                    if (opts.summary) {
+                        logSummary = summarizeJobLog(state, filteredLog, opts.maxLogLines ?? 20, elapsedMs);
+                    }
                 }
                 return {
                     success,
@@ -154,6 +300,7 @@ export class JobsResource extends BaseResource {
                         total: gs.total ?? null,
                     },
                     ...(log !== undefined ? { log, } : {}),
+                    ...(logSummary !== undefined ? { logSummary, } : {}),
                 };
             }
             // Timeout — return failure result, don't throw