dataiku-sdk 3.1.0 → 3.3.0

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

@@ -1,5 +1,7 @@
-import { ClientValidationError, DataikuError, } from "../errors.js";
+import { ClientValidationError, } from "../errors.js";
 import { ProjectGitActionResultSchema, ProjectGitDiffResultSchema, ProjectGitFutureResponseSchema, ProjectGitFutureStateSchema, ProjectGitLibrariesSchema, ProjectGitLogResultSchema, ProjectGitRemoteSchema, ProjectGitStatusSchema, ProjectGitTagsSchema, } from "../schemas.js";
+import { computeNextPollDelayMs, isRequestDeadlineError, } from "../utils/polling.js";
+import { sanitizeErrorSecrets, } from "../utils/secret-sanitize.js";
 import { BaseResource, } from "./base.js";
 /**
  * The per-project Git routes exist only under the dataikuapi base, not under
@@ -89,28 +91,10 @@ function validatedRepository(repository, field) {
     return candidate;
 }
 /** Replace every exact occurrence of a secret so echoed errors cannot leak it. */
-function redactSecrets(text, secrets) {
-    let result = text;
-    for (const secret of secrets) {
-        if (secret !== undefined && secret !== "") {
-            result = result.split(secret).join("[redacted]");
-        }
-    }
-    return result;
-}
-/**
- * Strip a password that a server misconfiguration may have echoed from an
- * error response. `DataikuError.message` was built at construction, so the
- * raw body, the message, and the stack all need scrubbing.
- */
 function scrubErrorSecrets(error, secrets) {
-    if (!(error instanceof DataikuError) || secrets.length === 0)
+    if (secrets.length === 0)
         return;
-    error.body = redactSecrets(error.body, secrets);
-    error.message = redactSecrets(error.message, secrets);
-    if (typeof error.stack === "string") {
-        error.stack = redactSecrets(error.stack, secrets);
-    }
+    sanitizeErrorSecrets(error, { sensitiveKeys: {}, secrets, });
 }
 function describeFutureFailure(error) {
     if (error === undefined || error === null)
@@ -129,6 +113,31 @@ function describeFutureFailure(error) {
     return String(error);
 }
 /* ------------------------------------------------------------------ */
+/**
+ * DSS answers the lib-git-refs listing as an object map of attached external
+ * libraries keyed by target path alongside code-library metadata (observed
+ * raw on DSS 15: `{gitReferences, pythonPath, rsrcPath,
+ * importLibrariesFromProjects}`), while the official Python client and this
+ * resource's typed contract expose a plain array. Normalize the map into
+ * entries, preserving each key as the library's `localTargetPath`; a bare
+ * array passes through untouched.
+ */
+function normalizeLibraryList(raw) {
+    if (Array.isArray(raw) || raw === undefined || raw === null)
+        return raw ?? [];
+    if (typeof raw !== "object")
+        return raw;
+    const record = raw;
+    const refs = record["gitReferences"];
+    if (refs === undefined || refs === null || typeof refs !== "object" || Array.isArray(refs)) {
+        return raw;
+    }
+    return Object.entries(refs).map(([localTargetPath, spec,]) => ({
+        localTargetPath,
+        ...(typeof spec === "object" && spec !== null ? spec : {}),
+    }));
+}
+/* ------------------------------------------------------------------ */
 /*  Resource                                                          */
 /* ------------------------------------------------------------------ */
 export class ProjectGitResource extends BaseResource {
@@ -287,7 +296,7 @@ export class ProjectGitResource extends BaseResource {
     /* ---- external libraries (async futures) ---- */
     async listLibraries(projectKey) {
         const raw = await this.request("GET", `${this.libraryPath(projectKey)}/`);
-        return this.client.safeParse(ProjectGitLibrariesSchema, raw ?? [], "projectGit.listLibraries");
+        return this.client.safeParse(ProjectGitLibrariesSchema, normalizeLibraryList(raw), "projectGit.listLibraries");
     }
     /** Attach an external Git library. Runs as a DSS future. */
     async addLibrary(projectKey, options) {
@@ -355,7 +364,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, })}`);
+        const raw = await this.request("GET", `/futures/${encodeURIComponent(jobId)}${this.query({ peek: options.peek === true, })}`, undefined, [], { timeoutMs: options.timeoutMs, });
         return this.client.safeParse(ProjectGitFutureStateSchema, raw ?? {}, "projectGit.getFutureState");
     }
     /** Abort a running future. */
@@ -376,10 +385,36 @@ export class ProjectGitResource extends BaseResource {
         if (!Number.isFinite(timeoutMs) || timeoutMs < 0) {
             throw new ClientValidationError("timeoutMs must be a finite non-negative number.");
         }
+        // Adaptive backoff applies only when the caller did not pin an exact
+        // interval; an explicit pollIntervalMs is an exact contract.
+        const adaptiveEnabled = options.pollIntervalMs === undefined;
+        let pollCount = 0;
         const startedAt = Date.now();
         while (true) {
             // Unlike peek state, the ordinary state includes the completed result.
-            const state = await this.getFutureState(jobId, { peek: false, });
+            // 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);
+            pollCount += 1;
+            let state;
+            try {
+                state = await this.getFutureState(jobId, remainingMs > 0
+                    ? {
+                        peek: false,
+                        timeoutMs: remainingMs,
+                    }
+                    : { peek: false, });
+            }
+            catch (error) {
+                // The poll budget ran out mid-request: report the documented
+                // timeout failure instead of letting the transport deadline
+                // error escape.
+                if (!isRequestDeadlineError(error, startedAt + timeoutMs))
+                    throw error;
+                throw new Error(`Timed out after ${String(Date.now() - startedAt)}ms waiting for Dataiku future ${jobId}`, { cause: error, });
+            }
             const failure = describeFutureFailure(state.error);
             if (failure !== undefined) {
                 throw new Error(`Dataiku future ${jobId} failed: ${failure}`);
@@ -395,13 +430,18 @@ export class ProjectGitResource extends BaseResource {
             if (state.alive === false) {
                 throw new Error(`Dataiku future ${jobId} ended without producing a result`);
             }
-            // Only the remaining budget is slept, so a caller's deadline is never
-            // overshot by a whole poll interval.
             const elapsedMs = Date.now() - startedAt;
             if (elapsedMs >= timeoutMs) {
                 throw new Error(`Timed out after ${String(elapsedMs)}ms waiting for Dataiku future ${jobId}`);
             }
-            await sleep(Math.min(pollIntervalMs, timeoutMs - elapsedMs));
+            const nextDelayMs = computeNextPollDelayMs({
+                pollCount,
+                baseIntervalMs: pollIntervalMs,
+                adaptiveEnabled,
+            });
+            // Only the remaining budget is slept, so a caller's deadline is never
+            // overshot by a whole interval.
+            await sleep(Math.min(nextDelayMs, timeoutMs - elapsedMs));
         }
     }
     /* ---- private ---- */
@@ -424,22 +464,9 @@ export class ProjectGitResource extends BaseResource {
         const queryString = search.toString();
         return queryString === "" ? "" : `?${queryString}`;
     }
-    async request(method, path, body, secrets = []) {
-        const transport = this.client;
-        const init = {
-            method,
-            headers: {
-                // The Git routes are only reachable with dataikuapi-style Basic auth:
-                // API key as the username, empty password.
-                Authorization: `Basic ${Buffer.from(`${transport.apiKey}:`, "utf8").toString("base64")}`,
-                Accept: "application/json",
-                "Content-Type": "application/json",
-            },
-        };
-        if (body !== undefined)
-            init.body = JSON.stringify(body);
+    async request(method, path, body, secrets = [], opts = {}) {
         try {
-            const res = await transport.fetchWithRetry(`${transport.baseUrl}${GIT_API_BASE}${path}`, init);
+            const res = await this.client.requestGit(method, `${GIT_API_BASE}${path}`, body, opts.timeoutMs === undefined ? undefined : Date.now() + opts.timeoutMs);
             const text = await res.text();
             if (text.trim() === "")
                 return undefined;

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

@@ -147,7 +147,6 @@ export declare class ProjectLibraryResource extends BaseResource {
     /** Move a project code-library file or folder into another library folder. */
     move(path: string, destinationFolderPath: string, projectKey?: string): Promise<void>;
     private contentsPath;
-    private postRawBody;
     private alreadyExistsError;
     private assertLibraryFileAbsent;
 }

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

@@ -403,7 +403,7 @@ export class ProjectLibraryResource extends BaseResource {
         }
         const bytes = typeof content === "string" ? Buffer.from(content, "utf8") : content;
         const sha256 = sha256Hex(bytes);
-        await this.postRawBody(this.contentsPath(valid, projectKey), content);
+        await this.client.postRawBody(this.contentsPath(valid, projectKey), content);
         return {
             path: valid,
             bytes: bytes.length,
@@ -518,22 +518,6 @@ export class ProjectLibraryResource extends BaseResource {
         const projectKeyPart = this.enc(projectKey);
         return `/public/api/projects/${projectKeyPart}/libraries/contents/${encodeLibraryPath(path)}`;
     }
-    async postRawBody(path, body) {
-        // DSS library writes use dataikuapi's raw_body; route through the client's
-        // transport so auth, retries, TLS options, and DSS error handling stay aligned.
-        // BodyInit rejects plain Uint8Array views, so non-Buffer bytes are copied
-        // into a Buffer (an ArrayBufferView BodyInit accepts).
-        const payload = body instanceof Uint8Array && !(body instanceof Buffer)
-            ? Buffer.from(body.buffer, body.byteOffset, body.byteLength)
-            : body;
-        const rawClient = this.client;
-        const res = await rawClient.fetchWithRetry(`${rawClient.baseUrl}${path}`, {
-            method: "POST",
-            headers: rawClient.getAnyHeaders(),
-            body: payload,
-        });
-        await res.text();
-    }
     alreadyExistsError(path) {
         return new ClientValidationError(`Project library item "${path}" already exists.`, "validation_failed", "Refuse to overwrite an existing item; delete it first, or use the create-or-replace update to replace an existing file.", { path, });
     }

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

@@ -1,4 +1,4 @@
-import type { FlowMapOptions, ProjectDetails, ProjectMetadata, ProjectSummary } from "../schemas.js";
+import type { FlowMapOptions, ProjectDetails, ProjectMetadata, ProjectSummary, ProjectTags } from "../schemas.js";
 import type { AnalyzedFlowMap, FlowMapRendering } from "../utils/flow-analysis.js";
 import { BaseResource } from "./base.js";
 interface FlowMapTruncationSummary {
@@ -87,8 +87,6 @@ export interface ProjectImportResult extends ProjectImportProcessResult {
     projectIncarnationHash?: string;
 }
 export declare class ProjectsResource extends BaseResource {
-    private httpInternals;
-    private postStream;
     /** Create a new project. */
     createProject(projectKey: string, name: string, ownerLogin: string, settings?: ProjectLifecycleSettings | null): Promise<Record<string, unknown>>;
     /** Delete a project using the lifecycle endpoint. */
@@ -126,6 +124,24 @@ export declare class ProjectsResource extends BaseResource {
     get(projectKey?: string): Promise<ProjectDetails>;
     /** Get metadata (tags, custom fields, checklists) for a project. */
     metadata(projectKey?: string): Promise<ProjectMetadata>;
+    /**
+     * Replace project metadata with the supplied full object.
+     *
+     * DSS PUT semantics replace the whole metadata object: pass a metadata
+     * object obtained from {@link metadata}, edit it, and send it back — fields
+     * absent from the payload are removed from the project.
+     */
+    setMetadata(projectKey: string | undefined, metadata: ProjectMetadata): Promise<void>;
+    /** Get project-level tags (tag name → {color?}). */
+    tags(projectKey?: string): Promise<ProjectTags>;
+    /**
+     * Replace project-level tags with the supplied full object.
+     *
+     * DSS PUT semantics replace the whole tags dictionary: pass a tags object
+     * obtained from {@link tags}, edit it, and send it back — tags absent from
+     * the payload are removed from the project.
+     */
+    setTags(projectKey: string | undefined, tags: ProjectTags): Promise<void>;
     /** Get the raw flow graph for a project. */
     flow(projectKey?: string): Promise<unknown>;
     /** Compute a stable fingerprint of flow nodes and edges, excluding visual metadata. */

package/dist/src/resources/projects.js

@@ -1,5 +1,6 @@
 import { ClientValidationError, DataikuError, } from "../errors.js";
-import { ProjectDetailsSchema, ProjectMetadataSchema, ProjectSummaryArraySchema, } from "../schemas.js";
+import { writeResponseToFile, } from "../utils/response-file.js";
+import { ProjectDetailsSchema, ProjectMetadataSchema, ProjectSummaryArraySchema, ProjectTagsSchema, } from "../schemas.js";
 import { analyzeFlowMap, flowTopologyFingerprint, renderFlowMap, } from "../utils/flow-analysis.js";
 import { normalizeFlowGraph, } from "../utils/flow-map.js";
 import { assertImportableProjectArchive, } from "../utils/project-archive.js";
@@ -104,21 +105,6 @@ const DEFAULT_MAX_EDGES = 600;
 const DEFAULT_METADATA_TIMEOUT_MS = 1_500;
 const PROJECT_IMPORT_AMBIGUOUS_REMEDIATION = "Import processing left DSS state indeterminate. Inspect the archive with `dss project inspect-archive <file>` and the live projects with `dss project list` before retrying the import.";
 export class ProjectsResource extends BaseResource {
-    httpInternals() {
-        return this.client;
-    }
-    async postStream(path, body) {
-        const http = this.httpInternals();
-        return http.fetchWithRetry(`${http.baseUrl}${path}`, {
-            method: "POST",
-            headers: {
-                Authorization: `Bearer ${http.apiKey}`,
-                Accept: "*/*",
-                "Content-Type": "application/json",
-            },
-            body: JSON.stringify(body),
-        });
-    }
     /** Create a new project. */
     async createProject(projectKey, name, ownerLogin, settings) {
         return this.client.post("/public/api/projects/", {
@@ -155,10 +141,10 @@ export class ProjectsResource extends BaseResource {
     }
     /** Export a project archive to a local file. */
     async exportArchive(projectKey, filePath, options) {
-        const res = await this.postStream(`/public/api/projects/${encodeURIComponent(projectKey)}/export`, options ?? {});
+        const res = await this.client.postStream(`/public/api/projects/${encodeURIComponent(projectKey)}/export`, options ?? {});
         if (!res.body)
             throw new Error("projects.exportArchive response did not include a body");
-        await Bun.write(filePath, new Response(res.body), { createPath: false, });
+        await writeResponseToFile(filePath, res);
     }
     /** Upload a project archive and return its temporary import handle. */
     async prepareProjectImport(filePath) {
@@ -316,6 +302,32 @@ export class ProjectsResource extends BaseResource {
         const raw = await this.client.get(`/public/api/projects/${enc}/metadata`);
         return this.client.safeParse(ProjectMetadataSchema, raw, "projects.metadata");
     }
+    /**
+     * Replace project metadata with the supplied full object.
+     *
+     * DSS PUT semantics replace the whole metadata object: pass a metadata
+     * object obtained from {@link metadata}, edit it, and send it back — fields
+     * absent from the payload are removed from the project.
+     */
+    async setMetadata(projectKey, metadata) {
+        await this.client.putVoid(`/public/api/projects/${this.enc(projectKey)}/metadata`, metadata);
+    }
+    /** Get project-level tags (tag name → {color?}). */
+    async tags(projectKey) {
+        const enc = this.enc(projectKey);
+        const raw = await this.client.get(`/public/api/projects/${enc}/tags`);
+        return this.client.safeParse(ProjectTagsSchema, raw, "projects.tags");
+    }
+    /**
+     * Replace project-level tags with the supplied full object.
+     *
+     * DSS PUT semantics replace the whole tags dictionary: pass a tags object
+     * obtained from {@link tags}, edit it, and send it back — tags absent from
+     * the payload are removed from the project.
+     */
+    async setTags(projectKey, tags) {
+        await this.client.putVoid(`/public/api/projects/${this.enc(projectKey)}/tags`, tags);
+    }
     /** Get the raw flow graph for a project. */
     async flow(projectKey) {
         const enc = this.enc(projectKey);

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

@@ -1,4 +1,4 @@
-import type { BuildMode, JobWaitResult, RecipeCreateOptions, RecipeCreateResult, RecipeSummary } from "../schemas.js";
+import type { BuildMode, JobWaitResult, ProjectMetadata, RecipeCreateOptions, RecipeCreateResult, RecipeSummary } from "../schemas.js";
 import { BaseResource } from "./base.js";
 import type { JobBuildTarget, JobBuildTargetType, JobLogFilter, JobLogSummary } from "./jobs.js";
 export interface RecipeRunOutput extends JobBuildTarget {
@@ -68,6 +68,20 @@ export interface RecipeCloneResult {
 export declare class RecipesResource extends BaseResource {
     /** List all recipes in a project. */
     list(projectKey?: string): Promise<RecipeSummary[]>;
+    /** Get recipe metadata (label, tags, description, custom fields). */
+    metadata(recipeName: string, opts?: {
+        projectKey?: string;
+    }): Promise<ProjectMetadata>;
+    /**
+     * Replace recipe metadata with the supplied full object.
+     *
+     * DSS PUT semantics replace the whole metadata object: pass a metadata
+     * object obtained from {@link metadata}, edit it, and send it back — fields
+     * absent from the payload are removed from the recipe.
+     */
+    setMetadata(recipeName: string, metadata: ProjectMetadata, opts?: {
+        projectKey?: string;
+    }): Promise<void>;
     /**
      * Get a recipe definition (and optionally its payload).
      * Returns the raw API response shape: `{ recipe, payload }`.

package/dist/src/resources/recipes.js

@@ -1,7 +1,7 @@
 import { writeFile, } from "node:fs/promises";
 import { resolve, } from "node:path";
 import { DataikuError, } from "../errors.js";
-import { RecipeSummaryArraySchema, } from "../schemas.js";
+import { ProjectMetadataSchema, RecipeSummaryArraySchema, } from "../schemas.js";
 import { deepMerge, } from "../utils/deep-merge.js";
 import { sanitizeFileName, } from "../utils/sanitize.js";
 import { BaseResource, } from "./base.js";
@@ -95,6 +95,8 @@ function normalizeRecipeOutputType(value) {
         return "DATASET";
     if (normalized === "MANAGED_FOLDER" || normalized === "FOLDER")
         return "MANAGED_FOLDER";
+    if (normalized === "MODEL_EVALUATION_STORE")
+        return "MODEL_EVALUATION_STORE";
     return undefined;
 }
 function recipeOutputItems(recipe) {
@@ -116,7 +118,12 @@ function recipeOutputItems(recipe) {
             if (seen.has(seenKey))
                 continue;
             seen.add(seenKey);
-            const type = normalizeRecipeOutputType(item?.type ?? item?.targetType ?? item?.objectType);
+            // The evaluation recipe's "evaluationStore" role targets a model
+            // evaluation store even when the item carries no explicit type
+            // (recipe.py EvaluationRecipeCreator.with_output_evaluation_store);
+            // the store is a valid job target (run object_type_map).
+            const type = normalizeRecipeOutputType(item?.type ?? item?.targetType ?? item?.objectType)
+                ?? (role === "evaluationStore" ? "MODEL_EVALUATION_STORE" : undefined);
             result.push({
                 ref,
                 role,
@@ -292,6 +299,25 @@ export class RecipesResource extends BaseResource {
         const raw = await this.client.get(`/public/api/projects/${enc}/recipes/`);
         return this.client.safeParse(RecipeSummaryArraySchema, raw, "recipes.list");
     }
+    /** Get recipe metadata (label, tags, description, custom fields). */
+    async metadata(recipeName, opts) {
+        const enc = this.enc(opts?.projectKey);
+        const rnEnc = encodeURIComponent(recipeName);
+        const raw = await this.client.get(`/public/api/projects/${enc}/recipes/${rnEnc}/metadata`);
+        return this.client.safeParse(ProjectMetadataSchema, raw, "recipes.metadata");
+    }
+    /**
+     * Replace recipe metadata with the supplied full object.
+     *
+     * DSS PUT semantics replace the whole metadata object: pass a metadata
+     * object obtained from {@link metadata}, edit it, and send it back — fields
+     * absent from the payload are removed from the recipe.
+     */
+    async setMetadata(recipeName, metadata, opts) {
+        const enc = this.enc(opts?.projectKey);
+        const rnEnc = encodeURIComponent(recipeName);
+        await this.client.putVoid(`/public/api/projects/${enc}/recipes/${rnEnc}/metadata`, metadata);
+    }
     /**
      * Get a recipe definition (and optionally its payload).
      * Returns the raw API response shape: `{ recipe, payload }`.
@@ -320,11 +346,13 @@ export class RecipesResource extends BaseResource {
         const { recipe, } = await this.get(recipeName, { projectKey: pk, });
         const inputItems = recipeInputItems(recipe);
         const outputItems = recipeOutputItems(recipe);
-        const [datasets, folders,] = await Promise.all([
+        const [datasets, folders, stores,] = await Promise.all([
             this.client.datasets.list(pk),
             this.client.folders.list(pk),
+            this.client.modelEvaluationStores.list(pk),
         ]);
         const datasetNames = new Set(datasets.map((dataset) => dataset.name));
+        const storeIds = new Set(stores.map((store) => store.id));
         const folderIdByRef = new Map();
         for (const folder of folders) {
             folderIdByRef.set(folder.id, folder.id);
@@ -337,6 +365,15 @@ export class RecipesResource extends BaseResource {
             if (item.type === "DATASET") {
                 return { ref: item.ref, role: item.role, type: "DATASET", exists: isDataset, id: item.ref, };
             }
+            if (item.type === "MODEL_EVALUATION_STORE") {
+                return {
+                    ref: item.ref,
+                    role: item.role,
+                    type: "MODEL_EVALUATION_STORE",
+                    exists: storeIds.has(item.ref),
+                    id: item.ref,
+                };
+            }
             if (item.type === "MANAGED_FOLDER") {
                 return {
                     ref: item.ref,
@@ -420,6 +457,19 @@ export class RecipesResource extends BaseResource {
                     partition: opts?.partition,
                 };
             }
+            if (item.type === "MODEL_EVALUATION_STORE") {
+                // The store id is the target id; evaluation builds into the store
+                // exactly like the official client (recipe.run maps
+                // COMPUTABLE_MODEL_EVALUATION_STORE -> MODEL_EVALUATION_STORE).
+                return {
+                    ref: item.ref,
+                    role: item.role,
+                    id: item.ref,
+                    type: "MODEL_EVALUATION_STORE",
+                    projectKey: pk,
+                    partition: opts?.partition,
+                };
+            }
             const folderId = folderIdByRef.get(item.ref);
             if (item.type === "MANAGED_FOLDER") {
                 return {
@@ -632,10 +682,22 @@ export class RecipesResource extends BaseResource {
                 }
             }
         };
+        let finalRecipeName;
+        // DSS renames some recipe types server-side (e.g. prediction_scoring
+        // becomes "score_<inputDataset>") and documents the creation response as
+        // the final unique name: Body {"name": "recipe1"} ("Returns the final
+        // unique name of the recipe"). The response name is the contract —
+        // falling back to the requested name would mask a missing/invalid
+        // receipt, so a body without it is an error.
         try {
             if (rawConnection)
                 await provisionOutputDatasets();
-            await createRecipe();
+            const created = await createRecipe();
+            const receivedName = asString(created?.["name"]);
+            if (!receivedName) {
+                throw new Error('DSS create-recipe response did not include the final recipe name (documented body: {"name": ...}).');
+            }
+            finalRecipeName = receivedName;
         }
         catch (error) {
             if (!shouldRetryRecipeCreateWithOutputProvisioning(error)) {
@@ -643,7 +705,12 @@ export class RecipesResource extends BaseResource {
             }
             usedOutputProvisioningFallback = true;
             await provisionOutputDatasets();
-            await createRecipe();
+            const retryCreated = await createRecipe();
+            const retryName = asString(retryCreated?.["name"]);
+            if (!retryName) {
+                throw new Error('DSS create-recipe response did not include the final recipe name (documented body: {"name": ...}).', { cause: error, });
+            }
+            finalRecipeName = retryName;
         }
         // For sync recipes (a 1:1 copy) DSS does not propagate schema on build, so a
         // schemaless dataset output silently builds to an empty dataset. Copy the
@@ -781,7 +848,7 @@ export class RecipesResource extends BaseResource {
             }
         }
         return {
-            recipeName: name,
+            recipeName: finalRecipeName,
             type,
             createdDatasets,
             joinConfigured,