dataiku-sdk 3.2.0 → 3.4.0

package/dist/src/client.d.ts

@@ -8,19 +8,26 @@ import { CodeEnvsResource } from "./resources/code-envs.js";
 import { ConnectionsResource } from "./resources/connections.js";
 import { ContinuousActivitiesResource } from "./resources/continuous-activities.js";
 import { DashboardsResource } from "./resources/dashboards.js";
+import { DataCollectionsResource } from "./resources/data-collections.js";
 import { DataQualityResource } from "./resources/data-quality.js";
 import { DatasetsResource } from "./resources/datasets.js";
 import { DiscussionsResource } from "./resources/discussions.js";
 import { FlowZonesResource } from "./resources/flow-zones.js";
 import { FoldersResource } from "./resources/folders.js";
 import { FuturesResource } from "./resources/futures.js";
+import { GroupsResource } from "./resources/groups.js";
 import { InsightsResource } from "./resources/insights.js";
 import { JobsResource } from "./resources/jobs.js";
+import { KnowledgeBanksResource } from "./resources/knowledge-banks.js";
+import { LlmsResource } from "./resources/llms.js";
+import { MacrosResource } from "./resources/macros.js";
 import { MeaningsResource } from "./resources/meanings.js";
 import { MetricsResource } from "./resources/metrics.js";
 import { MlTasksResource } from "./resources/ml-tasks.js";
 import { ModelEvaluationStoresResource } from "./resources/model-evaluation-stores.js";
 import { NotebooksResource } from "./resources/notebooks.js";
+import { PluginsResource } from "./resources/plugins.js";
+import { ProjectFoldersResource } from "./resources/project-folders.js";
 import { ProjectGitResource } from "./resources/project-git.js";
 import { ProjectLibraryResource } from "./resources/project-library.js";
 import { ProjectsResource } from "./resources/projects.js";
@@ -30,10 +37,52 @@ import { ScenariosResource } from "./resources/scenarios.js";
 import { SqlResource } from "./resources/sql.js";
 import { StatisticsResource } from "./resources/statistics.js";
 import { StreamingEndpointsResource } from "./resources/streaming-endpoints.js";
+import { UsersResource } from "./resources/users.js";
 import { VariablesResource } from "./resources/variables.js";
 import { WebappsResource } from "./resources/webapps.js";
 import { WikiResource } from "./resources/wiki.js";
 import { WorkspacesResource } from "./resources/workspaces.js";
