dataiku-sdk 3.0.0 → 3.2.0

package/dist/src/client.d.ts

@@ -67,10 +67,16 @@ 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.
+     */
+    maxResponseBodyBytes?: number;
     /** Emit HTTP request/response trace events. Defaults to JSONL on stderr when verbose is true. */
     verbose?: boolean;
     onTrace?: (event: DataikuClientTraceEvent) => void;
@@ -91,6 +97,7 @@ export declare class DataikuClient {
     private readonly apiKey;
     private readonly defaultProjectKey;
     private readonly requestTimeoutMs;
+    private readonly maxResponseBodyBytes;
     private readonly retryMaxAttempts;
     private readonly verbose;
     private readonly tlsOptions;
@@ -176,6 +183,11 @@ export declare class DataikuClient {
      */
     getBaseUrl(): string;
     getRequestTimeoutMs(): number;
+    /**
+     * The configured maximum number of bytes buffered from a single response
+     * body by the text/JSON consumer methods (default 50 MiB).
+     */
+    getMaxResponseBodyBytes(): number;
     resolveProjectKey(paramValue?: string): string;
     get<T = unknown>(path: string): Promise<T>;
     /**
@@ -187,11 +199,34 @@ export declare class DataikuClient {
         data: T;
         meta: DataikuClientResponseMeta;
     }>;
+    /**
+     * GET returning the entire text body. The body is buffered with a hard
+     * byte cap (`maxResponseBodyBytes`, default 50 MiB) and read under the
+     * request deadline: a response exceeding the cap throws a DataikuError
+     * instead of being silently truncated, and a stalled body times out.
+     */
     getText(path: string): Promise<string>;
+    /**
+     * GET returning at most the first `maxBytes` bytes of a text body.
+     * When the response exceeds the cap the stream is cancelled, only the
+     * collected prefix is returned and `truncated` is true. The read runs
+     * under the request deadline: a stalled body throws a DataikuError.
+     */
     getTextLimited(path: string, maxBytes: number): Promise<{
         text: string;
         truncated: boolean;
     }>;
+    /**
+     * GET returning at most the last `maxBytes` bytes of a text body.
+     * When the response exceeds the cap, earlier bytes are discarded, only
+     * the tail is kept and `truncated` is true — so callers that need the end
+     * of a large document (e.g. job logs) stay bounded without losing the most
+     * recent content. The read runs under the request deadline.
+     */
+    getTextTailLimited(path: string, maxBytes: number): Promise<{
+        text: string;
+        truncated: boolean;
+    }>;
     /**
      * POST with optional transient retry. Only opt in when repeating the request
      * is safe: the server may have accepted an attempt whose response was lost.
@@ -199,6 +234,10 @@ export declare class DataikuClient {
     post<T = unknown>(path: string, body?: unknown, options?: {
         retryMaxAttempts?: number;
     }): Promise<T>;
+    /**
+     * POST returning the text body, under the same bounded buffering rules as
+     * {@link getText} (byte cap `maxResponseBodyBytes`, request deadline).
+     */
     postText(path: string, body?: unknown): Promise<string>;
     postStream(path: string, body?: unknown): Promise<Response>;
     put<T = unknown>(path: string, body: unknown): Promise<T>;
@@ -208,6 +247,8 @@ export declare class DataikuClient {
     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;
@@ -229,5 +270,26 @@ export declare class DataikuClient {
     warn(method: string, errors: string[]): void;
     private requestIdFromHeaders;
     private parseJsonResponse;
+    /**
+     * Read at most `maxBytes` of a 2xx 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
+     * hanging. When the stream yields more than the cap, the reader cancels the
+     * body and returns the collected prefix with `truncated: true`; truncated
+     * text is trimmed to a UTF-8 character boundary so it never decodes beyond
+     * the byte cap.
+     */
+    private readBoundedBodyText;
+    /**
+     * Read a 2xx response body keeping only the last `maxBytes` bytes.
+     * Earlier bytes are discarded as the stream advances, so memory stays
+     * bounded by the cap plus one chunk even for arbitrarily large bodies.
+     * Returns `truncated: true` when bytes had to be dropped. Bytes that fall
+     * in the middle of a UTF-8 character are dropped from both ends so the
+     * decoded text never contains a replacement character.
+     */
+    private readBodyTextTail;
+    private buildResponseTooLargeError;
     private fetchWithRetry;
 }

package/dist/src/client.js

@@ -3,7 +3,7 @@ import { basename, } from "node:path";
 import { getCACertificates, } from "node:tls";
 import { Value, } from "@sinclair/typebox/value";
 import { safeParseSchema, } from "./schemas.js";
-import { classifyDataikuError, ClientValidationError, DataikuError, } from "./errors.js";
+import { classifyDataikuError, ClientValidationError, DataikuError, NON_JSON_RESPONSE_MARKER, } from "./errors.js";
 import { AnalysesResource, } from "./resources/analyses.js";
 import { ApiDeployerResource, } from "./resources/api-deployer.js";
 import { ApiServicesResource, } from "./resources/api-services.js";
@@ -47,6 +47,14 @@ const MAX_RETRY_ATTEMPTS_CAP = 10;
 const BASE_DELAY_MS = 2_000;
 const MAX_BACKOFF_DELAY_MS = 30_000;
 const DEFAULT_REQUEST_TIMEOUT_MS = 30_000;
+/**
+ * Default cap on bytes buffered from a single response body by the text/JSON
+ * consumers (getText, postText, parseJsonResponse). Bodies larger than this
+ * are rejected with a DataikuError after the stream is cancelled; raw
+ * streaming methods (stream, postStream) are unaffected.
+ */
+const DEFAULT_MAX_BUFFERED_BODY_BYTES = 50 * 1024 * 1024;
+const RESPONSE_TOO_LARGE_STATUS_TEXT = "Response Too Large";
 /* ------------------------------------------------------------------ */
 /*  Helpers                                                            */
 /* ------------------------------------------------------------------ */
@@ -68,15 +76,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
@@ -105,6 +104,43 @@ function trimToUtf8Boundary(bytes) {
         return bytes;
     return continuation + 1 < expected ? bytes.subarray(0, i) : bytes;
 }
+/**
+ * Drop leading UTF-8 continuation bytes. A UTF-8 character never *starts*
+ * with a continuation byte, so any leading continuation bytes are the remains
+ * of a character split by a byte cut at the start of the retained range.
+ * Dropping them keeps the decoded text free of replacement characters.
+ */
+function trimFromUtf8BoundaryStart(bytes) {
+    let i = 0;
+    while (i < bytes.length && (bytes[i] & 0xC0) === 0x80) {
+        i++;
+    }
+    return i > 0 ? bytes.subarray(i) : bytes;
+}
+function buildBodyReadTimeoutError(timeoutMs) {
+    return new DataikuError(0, "Request Timeout", `Request timed out after ${timeoutMs}ms while reading the response body.`);
+}
+/**
+ * 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
+ * consumers after headers already arrived.
+ */
+async function readChunkWithDeadline(reader, remainingMs, timeoutMs) {
+    const { promise, resolve, reject, } = Promise.withResolvers();
+    const timer = setTimeout(() => {
+        void reader.cancel(buildBodyReadTimeoutError(timeoutMs)).catch(() => { });
+        reject(buildBodyReadTimeoutError(timeoutMs));
+    }, remainingMs);
+    reader.read().then((result) => {
+        clearTimeout(timer);
+        resolve(result);
+    }, (error) => {
+        clearTimeout(timer);
+        reject(error);
+    });
+    return promise;
+}
 function buildRetryMetadata(method, enabled, maxAttempts, attempts, delaysMs, timedOut) {
     return {
         method,
@@ -161,6 +197,7 @@ export class DataikuClient {
     apiKey;
     defaultProjectKey;
     requestTimeoutMs;
+    maxResponseBodyBytes;
     retryMaxAttempts;
     verbose;
     tlsOptions;
@@ -326,6 +363,7 @@ export class DataikuClient {
         this.apiKey = apiKey;
         this.defaultProjectKey = config?.projectKey?.trim() || undefined;
         this.requestTimeoutMs = config?.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+        this.maxResponseBodyBytes = config?.maxResponseBodyBytes ?? DEFAULT_MAX_BUFFERED_BODY_BYTES;
         const rawMax = config?.retryMaxAttempts ?? DEFAULT_RETRY_MAX_ATTEMPTS;
         this.retryMaxAttempts = Math.min(Math.max(1, rawMax), MAX_RETRY_ATTEMPTS_CAP);
         this.verbose = config?.verbose === true;
@@ -344,6 +382,13 @@ export class DataikuClient {
     getRequestTimeoutMs() {
         return this.requestTimeoutMs;
     }
+    /**
+     * The configured maximum number of bytes buffered from a single response
+     * body by the text/JSON consumer methods (default 50 MiB).
+     */
+    getMaxResponseBodyBytes() {
+        return this.maxResponseBodyBytes;
+    }
     /* ---- public: project key resolution ---- */
     resolveProjectKey(paramValue) {
         const pk = paramValue?.trim();
@@ -374,56 +419,50 @@ export class DataikuClient {
         const data = await this.parseJsonResponse(res);
         return { data, meta: this.responseMeta(res.headers), };
     }
+    /**
+     * GET returning the entire text body. The body is buffered with a hard
+     * byte cap (`maxResponseBodyBytes`, default 50 MiB) and read under the
+     * request deadline: a response exceeding the cap throws a DataikuError
+     * instead of being silently truncated, and a stalled body times out.
+     */
     async getText(path) {
         const res = await this.fetchWithRetry(`${this.baseUrl}${path}`, {
             method: "GET",
             headers: this.getAnyHeaders(),
         });
-        return res.text();
+        const { text, truncated, } = await this.readBoundedBodyText(res, this.maxResponseBodyBytes);
+        if (truncated)
+            throw this.buildResponseTooLargeError(res, this.maxResponseBodyBytes);
+        return text;
     }
+    /**
+     * GET returning at most the first `maxBytes` bytes of a text body.
+     * When the response exceeds the cap the stream is cancelled, only the
+     * collected prefix is returned and `truncated` is true. The read runs
+     * under the request deadline: a stalled body throws a DataikuError.
+     */
     async getTextLimited(path, maxBytes) {
         const limit = Math.max(0, Math.floor(maxBytes));
         const res = await this.fetchWithRetry(`${this.baseUrl}${path}`, {
             method: "GET",
             headers: this.getAnyHeaders(),
         });
-        if (!res.body)
-            return { text: "", truncated: false, };
-        const reader = res.body.getReader();
-        const chunks = [];
-        let bytesRead = 0;
-        let truncated = false;
-        try {
-            while (bytesRead < limit) {
-                const { done, value, } = await reader.read();
-                if (done)
-                    break;
-                const room = limit - bytesRead;
-                if (value.byteLength > room) {
-                    chunks.push(value.slice(0, room));
-                    bytesRead += room;
-                    truncated = true;
-                    break;
-                }
-                chunks.push(value);
-                bytesRead += value.byteLength;
-            }
-            if (!truncated && bytesRead >= limit) {
-                // Buffer filled exactly on a chunk boundary; peek whether more data remains.
-                const { done, } = await reader.read();
-                if (!done)
-                    truncated = true;
-            }
-        }
-        finally {
-            await reader.cancel();
-        }
-        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, };
+        return this.readBoundedBodyText(res, limit);
+    }
+    /**
+     * GET returning at most the last `maxBytes` bytes of a text body.
+     * When the response exceeds the cap, earlier bytes are discarded, only
+     * the tail is kept and `truncated` is true — so callers that need the end
+     * of a large document (e.g. job logs) stay bounded without losing the most
+     * recent content. The read runs under the request deadline.
+     */
+    async getTextTailLimited(path, maxBytes) {
+        const limit = Math.max(0, Math.floor(maxBytes));
+        const res = await this.fetchWithRetry(`${this.baseUrl}${path}`, {
+            method: "GET",
+            headers: this.getAnyHeaders(),
+        });
+        return this.readBodyTextTail(res, limit);
     }
     /**
      * POST with optional transient retry. Only opt in when repeating the request
@@ -442,20 +481,28 @@ export class DataikuClient {
         }, retryMaxAttempts);
         return this.parseJsonResponse(res);
     }
+    /**
+     * POST returning the text body, under the same bounded buffering rules as
+     * {@link getText} (byte cap `maxResponseBodyBytes`, request deadline).
+     */
     async postText(path, body) {
         const res = await this.fetchWithRetry(`${this.baseUrl}${path}`, {
             method: "POST",
             headers: this.getHeaders(),
             body: body !== undefined ? JSON.stringify(body) : undefined,
         });
-        return res.text();
+        const { text, truncated, } = await this.readBoundedBodyText(res, this.maxResponseBodyBytes);
+        if (truncated)
+            throw this.buildResponseTooLargeError(res, this.maxResponseBodyBytes);
+        return text;
     }
     async postStream(path, body) {
-        return this.fetchWithRetry(`${this.baseUrl}${path}`, {
+        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}`, {
@@ -496,10 +543,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() {
@@ -571,7 +659,9 @@ export class DataikuClient {
         return undefined;
     }
     async parseJsonResponse(res) {
-        const text = await res.text();
+        const { text, truncated, } = await this.readBoundedBodyText(res, this.maxResponseBodyBytes);
+        if (truncated)
+            throw this.buildResponseTooLargeError(res, this.maxResponseBodyBytes);
         // SAFETY: Empty 2xx responses from DSS are surfaced to callers as undefined
         // cast to T. This keeps existing call sites stable, but callers that rely on
         // an object shape must guard explicitly before dereferencing the result.
@@ -582,8 +672,170 @@ export class DataikuClient {
         }
         catch {
             const summary = text.length > 300 ? `${text.slice(0, 300)}…` : text;
-            throw new DataikuError(res.status, res.statusText || "Invalid JSON response", `Expected JSON response body but got non-JSON content: ${summary}`, undefined, this.requestIdFromHeaders(res.headers));
+            throw new DataikuError(res.status, res.statusText || "Invalid JSON response", `${NON_JSON_RESPONSE_MARKER}: ${summary}`, undefined, this.requestIdFromHeaders(res.headers));
+        }
+    }
+    /* ---- private: bounded response body reading ---- */
+    /**
+     * Read at most `maxBytes` of a 2xx 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
+     * hanging. When the stream yields more than the cap, the reader cancels the
+     * body and returns the collected prefix with `truncated: true`; truncated
+     * text is trimmed to a UTF-8 character boundary so it never decodes beyond
+     * the byte cap.
+     */
+    async readBoundedBodyText(res, maxBytes) {
+        const limit = Math.max(0, Math.floor(maxBytes));
+        if (!res.body)
+            return { text: "", truncated: false, };
+        const reader = res.body.getReader();
+        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);
+                if (remainingMs <= 0)
+                    throw buildBodyReadTimeoutError(this.requestTimeoutMs);
+                const { done, value, } = await readChunkWithDeadline(reader, remainingMs, this.requestTimeoutMs);
+                if (done)
+                    break;
+                const room = limit - bytesRead;
+                if (value.byteLength > room) {
+                    append(value.subarray(0, room));
+                    bytesRead += room;
+                    truncated = true;
+                    break;
+                }
+                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);
+                if (remainingMs <= 0)
+                    throw buildBodyReadTimeoutError(this.requestTimeoutMs);
+                const { done, } = await readChunkWithDeadline(reader, remainingMs, this.requestTimeoutMs);
+                if (!done)
+                    truncated = true;
+            }
+        }
+        finally {
+            void reader.cancel().catch(() => { });
+        }
+        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.
+     * Earlier bytes are discarded as the stream advances, so memory stays
+     * bounded by the cap plus one chunk even for arbitrarily large bodies.
+     * Returns `truncated: true` when bytes had to be dropped. Bytes that fall
+     * in the middle of a UTF-8 character are dropped from both ends so the
+     * decoded text never contains a replacement character.
+     */
+    async readBodyTextTail(res, maxBytes) {
+        const limit = Math.max(0, Math.floor(maxBytes));
+        if (!res.body)
+            return { text: "", truncated: false, };
+        const reader = res.body.getReader();
+        const ring = new Uint8Array(limit);
+        let writeOffset = 0;
+        let retainedBytes = 0;
+        let truncated = false;
+        const startedAt = Date.now();
+        try {
+            while (true) {
+                const remainingMs = this.requestTimeoutMs - (Date.now() - startedAt);
+                if (remainingMs <= 0)
+                    throw buildBodyReadTimeoutError(this.requestTimeoutMs);
+                const { done, value, } = await readChunkWithDeadline(reader, remainingMs, this.requestTimeoutMs);
+                if (done)
+                    break;
+                if (limit === 0) {
+                    truncated = value.byteLength > 0;
+                    if (truncated)
+                        break;
+                    continue;
+                }
+                if (value.byteLength >= limit) {
+                    ring.set(value.subarray(value.byteLength - limit));
+                    truncated = truncated || retainedBytes > 0 || value.byteLength > limit;
+                    retainedBytes = limit;
+                    writeOffset = 0;
+                    continue;
+                }
+                const firstLength = Math.min(value.byteLength, limit - writeOffset);
+                ring.set(value.subarray(0, firstLength), writeOffset);
+                const remainingLength = value.byteLength - firstLength;
+                if (remainingLength > 0) {
+                    ring.set(value.subarray(firstLength));
+                }
+                writeOffset = (writeOffset + value.byteLength) % limit;
+                truncated = truncated || retainedBytes + value.byteLength > limit;
+                retainedBytes = Math.min(limit, retainedBytes + value.byteLength);
+            }
         }
+        finally {
+            void reader.cancel().catch(() => { });
+        }
+        let collected;
+        if (retainedBytes === 0) {
+            collected = new Uint8Array(0);
+        }
+        else if (retainedBytes < limit) {
+            collected = ring.slice(0, retainedBytes);
+        }
+        else if (writeOffset === 0) {
+            collected = ring;
+        }
+        else {
+            collected = new Uint8Array(retainedBytes);
+            const suffixLength = limit - writeOffset;
+            collected.set(ring.subarray(writeOffset));
+            collected.set(ring.subarray(0, writeOffset), suffixLength);
+        }
+        // A byte cut inside a multi-byte sequence can leave continuation bytes at
+        // the start (and possibly the end) of the tail; drop both so the decoded
+        // text never starts or ends with a U+FFFD replacement character.
+        const usable = truncated
+            ? trimToUtf8Boundary(trimFromUtf8BoundaryStart(collected))
+            : collected;
+        return { text: new TextDecoder().decode(usable), truncated, };
+    }
+    buildResponseTooLargeError(res, limit) {
+        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) {

package/dist/src/errors.d.ts

@@ -1,5 +1,5 @@
-export type DataikuErrorCategory = "not_found" | "forbidden" | "validation" | "transient" | "unknown";
-export type StableErrorCode = "usage_error" | "unknown_flag" | "missing_required_arg" | "missing_required_flag" | "invalid_flag_value" | "conflicting_input_sources" | "invalid_enum" | "not_found" | "permission_denied" | "target_absence_unverifiable" | "validation_failed" | "transient" | "long_running_failure" | "command_result_failure" | "assertion_failed" | "ambiguous_outcome" | "internal_error";
+export type DataikuErrorCategory = "not_found" | "forbidden" | "validation" | "transient" | "unexpected_response" | "unknown";
+export type StableErrorCode = "usage_error" | "unknown_flag" | "missing_required_arg" | "missing_required_flag" | "invalid_flag_value" | "conflicting_input_sources" | "invalid_enum" | "not_found" | "permission_denied" | "target_absence_unverifiable" | "validation_failed" | "transient" | "long_running_failure" | "command_result_failure" | "assertion_failed" | "ambiguous_outcome" | "unexpected_response" | "internal_error";
 export declare function dataikuErrorCode(category: DataikuErrorCategory): StableErrorCode;
 export interface DataikuErrorTaxonomy {
     category: DataikuErrorCategory;
@@ -26,6 +26,12 @@ export declare class ClientValidationError extends Error {
     readonly details?: Record<string, unknown>;
     constructor(message: string, code?: StableErrorCode, hint?: string, details?: Record<string, unknown>);
 }
+/**
+ * Message prefix the client stamps on a 2xx body that is not JSON. The
+ * classifier recognizes exactly this prefix, so the parse-failure path and the
+ * taxonomy stay in sync as one contract.
+ */
+export declare const NON_JSON_RESPONSE_MARKER = "Expected JSON response body but got non-JSON content";
 export declare function classifyDataikuError(status: number, body: string): DataikuErrorTaxonomy;
 export declare class DataikuError extends Error {
     status: number;