dataiku-sdk 3.1.0 → 3.3.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,43 @@ 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;
+}
 export interface DataikuClientTraceEvent {
     type: "trace";
     phase: "request" | "response" | "error";
@@ -67,14 +107,14 @@ export interface DataikuClientConfig {
     apiKey: string;
     /** Default project key — used when a resource method omits projectKey */
     projectKey?: string;
-    /** Per-request timeout in milliseconds (default 30 000) */
+    /** Request/header timeout and buffered-body budget; idle timeout per raw stream read (default 30 000 ms). */
     requestTimeoutMs?: number;
     /** 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 +179,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 +223,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 +245,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,14 +295,38 @@ 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): 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>;
     stream(path: string): Promise<Response>;
+    /** Bound each pending read, not total transfer time; preserve large downloads and backpressure. */
+    private withBodyDeadline;
     private getHeaders;
     private getAnyHeaders;
     private responseMeta;
@@ -269,7 +349,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";
@@ -76,15 +84,6 @@ function isTransientError(status, body) {
 function shouldRetryMethod(method) {
     return method.toUpperCase() === "GET";
 }
-function concatBytes(chunks, total) {
-    const out = new Uint8Array(total);
-    let offset = 0;
-    for (const chunk of chunks) {
-        out.set(chunk, offset);
-        offset += chunk.byteLength;
-    }
-    return out;
-}
 /**
  * Drop a trailing incomplete UTF-8 multibyte sequence so the bytes end on a
  * character boundary. Guarantees the decoded string re-encodes to no more bytes
@@ -133,7 +132,7 @@ function buildBodyReadTimeoutError(timeoutMs) {
  * Read the next chunk of a response body under a hard deadline.
  * When `remainingMs` elapses, the stream is cancelled and the caller's
  * promise rejects with a DataikuError, so a stalled body cannot hang the
- * buffered consumers after headers already arrived.
+ * consumers after headers already arrived.
  */
 async function readChunkWithDeadline(reader, remainingMs, timeoutMs) {
     const { promise, resolve, reject, } = Promise.withResolvers();
@@ -182,6 +181,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
@@ -249,6 +262,14 @@ export class DataikuClient {
     mlTasksResource;
     savedModelsResource;
     modelEvaluationStoresResource;
+    projectFoldersResource;
+    dataCollectionsResource;
+    llmsResource;
+    knowledgeBanksResource;
+    macrosResource;
+    pluginsResource;
+    usersResource;
+    groupsResource;
     get projects() {
         return (this.projectsResource ??= new ProjectsResource(this));
     }
@@ -357,6 +378,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();
@@ -408,12 +453,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(), }, undefined, deadlineAt);
+        return this.parseJsonResponse(res, deadlineAt);
     }
     /**
      * GET returning the parsed JSON body plus selected response metadata
@@ -505,12 +548,39 @@ export class DataikuClient {
             throw this.buildResponseTooLargeError(res, this.maxResponseBodyBytes);
         return text;
     }
-    async postStream(path, body) {
+    /** 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) {
         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),
+        }, undefined, deadlineAt);
+    }
+    async postStream(path, body) {
+        const res = await this.fetchWithRetry(`${this.baseUrl}${path}`, {
             method: "POST",
             headers: { ...this.getAnyHeaders(), "Content-Type": "application/json", },
             body: body !== undefined ? JSON.stringify(body) : undefined,
         });
+        return this.withBodyDeadline(res);
     }
     async put(path, body) {
         const res = await this.fetchWithRetry(`${this.baseUrl}${path}`, {
@@ -533,6 +603,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();
@@ -551,10 +669,51 @@ export class DataikuClient {
         return this.parseJsonResponse(response);
     }
     async stream(path) {
-        return this.fetchWithRetry(`${this.baseUrl}${path}`, {
+        const res = await this.fetchWithRetry(`${this.baseUrl}${path}`, {
             method: "GET",
             headers: this.getAnyHeaders(),
         });
+        return this.withBodyDeadline(res);
+    }
+    /** Bound each pending read, not total transfer time; preserve large downloads and backpressure. */
+    withBodyDeadline(res) {
+        if (!res.body)
+            return res;
+        const reader = res.body.getReader();
+        const timeoutMs = this.requestTimeoutMs;
+        const body = new ReadableStream({
+            async pull(controller) {
+                try {
+                    const { done, value, } = await readChunkWithDeadline(reader, timeoutMs, timeoutMs);
+                    if (done) {
+                        controller.close();
+                        reader.releaseLock();
+                    }
+                    else {
+                        controller.enqueue(value);
+                    }
+                }
+                catch (error) {
+                    controller.error(error);
+                    void reader.cancel(error).catch(() => { });
+                }
+            },
+            cancel(reason) {
+                void reader.cancel(reason).catch(() => { });
+            },
+        });
+        const response = new Response(body, {
+            status: res.status,
+            statusText: res.statusText,
+            headers: res.headers,
+        });
+        // ResponseInit has no fields for these fetch response properties.
+        Object.defineProperties(response, {
+            url: { value: res.url, },
+            redirected: { value: res.redirected, },
+            type: { value: res.type, },
+        });
+        return response;
     }
     /* ---- private: headers ---- */
     getHeaders() {
@@ -625,8 +784,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
@@ -644,7 +803,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
@@ -653,39 +812,71 @@ 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 chunks = [];
+        const decoder = new TextDecoder();
+        const parts = [];
+        // Keep the final UTF-8 sequence undecoded until truncation is known.
+        // Four bytes also cover malformed sequences handled by trimToUtf8Boundary.
+        const tail = new Uint8Array(4);
+        let tailLength = 0;
+        const append = (chunk) => {
+            if (chunk.byteLength >= tail.length) {
+                if (tailLength > 0) {
+                    parts.push(decoder.decode(tail.subarray(0, tailLength), { stream: true, }));
+                }
+                const end = chunk.byteLength - tail.length;
+                if (end > 0)
+                    parts.push(decoder.decode(chunk.subarray(0, end), { stream: true, }));
+                tail.set(chunk.subarray(end));
+                tailLength = tail.length;
+            }
+            else {
+                const excess = Math.max(0, tailLength + chunk.byteLength - tail.length);
+                if (excess > 0) {
+                    parts.push(decoder.decode(tail.subarray(0, excess), { stream: true, }));
+                    tail.copyWithin(0, excess, tailLength);
+                    tailLength -= excess;
+                }
+                tail.set(chunk, tailLength);
+                tailLength += chunk.byteLength;
+            }
+        };
         let bytesRead = 0;
         let truncated = false;
         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;
                 if (value.byteLength > room) {
-                    chunks.push(value.slice(0, room));
+                    append(value.subarray(0, room));
                     bytesRead += room;
                     truncated = true;
                     break;
                 }
-                chunks.push(value);
+                append(value);
                 bytesRead += value.byteLength;
             }
             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;
             }
@@ -693,12 +884,9 @@ export class DataikuClient {
         finally {
             void reader.cancel().catch(() => { });
         }
-        const collected = concatBytes(chunks, bytesRead);
-        // On truncation, drop any trailing partial UTF-8 character so the decoded
-        // text never re-encodes beyond the byte cap (a stream-flush would otherwise
-        // emit a 3-byte replacement char for a split multibyte sequence).
-        const usable = truncated ? trimToUtf8Boundary(collected) : collected;
-        return { text: new TextDecoder().decode(usable), truncated, };
+        const remaining = tail.subarray(0, tailLength);
+        parts.push(decoder.decode(truncated ? trimToUtf8Boundary(remaining) : remaining));
+        return { text: parts.join(""), truncated, };
     }
     /**
      * Read a 2xx response body keeping only the last `maxBytes` bytes.
@@ -781,7 +969,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
@@ -793,11 +981,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 = {
@@ -818,30 +1016,45 @@ 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;
+                        // 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";