+/** One part of a {@link DataikuClient.uploadForm} multipart/form-data body. */
+export interface UploadFormPart {
+    /** Form field name. */
+    name: string;
+    /** Text field value. Mutually exclusive with `blob`/`fileName` file parts. */
+    value?: string;
+    /** File content. Omit (or null) together with `fileName` for a zero-byte file part. */
+    blob?: Blob | null;
+    /** Filename for file parts. */
+    fileName?: string;
+}
+/**
+ * Multipart part modes for {@link DataikuClient.uploadForm}:
+ * - `value`: a form text field;
+ * - neither `blob` nor `fileName`: a filename-less, zero-length field part —
+ *   the official Python client's files={"file": (None, None)} shape required
+ *   by the managed-folder MLflow import (a Blob would add `filename=`, even
+ *   when empty);
+ * - `blob` (optionally with `fileName`): a file part.
+ */
+/** Per-call overrides for {@link DataikuClient.get}. */
+export interface DataikuGetOptions {
+    /**
+     * TOTAL duration budget in milliseconds for this call, measured from call
+     * start: it bounds every retry attempt's fetch, the backoff sleeps between
+     * attempts, and the response body read. When the budget is exhausted the
+     * request is aborted and a timeout DataikuError is thrown. The client-level
+     * requestTimeoutMs still caps each attempt and buffered body read; this
+     * budget may shorten those limits but never extends them.
+     */
+    timeoutMs?: number;
+    /**
+     * Issue exactly one transport attempt (no retries). Independent of
+     * `timeoutMs`: when both are supplied the total budget above still applies
+     * and aborts the attempt; when no budget is supplied the attempt is capped
+     * by the client-level `requestTimeoutMs`. Wait loops use this for the one
+     * observation whose wait budget is already spent, so it still reaches the
+     * server once instead of failing before any transport attempt.
+     */
+    noRetry?: boolean;
+}
 export interface DataikuClientTraceEvent {
     type: "trace";
     phase: "request" | "response" | "error";
@@ -72,9 +121,9 @@ export interface DataikuClientConfig {
     /** Max retry attempts for idempotent requests (default 4, capped at 10) */
     retryMaxAttempts?: number;
     /**
-     * Maximum bytes buffered from a single response body by the text/JSON
-     * consumer methods (default 50 MiB). Responses larger than this are
-     * rejected with a DataikuError after the stream is cancelled.
+     * Maximum bytes retained from a single response body by text/JSON consumers
+     * (default 50 MiB). Oversized successful responses are rejected. Error
+     * responses retain a bounded prefix with DataikuError.bodyTruncated=true.
      */
     maxResponseBodyBytes?: number;
     /** Emit HTTP request/response trace events. Defaults to JSONL on stderr when verbose is true. */
@@ -139,6 +188,14 @@ export declare class DataikuClient {
     private mlTasksResource?;
     private savedModelsResource?;
     private modelEvaluationStoresResource?;
+    private projectFoldersResource?;
+    private dataCollectionsResource?;
+    private llmsResource?;
+    private knowledgeBanksResource?;
+    private macrosResource?;
+    private pluginsResource?;
+    private usersResource?;
+    private groupsResource?;
     get projects(): ProjectsResource;
     get datasets(): DatasetsResource;
     get dashboards(): DashboardsResource;
@@ -175,6 +232,14 @@ export declare class DataikuClient {
     get mlTasks(): MlTasksResource;
     get savedModels(): SavedModelsResource;
     get modelEvaluationStores(): ModelEvaluationStoresResource;
+    get projectFolders(): ProjectFoldersResource;
+    get dataCollections(): DataCollectionsResource;
+    get llms(): LlmsResource;
+    get knowledgeBanks(): KnowledgeBanksResource;
+    get macros(): MacrosResource;
+    get plugins(): PluginsResource;
+    get users(): UsersResource;
+    get groups(): GroupsResource;
     constructor(config?: DataikuClientConfig);
     /**
      * Canonical request base URL: the exact prefix every HTTP verb concatenates
@@ -189,7 +254,7 @@ export declare class DataikuClient {
      */
     getMaxResponseBodyBytes(): number;
     resolveProjectKey(paramValue?: string): string;
-    get<T = unknown>(path: string): Promise<T>;
+    get<T = unknown>(path: string, options?: DataikuGetOptions): Promise<T>;
     /**
      * GET returning the parsed JSON body plus selected response metadata
      * (documented DSS version headers, server date, request id). Authorization
@@ -239,10 +304,32 @@ export declare class DataikuClient {
      * {@link getText} (byte cap `maxResponseBodyBytes`, request deadline).
      */
     postText(path: string, body?: unknown): Promise<string>;
+    /** Send raw file contents through the shared authenticated transport. */
+    postRawBody(path: string, body: string | Uint8Array): Promise<void>;
+    /** Git endpoints require Basic API-key authentication, unlike the bearer API. */
+    requestGit(method: string, path: string, body?: unknown, deadlineAt?: number, noRetry?: boolean): Promise<Response>;
     postStream(path: string, body?: unknown): Promise<Response>;
     put<T = unknown>(path: string, body: unknown): Promise<T>;
     del(path: string): Promise<void>;
     putVoid(path: string, body: unknown): Promise<void>;
+    /**
+     * PUT without a request body. A few DSS endpoints (bundle export) reject
+     * an empty JSON object body with 400 validation, and the official Python
+     * client sends no body at all for them.
+     */
+    putVoidNoBody(path: string): Promise<void>;
+    /**
+     * POST a multipart/form-data body built from explicit parts, with optional
+     * query parameters appended to the path, returning the parsed JSON body.
+     *
+     * A part with `value` becomes a form text field; a part with `blob`
+     * (or a `fileName` with no blob) becomes a file part — a `fileName` without
+     * blob yields a zero-byte file part, which some DSS import endpoints
+     * (e.g. saved-model MLflow version import) require for metadata-only parts.
+     * The `Content-Type` header is left to the runtime so the multipart
+     * boundary is set correctly.
+     */
+    uploadForm<T = unknown>(path: string, parts: UploadFormPart[], query?: URLSearchParams): Promise<T>;
     private uploadResponse;
     upload(path: string, filePath: string, fileName?: string): Promise<void>;
     uploadJson<T>(path: string, filePath: string, fileName?: string): Promise<T>;
@@ -271,7 +358,7 @@ export declare class DataikuClient {
     private requestIdFromHeaders;
     private parseJsonResponse;
     /**
-     * Read at most `maxBytes` of a 2xx response body as UTF-8 text.
+     * Read at most `maxBytes` of a response body as UTF-8 text.
      *
      * The body is consumed with the request deadline still active (measured
      * from the first read): a stalled body throws a DataikuError instead of

package/dist/src/client.js

@@ -13,19 +13,26 @@ import { CodeEnvsResource, } from "./resources/code-envs.js";
 import { ConnectionsResource, } from "./resources/connections.js";
 import { ContinuousActivitiesResource, } from "./resources/continuous-activities.js";
 import { DashboardsResource, } from "./resources/dashboards.js";
+import { DataCollectionsResource, } from "./resources/data-collections.js";
 import { DataQualityResource, } from "./resources/data-quality.js";
 import { DatasetsResource, } from "./resources/datasets.js";
 import { DiscussionsResource, } from "./resources/discussions.js";
 import { FlowZonesResource, } from "./resources/flow-zones.js";
 import { FoldersResource, } from "./resources/folders.js";
 import { FuturesResource, } from "./resources/futures.js";
+import { GroupsResource, } from "./resources/groups.js";
 import { InsightsResource, } from "./resources/insights.js";
 import { JobsResource, } from "./resources/jobs.js";
+import { KnowledgeBanksResource, } from "./resources/knowledge-banks.js";
+import { LlmsResource, } from "./resources/llms.js";
+import { MacrosResource, } from "./resources/macros.js";
 import { MeaningsResource, } from "./resources/meanings.js";
 import { MetricsResource, } from "./resources/metrics.js";
 import { MlTasksResource, } from "./resources/ml-tasks.js";
 import { ModelEvaluationStoresResource, } from "./resources/model-evaluation-stores.js";
 import { NotebooksResource, } from "./resources/notebooks.js";
+import { PluginsResource, } from "./resources/plugins.js";
+import { ProjectFoldersResource, } from "./resources/project-folders.js";
 import { ProjectGitResource, } from "./resources/project-git.js";
 import { ProjectLibraryResource, } from "./resources/project-library.js";
 import { ProjectsResource, } from "./resources/projects.js";
@@ -35,6 +42,7 @@ import { ScenariosResource, } from "./resources/scenarios.js";
 import { SqlResource, } from "./resources/sql.js";
 import { StatisticsResource, } from "./resources/statistics.js";
 import { StreamingEndpointsResource, } from "./resources/streaming-endpoints.js";
+import { UsersResource, } from "./resources/users.js";
 import { VariablesResource, } from "./resources/variables.js";
 import { WebappsResource, } from "./resources/webapps.js";
 import { WikiResource, } from "./resources/wiki.js";
@@ -70,6 +78,19 @@ function computeBackoffDelayMs(retryNumber) {
     const cap = Math.min(MAX_BACKOFF_DELAY_MS, BASE_DELAY_MS * 2 ** Math.max(0, retryNumber - 1));
     return Math.floor(Math.random() * (cap + 1));
 }
+/** Server-directed waits never bypass the existing automatic backoff cap. */
+function retryAfterDelayMs(value) {
+    if (value === null)
+        return 0;
+    const text = value.trim();
+    if (/^\d+$/.test(text))
+        return Number(text) * 1_000;
+    // Accept HTTP dates, not Date.parse's permissive numeric date shorthand.
+    if (!/^[A-Za-z]{3,9},? /.test(text))
+        return 0;
+    const date = Date.parse(text);
+    return Number.isFinite(date) ? Math.max(0, date - Date.now()) : 0;
+}
 function isTransientError(status, body) {
     return classifyDataikuError(status, body).category === "transient";
 }
@@ -173,6 +194,20 @@ function buildFetchTlsOptions(config) {
     }
     return tls;
 }
+/**
+ * Resolve the total-budget request deadline timestamp for a per-call GET
+ * budget: `Date.now() + timeoutMs`. Undefined when no budget is supplied, in
+ * which case the client-level per-attempt timeout applies unchanged.
+ */
+function resolveGetDeadlineAt(options) {
+    const timeoutMs = options?.timeoutMs;
+    if (timeoutMs === undefined)
+        return undefined;
+    if (!Number.isInteger(timeoutMs) || timeoutMs < 1) {
+        throw new ClientValidationError("timeoutMs must be a positive integer.");
+    }
+    return Date.now() + timeoutMs;
+}
 /**
  * True when the URL embeds userinfo (`https://user:password@host`). Embedded
  * credentials are rejected up front so they can never reach the canonical base
@@ -240,6 +275,14 @@ export class DataikuClient {
     mlTasksResource;
     savedModelsResource;
     modelEvaluationStoresResource;
+    projectFoldersResource;
+    dataCollectionsResource;
+    llmsResource;
+    knowledgeBanksResource;
+    macrosResource;
+    pluginsResource;
+    usersResource;
+    groupsResource;
     get projects() {
         return (this.projectsResource ??= new ProjectsResource(this));
     }
@@ -348,6 +391,30 @@ export class DataikuClient {
     get modelEvaluationStores() {
         return (this.modelEvaluationStoresResource ??= new ModelEvaluationStoresResource(this));
     }
+    get projectFolders() {
+        return (this.projectFoldersResource ??= new ProjectFoldersResource(this));
+    }
+    get dataCollections() {
+        return (this.dataCollectionsResource ??= new DataCollectionsResource(this));
+    }
+    get llms() {
+        return (this.llmsResource ??= new LlmsResource(this));
+    }
+    get knowledgeBanks() {
+        return (this.knowledgeBanksResource ??= new KnowledgeBanksResource(this));
+    }
+    get macros() {
+        return (this.macrosResource ??= new MacrosResource(this));
+    }
+    get plugins() {
+        return (this.pluginsResource ??= new PluginsResource(this));
+    }
+    get users() {
+        return (this.usersResource ??= new UsersResource(this));
+    }
+    get groups() {
+        return (this.groupsResource ??= new GroupsResource(this));
+    }
     constructor(config) {
         const envUrl = process.env["DATAIKU_URL"]?.trim();
         const envApiKey = process.env["DATAIKU_API_KEY"]?.trim();
@@ -399,12 +466,10 @@ export class DataikuClient {
         throw new Error("projectKey is required — pass it as a parameter or set projectKey in DataikuClientConfig");
     }
     /* ---- public: HTTP verbs ---- */
-    async get(path) {
-        const res = await this.fetchWithRetry(`${this.baseUrl}${path}`, {
-            method: "GET",
-            headers: this.getHeaders(),
-        });
-        return this.parseJsonResponse(res);
+    async get(path, options) {
+        const deadlineAt = resolveGetDeadlineAt(options);
+        const res = await this.fetchWithRetry(`${this.baseUrl}${path}`, { method: "GET", headers: this.getHeaders(), }, options?.noRetry === true ? 1 : undefined, deadlineAt);
+        return this.parseJsonResponse(res, deadlineAt);
     }
     /**
      * GET returning the parsed JSON body plus selected response metadata
@@ -496,6 +561,32 @@ export class DataikuClient {
             throw this.buildResponseTooLargeError(res, this.maxResponseBodyBytes);
         return text;
     }
+    /** Send raw file contents through the shared authenticated transport. */
+    async postRawBody(path, body) {
+        const payload = typeof body === "string"
+            ? body
+            : body.buffer instanceof ArrayBuffer
+                ? new Uint8Array(body.buffer, body.byteOffset, body.byteLength)
+                : new Uint8Array(body);
+        const response = await this.fetchWithRetry(`${this.baseUrl}${path}`, {
+            method: "POST",
+            headers: this.getAnyHeaders(),
+            body: payload,
+        });
+        await response.text();
+    }
+    /** Git endpoints require Basic API-key authentication, unlike the bearer API. */
+    async requestGit(method, path, body, deadlineAt, noRetry = false) {
+        return this.fetchWithRetry(`${this.baseUrl}${path}`, {
+            method,
+            headers: {
+                Authorization: `Basic ${Buffer.from(`${this.apiKey}:`, "utf8").toString("base64")}`,
+                Accept: "application/json",
+                "Content-Type": "application/json",
+            },
+            body: body === undefined ? undefined : JSON.stringify(body),
+        }, noRetry ? 1 : undefined, deadlineAt);
+    }
     async postStream(path, body) {
         const res = await this.fetchWithRetry(`${this.baseUrl}${path}`, {
             method: "POST",
@@ -525,6 +616,54 @@ export class DataikuClient {
             body: JSON.stringify(body),
         });
     }
+    /**
+     * PUT without a request body. A few DSS endpoints (bundle export) reject
+     * an empty JSON object body with 400 validation, and the official Python
+     * client sends no body at all for them.
+     */
+    async putVoidNoBody(path) {
+        await this.fetchWithRetry(`${this.baseUrl}${path}`, {
+            method: "PUT",
+            headers: this.getHeaders(),
+        });
+    }
+    /**
+     * POST a multipart/form-data body built from explicit parts, with optional
+     * query parameters appended to the path, returning the parsed JSON body.
+     *
+     * A part with `value` becomes a form text field; a part with `blob`
+     * (or a `fileName` with no blob) becomes a file part — a `fileName` without
+     * blob yields a zero-byte file part, which some DSS import endpoints
+     * (e.g. saved-model MLflow version import) require for metadata-only parts.
+     * The `Content-Type` header is left to the runtime so the multipart
+     * boundary is set correctly.
+     */
+    async uploadForm(path, parts, query) {
+        const formData = new FormData();
+        for (const part of parts) {
+            if (part.value !== undefined) {
+                formData.append(part.name, part.value);
+                continue;
+            }
+            if ((part.blob ?? null) === null && (part.fileName ?? null) === null) {
+                // Filename-less, zero-length field part — the shape the official
+                // Python client produces with files={"file": (None, None)} and
+                // the one DSS's managed-folder MLflow import requires (a Blob
+                // would always add a `filename=` parameter, even when empty).
+                formData.append(part.name, "");
+                continue;
+            }
+            const blob = part.blob ?? new Blob([]);
+            formData.append(part.name, blob, part.fileName);
+        }
+        const suffix = query && [...query.keys(),].length > 0 ? `?${query.toString()}` : "";
+        const res = await this.fetchWithRetry(`${this.baseUrl}${path}${suffix}`, {
+            method: "POST",
+            headers: { Authorization: `Bearer ${this.apiKey}`, },
+            body: formData,
+        });
+        return this.parseJsonResponse(res);
+    }
     async uploadResponse(path, filePath, fileName) {
         const fileBlob = Bun.file(filePath);
         const formData = new FormData();
@@ -658,8 +797,8 @@ export class DataikuClient {
         }
         return undefined;
     }
-    async parseJsonResponse(res) {
-        const { text, truncated, } = await this.readBoundedBodyText(res, this.maxResponseBodyBytes);
+    async parseJsonResponse(res, deadlineAt) {
+        const { text, truncated, } = await this.readBoundedBodyText(res, this.maxResponseBodyBytes, deadlineAt);
         if (truncated)
             throw this.buildResponseTooLargeError(res, this.maxResponseBodyBytes);
         // SAFETY: Empty 2xx responses from DSS are surfaced to callers as undefined
@@ -677,7 +816,7 @@ export class DataikuClient {
     }
     /* ---- private: bounded response body reading ---- */
     /**
-     * Read at most `maxBytes` of a 2xx response body as UTF-8 text.
+     * Read at most `maxBytes` of a response body as UTF-8 text.
      *
      * The body is consumed with the request deadline still active (measured
      * from the first read): a stalled body throws a DataikuError instead of
@@ -686,10 +825,15 @@ export class DataikuClient {
      * text is trimmed to a UTF-8 character boundary so it never decodes beyond
      * the byte cap.
      */
-    async readBoundedBodyText(res, maxBytes) {
+    async readBoundedBodyText(res, maxBytes, deadlineAt) {
         const limit = Math.max(0, Math.floor(maxBytes));
         if (!res.body)
             return { text: "", truncated: false, };
+        // Total-budget mode: the read shares the call's absolute deadline, so
+        // the budget already spent on attempts/backoff is not re-credited here.
+        const bodyTimeoutMs = deadlineAt === undefined
+            ? this.requestTimeoutMs
+            : Math.min(this.requestTimeoutMs, Math.max(1, deadlineAt - Date.now()));
         const reader = res.body.getReader();
         const decoder = new TextDecoder();
         const parts = [];
@@ -724,10 +868,10 @@ export class DataikuClient {
         const startedAt = Date.now();
         try {
             while (bytesRead < limit) {
-                const remainingMs = this.requestTimeoutMs - (Date.now() - startedAt);
+                const remainingMs = bodyTimeoutMs - (Date.now() - startedAt);
                 if (remainingMs <= 0)
-                    throw buildBodyReadTimeoutError(this.requestTimeoutMs);
-                const { done, value, } = await readChunkWithDeadline(reader, remainingMs, this.requestTimeoutMs);
+                    throw buildBodyReadTimeoutError(bodyTimeoutMs);
+                const { done, value, } = await readChunkWithDeadline(reader, remainingMs, bodyTimeoutMs);
                 if (done)
                     break;
                 const room = limit - bytesRead;
@@ -742,10 +886,10 @@ export class DataikuClient {
             }
             if (!truncated && bytesRead >= limit) {
                 // Buffer filled exactly on a chunk boundary; peek whether more data remains.
-                const remainingMs = this.requestTimeoutMs - (Date.now() - startedAt);
+                const remainingMs = bodyTimeoutMs - (Date.now() - startedAt);
                 if (remainingMs <= 0)
-                    throw buildBodyReadTimeoutError(this.requestTimeoutMs);
-                const { done, } = await readChunkWithDeadline(reader, remainingMs, this.requestTimeoutMs);
+                    throw buildBodyReadTimeoutError(bodyTimeoutMs);
+                const { done, } = await readChunkWithDeadline(reader, remainingMs, bodyTimeoutMs);
                 if (!done)
                     truncated = true;
             }
@@ -838,7 +982,7 @@ export class DataikuClient {
         return new DataikuError(res.status, RESPONSE_TOO_LARGE_STATUS_TEXT, `Response body exceeded the ${limit}-byte limit; the body was cancelled after ${limit} bytes.`, undefined, this.requestIdFromHeaders(res.headers));
     }
     /* ---- private: retry loop ---- */
-    async fetchWithRetry(url, init, retryMaxAttempts) {
+    async fetchWithRetry(url, init, retryMaxAttempts, deadlineAt) {
         const method = (init.method ?? "GET").toUpperCase();
         const retryEnabled = shouldRetryMethod(method) || retryMaxAttempts !== undefined;
         const maxAttempts = retryMaxAttempts === undefined
@@ -850,11 +994,21 @@ export class DataikuClient {
         for (let attempt = 1; attempt <= maxAttempts; attempt++) {
             let timedOut = false;
             const startedAt = Date.now();
+            // An overall deadline may shorten, but never extend, the attempt cap.
+            const remainingMs = deadlineAt === undefined
+                ? undefined
+                : deadlineAt - startedAt;
+            if (remainingMs !== undefined && remainingMs <= 0) {
+                throw new DataikuError(0, "Request Timeout", `Request deadline exceeded after ${attempt - 1} attempt(s) and ${delaysMs.length} backoff delay(s).`, buildRetryMetadata(method, retryEnabled, maxAttempts, attempt, delaysMs, true));
+            }
+            const attemptTimeoutMs = remainingMs === undefined
+                ? this.requestTimeoutMs
+                : Math.min(remainingMs, this.requestTimeoutMs);
             const controller = new AbortController();
             const timeout = setTimeout(() => {
                 timedOut = true;
                 controller.abort();
-            }, this.requestTimeoutMs);
+            }, attemptTimeoutMs);
             this.logTrace({ phase: "request", method, url, attempt, maxAttempts, });
             try {
                 const requestInit = {
@@ -875,30 +1029,47 @@ export class DataikuClient {
                     elapsedMs: Date.now() - startedAt,
                 });
                 if (!res.ok) {
-                    const text = await res.text();
+                    const { text, truncated, } = await this.readBoundedBodyText(res, this.maxResponseBodyBytes, startedAt + attemptTimeoutMs);
                     const canRetry = retryEnabled && attempt < maxAttempts && isTransientError(res.status, text);
-                    if (canRetry) {
-                        const delayMs = computeBackoffDelayMs(attempt);
-                        delaysMs.push(delayMs);
-                        await sleep(delayMs);
-                        continue;
+                    const serverDelayMs = canRetry ? retryAfterDelayMs(res.headers.get("retry-after")) : 0;
+                    // A longer server wait declines automatic retry; never clamp it into an early request.
+                    if (canRetry && serverDelayMs <= MAX_BACKOFF_DELAY_MS) {
+                        const delayMs = Math.max(computeBackoffDelayMs(attempt), serverDelayMs);
+                        // Do not start a retry whose backoff cannot fit in the budget.
+                        if (deadlineAt === undefined || Date.now() + delayMs <= deadlineAt) {
+                            delaysMs.push(delayMs);
+                            await sleep(delayMs);
+                            continue;
+                        }
+                        await sleep(Math.max(0, deadlineAt - Date.now()));
+                        throw new DataikuError(0, "Request Timeout", `Request deadline exceeded before backoff retry ${attempt + 1}.`, buildRetryMetadata(method, retryEnabled, maxAttempts, attempt, delaysMs, true));
                     }
-                    throw new DataikuError(res.status, res.statusText, text, buildRetryMetadata(method, retryEnabled, maxAttempts, attempt, delaysMs, false), this.requestIdFromHeaders(res.headers));
+                    throw new DataikuError(res.status, res.statusText, text, buildRetryMetadata(method, retryEnabled, maxAttempts, attempt, delaysMs, false), this.requestIdFromHeaders(res.headers), truncated ? { bodyTruncated: true, } : undefined);
                 }
                 return res;
             }
             catch (error) {
-                if (error instanceof DataikuError)
-                    throw error;
+                if (error instanceof DataikuError) {
+                    // A bounded error-body read is still part of this transport attempt.
+                    // Preserve the same retry/deadline policy as a fetch body abort.
+                    if (error.status !== 0 || error.statusText !== "Request Timeout" || error.retry !== undefined) {
+                        throw error;
+                    }
+                    timedOut = true;
+                }
                 const canRetry = retryEnabled && attempt < maxAttempts;
                 if (canRetry) {
                     const delayMs = computeBackoffDelayMs(attempt);
-                    delaysMs.push(delayMs);
-                    await sleep(delayMs);
-                    continue;
+                    if (deadlineAt === undefined || Date.now() + delayMs <= deadlineAt) {
+                        delaysMs.push(delayMs);
+                        await sleep(delayMs);
+                        continue;
+                    }
+                    await sleep(Math.max(0, deadlineAt - Date.now()));
+                    throw new DataikuError(0, "Request Timeout", `Request deadline exceeded before backoff retry ${attempt + 1}.`, buildRetryMetadata(method, retryEnabled, maxAttempts, attempt, delaysMs, true));
                 }
                 const detail = timedOut
-                    ? `Request timed out after ${this.requestTimeoutMs}ms`
+                    ? `Request timed out after ${attemptTimeoutMs}ms`
                     : error instanceof Error
                         ? error.message
                         : "Unknown transport error";

package/dist/src/errors.d.ts

@@ -18,6 +18,8 @@ export interface DataikuRetryMetadata {
 export interface DataikuErrorTrustedMetadata {
     target?: string;
     elapsedMs?: number;
+    /** Set by the transport when the retained response body is only a bounded prefix. */
+    bodyTruncated?: boolean;
 }
 export declare function canonicalStatusText(status: number): string;
 export declare class ClientValidationError extends Error {
@@ -44,6 +46,7 @@ export declare class DataikuError extends Error {
     requestId?: string;
     readonly trustedTarget?: string;
     readonly trustedElapsedMs?: number;
+    readonly bodyTruncated?: boolean;
     constructor(status: number, statusText: string, body: string, retry?: DataikuRetryMetadata, requestId?: string, trustedMetadata?: DataikuErrorTrustedMetadata);
     get safeMessage(): string;
     private static extractSummary;

package/dist/src/errors.js

@@ -92,10 +92,12 @@ function firstHtmlTextLine(body) {
         .replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, " ")
         .replace(/<style\b[^>]*>[\s\S]*?<\/style>/gi, " ")
         .replace(/<[^>]+>/g, "\n"));
-    return text
-        .split(/\r?\n/g)
-        .map((line) => line.trim())
-        .find((line) => line.length > 0);
+    for (const match of text.matchAll(/[^\n]+/g)) {
+        const line = match[0].trim();
+        if (line.length > 0)
+            return line;
+    }
+    return undefined;
 }
 function conciseErrorSummary(text) {
     const sanitized = stripServerFilesystemPaths(text);
@@ -339,6 +341,7 @@ export class DataikuError extends Error {
     requestId;
     trustedTarget;
     trustedElapsedMs;
+    bodyTruncated;
     constructor(status, statusText, body, retry, requestId, trustedMetadata) {
         const details = DataikuError.buildDetails(status, body, retry);
         super(details.message);
@@ -353,6 +356,7 @@ export class DataikuError extends Error {
         this.requestId = requestId;
         this.trustedTarget = trustedMetadata?.target;
         this.trustedElapsedMs = trustedMetadata?.elapsedMs;
+        this.bodyTruncated = trustedMetadata?.bodyTruncated === true ? true : undefined;
     }
     get safeMessage() {
         const retrySummary = DataikuError.formatRetryMetadata(this.retry);