dataiku-sdk 3.2.0 → 3.4.0

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

@@ -1,5 +1,8 @@
-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 { 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";
 /**
  * The per-project Git routes exist only under the dataikuapi base, not under
@@ -17,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
@@ -89,28 +55,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 +77,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 +260,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 +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, })}`);
+        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. */
@@ -376,10 +349,46 @@ 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;
+        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.
-            const state = await this.getFutureState(jobId, { peek: false, });
+            // 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 {
+                state = await this.getFutureState(jobId, remainingMs > 0
+                    ? {
+                        peek: false,
+                        timeoutMs: remainingMs,
+                    }
+                    : { peek: false, noRetry: true, });
+            }
+            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, });
+            }
+            lastState = state;
             const failure = describeFutureFailure(state.error);
             if (failure !== undefined) {
                 throw new Error(`Dataiku future ${jobId} failed: ${failure}`);
@@ -395,13 +404,19 @@ 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));
+            // 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,
+                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 +439,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, opts.noRetry === true);
             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 {
@@ -124,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. */
@@ -132,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;

package/dist/src/resources/projects.js

@@ -1,39 +1,37 @@
 import { ClientValidationError, DataikuError, } from "../errors.js";
+import { isRequestDeadlineError, } from "../utils/polling.js";
 import { writeResponseToFile, } from "../utils/response-file.js";
-import { ProjectDetailsSchema, ProjectMetadataSchema, ProjectSummaryArraySchema, } from "../schemas.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";
 import { projectIncarnationHash, } from "../utils/project-incarnation.js";
 import { BaseResource, } from "./base.js";
-function fetchWithTimeout(label, timeoutMs, fetcher) {
-    return new Promise((resolve) => {
-        let settled = false;
-        const timer = setTimeout(() => {
-            if (settled)
-                return;
-            settled = true;
-            resolve({
+/**
+ * Runs an optional metadata fetch under a total budget. The fetcher receives
+ * the client GET options and must pass `timeoutMs` through to its request, so
+ * the client owns the deadline: the in-flight request is aborted when the
+ * budget expires and no further retry is started afterwards. Expiry of the
+ * total budget resolves to a warning so the map still returns; an earlier
+ * per-request failure is reported as "unavailable" (classified with the same
+ * deadline check the wait loops use).
+ */
+async function fetchWithTimeout(label, timeoutMs, fetcher) {
+    const deadlineAt = Date.now() + timeoutMs;
+    try {
+        return { value: await fetcher({ timeoutMs, }), };
+    }
+    catch (error) {
+        if (isRequestDeadlineError(error, deadlineAt)) {
+            return {
                 warning: `${label} metadata timed out after ${timeoutMs}ms; continuing without it.`,
-            });
-        }, timeoutMs);
-        fetcher().then((value) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timer);
-            resolve({ value, });
-        }, (error) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timer);
-            const detail = error instanceof Error ? error.message : String(error);
-            resolve({
-                warning: `${label} metadata unavailable: ${detail}`,
-            });
-        });
-    });
+            };
+        }
+        const detail = error instanceof Error ? error.message : String(error);
+        return {
+            warning: `${label} metadata unavailable: ${detail}`,
+        };
+    }
 }
 function computeRootsAndLeaves(nodes, edges) {
     const inDegree = new Map();
@@ -302,6 +300,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);
@@ -317,8 +341,10 @@ export 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.
      */
     async map(opts) {
         const enc = this.enc(opts?.projectKey);
@@ -326,10 +352,10 @@ export class ProjectsResource extends BaseResource {
         const timeoutMs = DEFAULT_METADATA_TIMEOUT_MS;
         const [rawGraph, foldersMeta, datasetsMeta, recipesMeta, zonesMeta,] = await Promise.all([
             this.client.get(`/public/api/projects/${enc}/flow/graph/`),
-            fetchWithTimeout("Managed folders", timeoutMs, () => this.client.get(`/public/api/projects/${enc}/managedfolders/`)),
-            fetchWithTimeout("Datasets", timeoutMs, () => this.client.get(`/public/api/projects/${enc}/datasets/`)),
-            fetchWithTimeout("Recipes", timeoutMs, () => this.client.get(`/public/api/projects/${enc}/recipes/`)),
-            fetchWithTimeout("Flow zones", timeoutMs, () => this.client.flowZones.list(pk)),
+            fetchWithTimeout("Managed folders", timeoutMs, (getOptions) => this.client.get(`/public/api/projects/${enc}/managedfolders/`, getOptions)),
+            fetchWithTimeout("Datasets", timeoutMs, (getOptions) => this.client.get(`/public/api/projects/${enc}/datasets/`, getOptions)),
+            fetchWithTimeout("Recipes", timeoutMs, (getOptions) => this.client.get(`/public/api/projects/${enc}/recipes/`, getOptions)),
+            fetchWithTimeout("Flow zones", timeoutMs, (getOptions) => this.client.flowZones.list(pk, getOptions)),
         ]);
         // Build folder name lookup
         const folderNamesById = {};

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,