dataiku-sdk 3.3.0 → 3.4.0

package/dist/src/resources/datasets.js

@@ -394,12 +394,39 @@ async function collectTsvRowCount(body, stopAfter, timeoutMs) {
         reader.releaseLock();
     }
 }
+/**
+ * Encoded CSV bytes accumulated before one stream push. Rows are joined into
+ * batch-sized chunks so large downloads do not pay per-row stream overhead; a
+ * single escaped row may exceed the budget (rows are never split), and the
+ * batch is always flushed at EOF so trailing rows are never dropped.
+ */
+const CSV_BATCH_BYTES = 64 * 1024;
 function tsvToCsvTransform(maxDataRows, stats, onHeader, spreadsheetSafe = true) {
     const state = createTsvStreamState();
     const decoder = new StringDecoder("utf-8");
     const maxRows = Math.max(1, maxDataRows);
     let headerSeen = false;
     let done = false;
+    // Bounded CSV output batching: emitted rows accumulate here and are joined
+    // into a single push once the batch reaches CSV_BATCH_BYTES, so memory stays
+    // bounded by the batch budget plus one escaped row (the join briefly holds a
+    // second copy of the batch) while per-row push/callback overhead disappears.
+    let batchLines = [];
+    let batchBytes = 0;
+    const flushBatch = (target) => {
+        if (batchLines.length === 0)
+            return;
+        const csv = batchLines.join("");
+        batchLines = [];
+        batchBytes = 0;
+        target.push(csv);
+    };
+    const queueLine = (target, line) => {
+        batchLines.push(line);
+        batchBytes += Buffer.byteLength(line);
+        if (batchBytes >= CSV_BATCH_BYTES)
+            flushBatch(target);
+    };
     let columnCount = 0;
     const handleRow = (row, push) => {
         if (done)
@@ -430,7 +457,7 @@ function tsvToCsvTransform(maxDataRows, stats, onHeader, spreadsheetSafe = true)
                 return;
             }
             try {
-                consumeTsvChunk(decoder.write(chunk), state, (row) => handleRow(row, (line) => this.push(line)));
+                consumeTsvChunk(decoder.write(chunk), state, (row) => handleRow(row, (line) => queueLine(this, line)));
             }
             catch (error) {
                 // Byte-limit overflow: destroy the transform so the pipeline
@@ -438,8 +465,11 @@ function tsvToCsvTransform(maxDataRows, stats, onHeader, spreadsheetSafe = true)
                 callback(error instanceof Error ? error : new Error(String(error)));
                 return;
             }
-            if (done)
+            if (done) {
+                // Truncation reached: emit the batch queued so far before EOF.
+                flushBatch(this);
                 this.push(null);
+            }
             callback();
         },
         flush(callback) {
@@ -450,14 +480,17 @@ function tsvToCsvTransform(maxDataRows, stats, onHeader, spreadsheetSafe = true)
             try {
                 const tail = decoder.end();
                 if (tail !== "") {
-                    consumeTsvChunk(tail, state, (row) => handleRow(row, (line) => this.push(line)));
+                    consumeTsvChunk(tail, state, (row) => handleRow(row, (line) => queueLine(this, line)));
                 }
-                flushTsvStream(state, (row) => handleRow(row, (line) => this.push(line)));
+                flushTsvStream(state, (row) => handleRow(row, (line) => queueLine(this, line)));
             }
             catch (error) {
                 callback(error instanceof Error ? error : new Error(String(error)));
                 return;
             }
+            // Emit the trailing partial batch; without this the last rows of a
+            // download (below the batch budget) would be silently dropped.
+            flushBatch(this);
             callback();
         },
     });

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

@@ -1,3 +1,4 @@
+import type { DataikuGetOptions } from "../client.js";
 import type { FlowZone, FlowZoneCreateOptions, FlowZoneObjectType, FlowZoneUpdateOptions } from "../schemas.js";
 import { BaseResource } from "./base.js";
 export type FlowZoneItemInput = {
@@ -6,8 +7,11 @@ export type FlowZoneItemInput = {
     projectKey?: string;
 };
 export declare class FlowZonesResource extends BaseResource {
-    /** List all flow zones in a project. */
-    list(projectKey?: string): Promise<FlowZone[]>;
+    /**
+     * List all flow zones in a project. Pass `timeoutMs` to bound the whole
+     * request (attempts, backoff, and body read) by a total budget.
+     */
+    list(projectKey?: string, options?: DataikuGetOptions): Promise<FlowZone[]>;
     /** Get one flow zone by id. */
     get(zoneId: string, projectKey?: string): Promise<FlowZone>;
     /** Create a flow zone. */

package/dist/src/resources/flow-zones.js

@@ -9,9 +9,12 @@ function normalizeZoneItem(item) {
     };
 }
 export class FlowZonesResource extends BaseResource {
-    /** List all flow zones in a project. */
-    async list(projectKey) {
-        const raw = await this.client.get(`/public/api/projects/${this.enc(projectKey)}/flow/zones`);
+    /**
+     * List all flow zones in a project. Pass `timeoutMs` to bound the whole
+     * request (attempts, backoff, and body read) by a total budget.
+     */
+    async list(projectKey, options) {
+        const raw = await this.client.get(`/public/api/projects/${this.enc(projectKey)}/flow/zones`, options);
         return this.client.safeParse(FlowZoneArraySchema, raw, "flowZones.list");
     }
     /** Get one flow zone by id. */

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

@@ -7,11 +7,13 @@ export interface FutureWaitOptions {
 export declare class FuturesResource extends BaseResource {
     get(futureId: string, opts?: {
         timeoutMs?: number;
+        noRetry?: boolean;
     }): Promise<FutureState>;
     peek(futureId: string): Promise<FutureState>;
     state(futureId: string, opts?: {
         peek?: boolean;
         timeoutMs?: number;
+        noRetry?: boolean;
     }): Promise<FutureState>;
     abort(futureId: string): Promise<void>;
     wait(futureId: string, opts?: FutureWaitOptions): Promise<FutureWaitResult>;

package/dist/src/resources/futures.js

@@ -25,7 +25,11 @@ function waitState(state) {
 }
 export class FuturesResource extends BaseResource {
     async get(futureId, opts = {}) {
-        return this.state(futureId, { peek: false, timeoutMs: opts.timeoutMs, });
+        return this.state(futureId, {
+            peek: false,
+            timeoutMs: opts.timeoutMs,
+            noRetry: opts.noRetry,
+        });
     }
     async peek(futureId) {
         return this.state(futureId, { peek: true, });
@@ -33,7 +37,7 @@ export class FuturesResource extends BaseResource {
     async state(futureId, opts = {}) {
         const params = new URLSearchParams();
         params.set("peek", String(opts.peek === true));
-        const raw = await this.client.get(`/public/api/futures/${encodeURIComponent(futureId)}?${params.toString()}`, { timeoutMs: opts.timeoutMs, });
+        const raw = await this.client.get(`/public/api/futures/${encodeURIComponent(futureId)}?${params.toString()}`, { timeoutMs: opts.timeoutMs, noRetry: opts.noRetry, });
         return this.client.safeParse(FutureStateSchema, raw, "futures.state");
     }
     async abort(futureId) {
@@ -51,16 +55,37 @@ export class FuturesResource extends BaseResource {
         const timeoutMs = Math.max(0, opts.timeoutMs ?? DEFAULT_TIMEOUT_MS);
         const startedAt = Date.now();
         let pollCount = 0;
+        let lastState;
         while (true) {
+            const elapsedBeforeMs = Date.now() - startedAt;
+            // The first observation always happens, even when the budget is
+            // already spent. A later poll is never started after the deadline:
+            // the loop reports the structured timeout from the last observed
+            // state instead of issuing a request the budget cannot cover.
+            if (lastState !== undefined && elapsedBeforeMs >= timeoutMs) {
+                return this.client.safeParse(FutureWaitResultSchema, {
+                    futureId,
+                    jobId: lastState.jobId,
+                    state: waitState(lastState),
+                    elapsedMs: elapsedBeforeMs,
+                    pollCount,
+                    success: false,
+                    timedOut: true,
+                    hasResult: lastState.hasResult === true,
+                    alive: lastState.alive,
+                    aborted: lastState.aborted,
+                    unknown: lastState.unknown,
+                }, "futures.wait");
+            }
             pollCount += 1;
-            // One state observation always happens, even when the budget is
-            // already spent (the poll precedes the deadline check); only the
-            // requests issued while budget remains are bounded by the remaining
-            // time, so a stalled status endpoint can never defeat the deadline.
-            const remainingMs = timeoutMs - (Date.now() - startedAt);
+            // Requests issued while budget remains are bounded by the remaining
+            // time; a spent budget still issues exactly one transport attempt
+            // (no retries, client requestTimeoutMs cap) so the first observation
+            // reaches the server instead of failing before any attempt.
+            const remainingMs = timeoutMs - elapsedBeforeMs;
             let state;
             try {
-                state = await this.get(futureId, remainingMs > 0 ? { timeoutMs: remainingMs, } : undefined);
+                state = await this.get(futureId, remainingMs > 0 ? { timeoutMs: remainingMs, } : { noRetry: true, });
             }
             catch (error) {
                 // The poll budget ran out mid-request: report the structured
@@ -76,6 +101,7 @@ export class FuturesResource extends BaseResource {
                     timedOut: true,
                 }, "futures.wait");
             }
+            lastState = state;
             const elapsedMs = Date.now() - startedAt;
             const status = waitState(state);
             if (isFinished(state)) {
@@ -94,22 +120,10 @@ export class FuturesResource extends BaseResource {
                 };
                 return this.client.safeParse(FutureWaitResultSchema, result, "futures.wait");
             }
-            if (elapsedMs >= timeoutMs) {
-                const result = {
-                    futureId,
-                    jobId: state.jobId,
-                    state: status,
-                    elapsedMs,
-                    pollCount,
-                    success: false,
-                    timedOut: true,
-                    hasResult: state.hasResult === true,
-                    alive: state.alive,
-                    aborted: state.aborted,
-                    unknown: state.unknown,
-                };
-                return this.client.safeParse(FutureWaitResultSchema, result, "futures.wait");
-            }
+            // Deadline reached: the guard at the top of the loop reports the
+            // timeout from this observation without issuing another request.
+            if (elapsedMs >= timeoutMs)
+                continue;
             // Only the remaining budget is slept: a longer sleep would report an
             // elapsed time the caller never authorized.
             const nextDelayMs = computeNextPollDelayMs({

package/dist/src/resources/jobs.js

@@ -289,19 +289,44 @@ export class JobsResource extends BaseResource {
         const timeout = Math.max(baseIntervalMs, opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS);
         const startedAt = Date.now();
         let pollCount = 0;
+        let lastJ;
         while (true) {
+            const elapsedBeforeMs = Date.now() - startedAt;
+            // The first observation always happens, even when the budget is
+            // already spent. A later poll is never started after the deadline:
+            // the loop reports the structured timeout from the last observed
+            // state instead of issuing a request the budget cannot cover.
+            if (lastJ !== undefined && elapsedBeforeMs >= timeout) {
+                const bs = lastJ.baseStatus ?? {};
+                const def = bs.def ?? {};
+                const gs = lastJ.globalState ?? {};
+                return {
+                    success: false,
+                    jobId,
+                    state: bs.state ?? "unknown",
+                    type: def.type ?? "unknown",
+                    elapsedMs: elapsedBeforeMs,
+                    pollCount,
+                    timedOut: true,
+                    progress: {
+                        done: gs.done ?? 0,
+                        failed: gs.failed ?? 0,
+                        running: gs.running ?? 0,
+                        total: gs.total ?? null,
+                    },
+                };
+            }
             pollCount += 1;
-            // One status observation always happens, even when the budget is
-            // already spent (the poll precedes the deadline check); only the
-            // requests issued while budget remains are bounded by the remaining
-            // time, so a stalled status endpoint can never defeat the deadline.
-            const elapsedBefore = Date.now() - startedAt;
-            const remainingMs = timeout - elapsedBefore;
+            // Requests issued while budget remains are bounded by the remaining
+            // time; a spent budget still issues exactly one transport attempt
+            // (no retries, client requestTimeoutMs cap) so the first observation
+            // reaches the server instead of failing before any attempt.
+            const remainingMs = timeout - elapsedBeforeMs;
             let j;
             try {
                 j = await this.client.get(`/public/api/projects/${projectEnc}/jobs/${jobEnc}/`, remainingMs > 0
                     ? { timeoutMs: remainingMs, }
-                    : undefined);
+                    : { noRetry: true, });
             }
             catch (error) {
                 // The poll budget ran out mid-request: report the documented
@@ -325,6 +350,7 @@ export class JobsResource extends BaseResource {
                     },
                 };
             }
+            lastJ = j;
             const bs = j.baseStatus ?? {};
             const def = bs.def ?? {};
             const gs = j.globalState ?? {};
@@ -387,24 +413,10 @@ export class JobsResource extends BaseResource {
                     ...(removed !== undefined ? { removed, } : {}),
                 };
             }
-            // Timeout — return failure result, don't throw
-            if (elapsedMs >= timeout) {
-                return {
-                    success: false,
-                    jobId,
-                    state,
-                    type: def.type ?? "unknown",
-                    elapsedMs,
-                    pollCount,
-                    timedOut: true,
-                    progress: {
-                        done: gs.done ?? 0,
-                        failed: gs.failed ?? 0,
-                        running: gs.running ?? 0,
-                        total: gs.total ?? null,
-                    },
-                };
-            }
+            // Timeout — the guard at the top of the loop returns the failure
+            // result from this observation without issuing another request.
+            if (elapsedMs >= timeout)
+                continue;
             const nextDelayMs = computeNextPollDelayMs({
                 pollCount,
                 baseIntervalMs,

package/dist/src/resources/ml-tasks.js

@@ -117,20 +117,35 @@ export class MlTasksResource extends BaseResource {
         const adaptiveEnabled = explicitIntervalMs === undefined;
         const startedAt = Date.now();
         let pollCount = 0;
-        // One status observation always happens; the poll precedes the deadline
-        // check, so `timeoutMs: 0` still reports the freshly-started state once.
+        let lastStatus;
         while (true) {
+            const elapsedBeforeMs = Date.now() - startedAt;
+            // The first observation always happens, even when the budget is
+            // already spent. A later poll is never started after the deadline:
+            // the loop reports the structured timeout from the last observed
+            // status instead of issuing a request the budget cannot cover.
+            if (lastStatus !== undefined && elapsedBeforeMs >= deadlineMs) {
+                return {
+                    sessionId: session.sessionId,
+                    trainedModelIds: modelIdsFromStatus(lastStatus),
+                    timedOut: true,
+                    success: false,
+                    state: "RUNNING",
+                    elapsedMs: elapsedBeforeMs,
+                    pollCount,
+                };
+            }
             pollCount += 1;
-            // One status observation always happens, even when the budget is
-            // already spent (the poll precedes the deadline check); only the
-            // requests issued while budget remains are bounded by the remaining
-            // time, so a stalled status endpoint can never defeat the deadline.
-            const remainingMs = deadlineMs - (Date.now() - startedAt);
+            // Requests issued while budget remains are bounded by the remaining
+            // time; a spent budget still issues exactly one transport attempt
+            // (no retries, client requestTimeoutMs cap) so the first observation
+            // reaches the server instead of failing before any attempt.
+            const remainingMs = deadlineMs - elapsedBeforeMs;
             let status;
             try {
                 status = await this.client.get(`${this.taskPath(opts.analysisId, opts.mlTaskId, opts.projectKey)}/status`, remainingMs > 0
                     ? { timeoutMs: remainingMs, }
-                    : undefined);
+                    : { noRetry: true, });
             }
             catch (error) {
                 // The poll budget ran out: report the structured timeout instead
@@ -147,19 +162,13 @@ export class MlTasksResource extends BaseResource {
                     pollCount,
                 };
             }
+            lastStatus = status;
             const elapsedMs = Date.now() - startedAt;
             if (status.training !== false) {
-                if (elapsedMs >= deadlineMs) {
-                    return {
-                        sessionId: session.sessionId,
-                        trainedModelIds: modelIdsFromStatus(status),
-                        timedOut: true,
-                        success: false,
-                        state: "RUNNING",
-                        elapsedMs,
-                        pollCount,
-                    };
-                }
+                // Deadline reached: the guard at the top of the loop reports the
+                // timeout from this status without issuing another request.
+                if (elapsedMs >= deadlineMs)
+                    continue;
                 const nextDelayMs = computeNextPollDelayMs({
                     pollCount,
                     baseIntervalMs,

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

@@ -1,5 +1,4 @@
 import { BaseResource } from "./base.js";
-import { validateGitReferencePath } from "./project-git.js";
 /** Summary entry of `/plugins/` as documented (id/version/isDev/meta). */
 export interface PluginSummary {
     id: string;
@@ -262,4 +261,3 @@ export declare function validatedPluginGitUrl(repository: string, field?: string
  * CLI to decide which actions need a plugin id positional.
  */
 export declare function isPluginIdCandidate(value: unknown): boolean;
-export { validateGitReferencePath, };

package/dist/src/resources/plugins.js

@@ -1,6 +1,5 @@
 import { ClientValidationError, DataikuError, } from "../errors.js";
 import { BaseResource, requireNonEmpty, } from "./base.js";
-import { validateGitReferencePath, } from "./project-git.js";
 /* ------------------------------------------------------------------ */
 /*  Path helpers                                                       */
 /* ------------------------------------------------------------------ */
@@ -454,5 +453,3 @@ export function validatedPluginGitUrl(repository, field = "Git repository URL")
 export function isPluginIdCandidate(value) {
     return typeof value === "string" && PLUGIN_ID_PATTERN.test(value);
 }
-// Re-exported for CLI consumers so a single import site covers path rules.
-export { validateGitReferencePath, };

package/dist/src/resources/project-git.d.ts

@@ -68,23 +68,17 @@ export interface ProjectGitFutureStateOptions {
      * loops that must not hang on a stalled endpoint.
      */
     timeoutMs?: number;
+    /**
+     * Issue exactly one transport attempt (no retries). Independent of
+     * `timeoutMs`: when both are supplied the total budget still applies. Used
+     * by the wait loop for the one observation whose wait budget is spent.
+     */
+    noRetry?: boolean;
 }
 export interface ProjectGitFutureWaitOptions {
     pollIntervalMs?: number;
     timeoutMs?: number;
 }
-/**
- * Validate and canonicalize a Git library reference path. This is the single
- * validator used by both SDK dispatch and CLI mutation planning.
- *
- * Strip only the permitted outer '/' separators, then require nonempty
- * ordinary segments: no empty segments and no '.' or '..' segments. A hostile
- * path therefore cannot change which API resource a dispatcher's URL
- * normalization would otherwise select.
- */
-export declare function validateGitReferencePath(path: string): string;
-/** Validate a Git library reference path and URL-encode it per segment. */
-export declare function encodeGitReferencePath(path: string): string;
 export declare class ProjectGitResource extends BaseResource {
     /** Working-copy status: current branch, remotes, tracking counts, changes. */
     status(projectKey: string): Promise<ProjectGitStatus>;

package/dist/src/resources/project-git.js

@@ -1,5 +1,6 @@
 import { ClientValidationError, } from "../errors.js";
 import { ProjectGitActionResultSchema, ProjectGitDiffResultSchema, ProjectGitFutureResponseSchema, ProjectGitFutureStateSchema, ProjectGitLibrariesSchema, ProjectGitLogResultSchema, ProjectGitRemoteSchema, ProjectGitStatusSchema, ProjectGitTagsSchema, } from "../schemas.js";
+import { encodeGitReferencePath, validateGitReferencePath, } from "../utils/git-reference.js";
 import { computeNextPollDelayMs, isRequestDeadlineError, } from "../utils/polling.js";
 import { sanitizeErrorSecrets, } from "../utils/secret-sanitize.js";
 import { BaseResource, } from "./base.js";
@@ -19,43 +20,6 @@ function sleep(ms) {
     setTimeout(resolve, ms);
     return promise;
 }
-function gitReferencePathError(path, message) {
-    return new ClientValidationError(message, "validation_failed", "Use a Git library reference path relative to the project library root: '/' -separated segment names, with no '.' or '..' segments.", { path, });
-}
-/**
- * Validate and canonicalize a Git library reference path. This is the single
- * validator used by both SDK dispatch and CLI mutation planning.
- *
- * Strip only the permitted outer '/' separators, then require nonempty
- * ordinary segments: no empty segments and no '.' or '..' segments. A hostile
- * path therefore cannot change which API resource a dispatcher's URL
- * normalization would otherwise select.
- */
-export function validateGitReferencePath(path) {
-    if (typeof path !== "string" || path.trim() === "") {
-        throw gitReferencePathError(path, "A Git library reference path is required.");
-    }
-    const normalized = path.replace(/^\/+/, "").replace(/\/+$/, "");
-    if (normalized === "") {
-        throw gitReferencePathError(path, "A Git library reference path is required.");
-    }
-    for (const segment of normalized.split("/")) {
-        if (segment === "") {
-            throw gitReferencePathError(path, "A Git library reference path must not contain empty segments (consecutive or repeated '/').");
-        }
-        if (segment === "." || segment === "..") {
-            throw gitReferencePathError(path, "A Git library reference path must not contain '.' or '..' segments.");
-        }
-    }
-    return normalized;
-}
-/** Validate a Git library reference path and URL-encode it per segment. */
-export function encodeGitReferencePath(path) {
-    return validateGitReferencePath(path)
-        .split("/")
-        .map((segment) => encodeURIComponent(segment))
-        .join("/");
-}
 /**
  * Reject `https://user:token@host/repo` before it reaches DSS: an embedded
  * secret would be stored in the project's Git configuration and echoed back by
@@ -364,7 +328,7 @@ export class ProjectGitResource extends BaseResource {
      * what polling loops want; the default consumes it like the Python client.
      */
     async getFutureState(jobId, options = {}) {
-        const raw = await this.request("GET", `/futures/${encodeURIComponent(jobId)}${this.query({ peek: options.peek === true, })}`, undefined, [], { timeoutMs: options.timeoutMs, });
+        const raw = await this.request("GET", `/futures/${encodeURIComponent(jobId)}${this.query({ peek: options.peek === true, })}`, undefined, [], { timeoutMs: options.timeoutMs, noRetry: options.noRetry, });
         return this.client.safeParse(ProjectGitFutureStateSchema, raw ?? {}, "projectGit.getFutureState");
     }
     /** Abort a running future. */
@@ -389,14 +353,23 @@ export class ProjectGitResource extends BaseResource {
         // interval; an explicit pollIntervalMs is an exact contract.
         const adaptiveEnabled = options.pollIntervalMs === undefined;
         let pollCount = 0;
+        let lastState;
         const startedAt = Date.now();
         while (true) {
+            const elapsedBeforeMs = Date.now() - startedAt;
+            // The first observation always happens, even when the budget is
+            // already spent. A later poll is never started after the deadline:
+            // the loop reports the documented timeout from the last observed
+            // state instead of issuing a request the budget cannot cover.
+            if (lastState !== undefined && elapsedBeforeMs >= timeoutMs) {
+                throw new Error(`Timed out after ${String(elapsedBeforeMs)}ms waiting for Dataiku future ${jobId}`);
+            }
             // Unlike peek state, the ordinary state includes the completed result.
-            // One state observation always happens, even when the budget is
-            // already spent (the poll precedes the deadline check); only the
-            // requests issued while budget remains are bounded by the remaining
-            // time, so a stalled endpoint can never defeat the caller's deadline.
-            const remainingMs = timeoutMs - (Date.now() - startedAt);
+            // Requests issued while budget remains are bounded by the remaining
+            // time; a spent budget still issues exactly one transport attempt
+            // (no retries, client requestTimeoutMs cap) so the first observation
+            // reaches the server instead of failing before any attempt.
+            const remainingMs = timeoutMs - elapsedBeforeMs;
             pollCount += 1;
             let state;
             try {
@@ -405,7 +378,7 @@ export class ProjectGitResource extends BaseResource {
                         peek: false,
                         timeoutMs: remainingMs,
                     }
-                    : { peek: false, });
+                    : { peek: false, noRetry: true, });
             }
             catch (error) {
                 // The poll budget ran out mid-request: report the documented
@@ -415,6 +388,7 @@ export class ProjectGitResource extends BaseResource {
                     throw error;
                 throw new Error(`Timed out after ${String(Date.now() - startedAt)}ms waiting for Dataiku future ${jobId}`, { cause: error, });
             }
+            lastState = state;
             const failure = describeFutureFailure(state.error);
             if (failure !== undefined) {
                 throw new Error(`Dataiku future ${jobId} failed: ${failure}`);
@@ -431,9 +405,10 @@ export class ProjectGitResource extends BaseResource {
                 throw new Error(`Dataiku future ${jobId} ended without producing a result`);
             }
             const elapsedMs = Date.now() - startedAt;
-            if (elapsedMs >= timeoutMs) {
-                throw new Error(`Timed out after ${String(elapsedMs)}ms waiting for Dataiku future ${jobId}`);
-            }
+            // Deadline reached: the guard at the top of the loop reports the
+            // timeout from this observation without issuing another request.
+            if (elapsedMs >= timeoutMs)
+                continue;
             const nextDelayMs = computeNextPollDelayMs({
                 pollCount,
                 baseIntervalMs: pollIntervalMs,
@@ -466,7 +441,7 @@ export class ProjectGitResource extends BaseResource {
     }
     async request(method, path, body, secrets = [], opts = {}) {
         try {
-            const res = await this.client.requestGit(method, `${GIT_API_BASE}${path}`, body, opts.timeoutMs === undefined ? undefined : Date.now() + opts.timeoutMs);
+            const res = await this.client.requestGit(method, `${GIT_API_BASE}${path}`, body, opts.timeoutMs === undefined ? undefined : Date.now() + opts.timeoutMs, opts.noRetry === true);
             const text = await res.text();
             if (text.trim() === "")
                 return undefined;

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

@@ -150,8 +150,10 @@ export declare class ProjectsResource extends BaseResource {
      * Build a normalized, optionally truncated flow map for a project.
      *
      * Fetches the flow graph and supplementary metadata (datasets, recipes,
-     * managed folders) in parallel. Folder name resolution uses a timeout
-     * to avoid blocking when the folders endpoint is slow.
+     * managed folders) in parallel. Each metadata fetch runs under a total
+     * `timeoutMs` budget: when the budget expires the in-flight request is
+     * aborted and the map is returned without that metadata, reported as a
+     * warning.
      */
     map(opts?: FlowMapOptions & {
         projectKey?: string;