dataiku-sdk 3.5.0 → 3.6.1

package/dist/src/cli.js

@@ -9,6 +9,7 @@ import { executionMode, FLAG_ALIASES, isNegativeNumberToken, parseArgs, SHORT_FL
 import { cleanupLedgerEntry, } from "./cli/helpers/cleanup.js";
 import { commandFailureExitCode, CommandResultFailure, flushCliWarnings, isFailedWaitResult, planResult, projectResultFields, setOutputFieldProjection, writeCommandResult, } from "./cli/output.js";
 import { currentCommandContext, resolveCredentials, resolveLoginCredentials, } from "./cli/runtime.js";
+import { commandUsage, } from "./cli/syntax.js";
 import { COMMANDS_RUN_HINT, inferRequiresProject, missingActionError, noCommandError, requireArgs, RESOURCE_NAMES, unknownActionError, unknownResourceError, UsageError, } from "./cli/usage.js";
 import { cliVersionResult, } from "./cli/version.js";
 import { getCredentialsPath, } from "./config.js";
@@ -171,17 +172,6 @@ async function runCleanup(flags) {
                 || !commands[resource]?.[action]) {
                 throw new UsageError(`Invalid cleanup argv: ${entry.cleanup.argv.join(" ")}`);
             }
-            if (resource === "project"
-                && action === "delete"
-                && typeof parsed.flags["expect-project-incarnation"] !== "string") {
-                throw new UsageError("Project cleanup entry is not bound to a project incarnation. Refusing deletion after possible project-key reuse.", "validation_failed", "Capture a new cleanup entry from the current CLI. Legacy entries cannot safely delete projects.");
-            }
-            if (resource === "app"
-                && action === "delete-instance"
-                && parsed.flags["unconfirmed-creation"] !== true
-                && typeof parsed.flags["expect-project-incarnation"] !== "string") {
-                throw new UsageError("App cleanup entry is not bound to a project incarnation. Refusing deletion after possible project-key reuse.", "validation_failed", "Capture a new cleanup entry from the current CLI. Legacy entries cannot safely delete app projects.");
-            }
             const result = await commands[resource][action].handler(client, args, parsed.flags);
             if (isFailedWaitResult(result)) {
                 const failure = {
@@ -418,81 +408,60 @@ async function validateDryRunHandlerPreconditions(handler, args, flags) {
         throw error;
     }
 }
+/**
+ * The one validator for meta commands, shared by direct runs and batch
+ * --dry-run: action, supported flags (incl. --plan/--dry-run), flag conflicts,
+ * and required inputs. Returns the canonical action, or undefined for a
+ * non-meta resource.
+ */
 async function validateMetaCommandInputs(resource, action, flags) {
-    if (resource === "doctor") {
-        if (action !== undefined && action !== "run") {
-            throw unknownActionError("doctor", action, ["run",]);
-        }
-        return "run";
-    }
+    if (META_COMMAND_RESOURCES[resource] !== true)
+        return undefined;
+    await loadCommandRuntime();
+    let resolved;
     if (resource === "auth") {
         const validActions = Object.keys(contract.AUTH_ACTIONS);
-        if (!action) {
-            throw missingActionError("auth", validActions, "dss auth login --url URL --api-key KEY");
-        }
+        if (!action)
+            throw missingActionError("auth", validActions, commandUsage("auth", "login"));
         if (!contract.AUTH_ACTIONS[action]) {
             throw unknownActionError("auth", action, validActions, "auth only supports 'login'. To check credentials/connectivity, run 'dss doctor'.");
         }
-        return action;
-    }
-    if (resource === "install-skill") {
-        if (action !== undefined && action !== "run") {
-            throw unknownActionError("install-skill", action, ["run",]);
-        }
-        const { AGENTS, } = await import("./skill.js");
-        const agentFilter = typeof flags["agent"] === "string" ? flags["agent"] : undefined;
-        if (agentFilter && !AGENTS[agentFilter]) {
-            throw new UsageError(`Unknown agent: ${agentFilter}.`, "usage_error", COMMANDS_RUN_HINT, { agent: agentFilter, validAgents: Object.keys(AGENTS), });
-        }
-        return "run";
+        resolved = action;
     }
-    if (resource === "agent") {
+    else if (resource === "agent" || resource === "commands") {
+        const only = resource === "agent" ? "contract" : "run";
+        const usage = resource === "agent" ? contract.AGENT_CONTRACT_USAGE : contract.COMMANDS_USAGE;
         if (!action)
-            throw missingActionError("agent", ["contract",], contract.AGENT_CONTRACT_USAGE);
-        if (action !== "contract")
-            throw unknownActionError("agent", action, ["contract",]);
-        return action;
+            throw missingActionError(resource, [only,], usage);
+        if (action !== only)
+            throw unknownActionError(resource, action, [only,]);
+        resolved = action;
     }
-    if (resource === "commands") {
-        if (!action)
-            throw missingActionError("commands", ["run",], contract.COMMANDS_USAGE);
-        if (action !== "run")
-            throw unknownActionError("commands", action, ["run",]);
-        validateSupportedCommandFlags("commands", "run", flags);
-        commandRegistrySelectors(flags);
-        return action;
-    }
-    if (resource === "version") {
+    else {
         if (action !== undefined && action !== "run") {
-            throw unknownActionError("version", action, ["run",]);
+            throw unknownActionError(resource, action, ["run",]);
         }
-        return "run";
+        resolved = "run";
     }
-    if (resource === "cleanup") {
-        if (action !== undefined && action !== "run") {
-            throw unknownActionError("cleanup", action, ["run",]);
-        }
-        const entry = cachedCommandRegistry("cleanup")?.run;
+    validateSupportedCommandFlags(resource, resolved, flags);
+    if (resource === "commands")
+        commandRegistrySelectors(flags);
+    if (resource === "cleanup" || resource === "batch") {
+        const entry = cachedCommandRegistry(resource)?.run;
         if (entry)
-            validateRequiredCommandInputs("cleanup", "run", [], flags, entry);
-        return "run";
+            validateRequiredCommandInputs(resource, "run", [], flags, entry);
     }
-    if (resource === "fixtures") {
-        if (action !== undefined && action !== "run") {
-            throw unknownActionError("fixtures", action, ["run",]);
-        }
-        return "run";
+    if (resource === "cleanup" && flags["apply"] === true && executionMode(flags).dryRun) {
+        throw new UsageError("--dry-run and --apply are mutually exclusive.", "usage_error");
     }
-    if (resource === "batch") {
-        if (action !== undefined && action !== "run") {
-            throw unknownActionError("batch", action, ["run",]);
+    if (resource === "install-skill") {
+        const { AGENTS, } = await import("./skill.js");
+        const agentFilter = typeof flags["agent"] === "string" ? flags["agent"] : undefined;
+        if (agentFilter && !AGENTS[agentFilter]) {
+            throw new UsageError(`Unknown agent: ${agentFilter}.`, "usage_error", COMMANDS_RUN_HINT, { agent: agentFilter, validAgents: Object.keys(AGENTS), });
         }
-        const entry = cachedCommandRegistry("batch")?.run;
-        if (entry)
-            validateRequiredCommandInputs("batch", "run", [], flags, entry);
-        return "run";
     }
-    return undefined;
+    return resolved;
 }
 async function validateBatchStep(argv) {
     const { positional, flags, } = parseArgs(argv);
@@ -532,29 +501,8 @@ function batchStepNeedsClient(argv) {
     }
 }
 function batchStepCommandContext(argv) {
-    const positionals = [];
-    for (let index = 0; index < argv.length; index++) {
-        const arg = argv[index];
-        if (arg === "--") {
-            positionals.push(...argv.slice(index + 1));
-            break;
-        }
-        if (arg.startsWith("--")) {
-            const name = arg.slice(2).split("=")[0] ?? "";
-            const canonical = FLAG_ALIASES[name] ?? name;
-            if (!arg.includes("=") && VALUE_FLAGS.has(canonical))
-                index++;
-            continue;
-        }
-        if (arg.length === 2 && arg[0] === "-" && arg[1] !== "-") {
-            const long = SHORT_FLAGS[arg[1]];
-            if (long && VALUE_FLAGS.has(long))
-                index++;
-            continue;
-        }
-        positionals.push(arg);
-    }
-    return { resource: positionals[0], action: positionals[1], };
+    const [resource, action,] = rawPositionals(argv);
+    return { resource, action, };
 }
 const SENSITIVE_ARGV_VALUE_FLAGS = {
     "api-key": true,
@@ -748,145 +696,78 @@ function batchPlan(flags) {
         plannedAndDryRun: executionMode(flags).dryRun,
     });
 }
-async function runMetaCommand(resource, action, flags) {
-    if (resource === "doctor") {
-        await loadCommandRuntime();
-        if (action !== undefined && action !== "run") {
-            throw unknownActionError("doctor", action, ["run",]);
-        }
-        currentCommandContext.action = action ?? "run";
-        validateSupportedCommandFlags("doctor", "run", flags);
-        const { runDoctor, } = await import("./cli/doctor.js");
-        const { result, exitCode, } = await runDoctor(flags);
-        return { action: "run", result, exitCode, };
-    }
-    if (resource === "auth") {
-        await loadCommandRuntime();
-        const validActions = Object.keys(contract.AUTH_ACTIONS);
-        if (!action) {
-            throw missingActionError("auth", validActions, "dss auth login --url URL --api-key KEY");
-        }
-        currentCommandContext.action = action;
-        const authMeta = contract.AUTH_ACTIONS[action];
-        if (!authMeta) {
-            throw unknownActionError("auth", action, validActions, "auth only supports 'login'. To check credentials/connectivity, run 'dss doctor'.");
-        }
-        validateSupportedCommandFlags("auth", action, flags);
-        if (executionMode(flags).plan) {
-            return { action, result: authLoginPlan(flags), exitCode: 0, };
-        }
-        return { action, result: await authMeta.handler(flags), exitCode: 0, };
-    }
-    if (resource === "install-skill") {
-        await loadCommandRuntime();
-        if (action !== undefined && action !== "run") {
-            throw unknownActionError("install-skill", action, ["run",]);
-        }
-        currentCommandContext.action = action ?? "run";
-        validateSupportedCommandFlags("install-skill", "run", flags);
-        return { action: "run", result: await runInstallSkill(flags), exitCode: 0, };
-    }
-    if (resource === "agent") {
-        await loadCommandRuntime();
-        if (!action)
-            throw missingActionError("agent", ["contract",], contract.AGENT_CONTRACT_USAGE);
-        currentCommandContext.action = action;
-        if (action !== "contract")
-            throw unknownActionError("agent", action, ["contract",]);
-        validateSupportedCommandFlags("agent", "contract", flags);
-        return { action, result: contract.buildAgentContract(), exitCode: 0, };
-    }
-    if (resource === "commands") {
-        await loadCommandRuntime();
-        if (!action)
-            throw missingActionError("commands", ["run",], contract.COMMANDS_USAGE);
-        currentCommandContext.action = action;
-        if (action !== "run")
-            throw unknownActionError("commands", action, ["run",]);
-        validateSupportedCommandFlags("commands", "run", flags);
-        const selectors = commandRegistrySelectors(flags);
-        const outputPath = flags["output"];
-        if (selectors.length === 0 && typeof outputPath !== "string") {
-            return { action, result: contract.commandActionSummary(), exitCode: 0, };
+async function runMetaCommand(resource, rawAction, flags) {
+    const action = await validateMetaCommandInputs(resource, rawAction, flags);
+    if (action === undefined)
+        return undefined;
+    currentCommandContext.action = action;
+    const plan = executionMode(flags).plan;
+    switch (resource) {
+        case "doctor": {
+            const { runDoctor, } = await import("./cli/doctor.js");
+            const { result, exitCode, } = await runDoctor(flags);
+            return { action, result, exitCode, };
         }
-        const registry = selectors.length === 0 ? contract.buildCommandRegistry() : {};
-        for (const selector of selectors) {
-            const selectorParts = selector.split(".");
-            if (selectorParts.some((part) => part.length === 0)) {
-                throw new UsageError(`Invalid --fields selector: ${selector}. Expected RESOURCE or RESOURCE.ACTION[.FIELD...].`, "usage_error", contract.COMMANDS_USAGE, { selector, });
-            }
-            const [selectedResource, selectedAction,] = selectorParts;
-            const resourceActions = cachedCommandRegistry(selectedResource);
-            if (!resourceActions)
-                throw unknownResourceError(selectedResource);
-            registry[selectedResource] = resourceActions;
-            if (selectedAction && !resourceActions[selectedAction]) {
-                throw unknownActionError(selectedResource, selectedAction, Object.keys(resourceActions));
-            }
+        case "auth":
+            if (plan)
+                return { action, result: authLoginPlan(flags), exitCode: 0, };
+            return { action, result: await contract.AUTH_ACTIONS[action].handler(flags), exitCode: 0, };
+        case "install-skill":
+            return { action, result: await runInstallSkill(flags), exitCode: 0, };
+        case "agent":
+            return { action, result: contract.buildAgentContract(), exitCode: 0, };
+        case "version":
+            return { action, result: cliVersionResult(), exitCode: 0, };
+        case "fixtures": {
+            const { runFixtures, } = await import("./cli/doctor.js");
+            return { action, result: await runFixtures(flags), exitCode: 0, };
         }
-        const selectedRegistry = selectors.length === 0
-            ? registry
-            : projectResultFields(registry, selectors, () => Object.keys(contract.commandActionSummary()).sort());
-        if (typeof outputPath === "string") {
-            const exported = selectedRegistry;
-            await fs.writeFile(outputPath, `${JSON.stringify(exported)}\n`, "utf-8");
-            return { action, result: { path: outputPath, }, exitCode: 0, };
+        case "cleanup": {
+            if (plan)
+                return { action, result: cleanupPlan(flags), exitCode: 0, };
+            const { result, exitCode, } = await runCleanup(flags);
+            return { action, result, exitCode, };
         }
-        return {
-            action,
-            result: selectedRegistry,
-            exitCode: 0,
-        };
-    }
-    if (resource === "version") {
-        await loadCommandRuntime();
-        if (action !== undefined && action !== "run") {
-            throw unknownActionError("version", action, ["run",]);
+        case "batch": {
+            if (plan)
+                return { action, result: batchPlan(flags), exitCode: 0, };
+            const { result, exitCode, } = await runBatch(flags);
+            return { action, result, exitCode, };
         }
-        currentCommandContext.action = action ?? "run";
-        validateSupportedCommandFlags("version", "run", flags);
-        return { action: "run", result: cliVersionResult(), exitCode: 0, };
+        default:
+            return { action, result: await commandsRunResult(flags), exitCode: 0, };
     }
-    if (resource === "cleanup") {
-        await loadCommandRuntime();
-        if (action !== undefined && action !== "run") {
-            throw unknownActionError("cleanup", action, ["run",]);
-        }
-        currentCommandContext.action = action ?? "run";
-        validateSupportedCommandFlags("cleanup", "run", flags);
-        if (flags["apply"] === true && executionMode(flags).dryRun) {
-            throw new UsageError("--dry-run and --apply are mutually exclusive.", "usage_error");
-        }
-        if (executionMode(flags).plan) {
-            return { action: "run", result: cleanupPlan(flags), exitCode: 0, };
+}
+async function commandsRunResult(flags) {
+    const selectors = commandRegistrySelectors(flags);
+    const outputPath = flags["output"];
+    if (selectors.length === 0 && typeof outputPath !== "string") {
+        return contract.commandActionSummary();
+    }
+    const registry = selectors.length === 0 ? contract.buildCommandRegistry() : {};
+    for (const selector of selectors) {
+        const selectorParts = selector.split(".");
+        if (selectorParts.some((part) => part.length === 0)) {
+            throw new UsageError(`Invalid --fields selector: ${selector}. Expected RESOURCE or RESOURCE.ACTION[.FIELD...].`, "usage_error", contract.COMMANDS_USAGE, { selector, });
         }
-        const { result, exitCode, } = await runCleanup(flags);
-        return { action: "run", result, exitCode, };
-    }
-    if (resource === "fixtures") {
-        await loadCommandRuntime();
-        if (action !== undefined && action !== "run") {
-            throw unknownActionError("fixtures", action, ["run",]);
+        const [selectedResource, selectedAction,] = selectorParts;
+        const resourceActions = cachedCommandRegistry(selectedResource);
+        if (!resourceActions)
+            throw unknownResourceError(selectedResource);
+        registry[selectedResource] = resourceActions;
+        if (selectedAction && !resourceActions[selectedAction]) {
+            throw unknownActionError(selectedResource, selectedAction, Object.keys(resourceActions));
         }
-        currentCommandContext.action = action ?? "run";
-        validateSupportedCommandFlags("fixtures", "run", flags);
-        const { runFixtures, } = await import("./cli/doctor.js");
-        return { action: "run", result: await runFixtures(flags), exitCode: 0, };
     }
-    if (resource === "batch") {
-        await loadCommandRuntime();
-        if (action !== undefined && action !== "run") {
-            throw unknownActionError("batch", action, ["run",]);
-        }
-        currentCommandContext.action = action ?? "run";
-        validateSupportedCommandFlags("batch", "run", flags);
-        if (executionMode(flags).plan) {
-            return { action: "run", result: batchPlan(flags), exitCode: 0, };
-        }
-        const { result, exitCode, } = await runBatch(flags);
-        return { action: "run", result, exitCode, };
+    const selectedRegistry = selectors.length === 0
+        ? registry
+        : projectResultFields(registry, selectors, () => Object.keys(contract.commandActionSummary()).sort());
+    if (typeof outputPath === "string") {
+        const exported = selectedRegistry;
+        await fs.writeFile(outputPath, `${JSON.stringify(exported)}\n`, "utf-8");
+        return { path: outputPath, };
     }
-    return undefined;
+    return selectedRegistry;
 }
 /**
  * Cleanup-ledger support is checked before a handler runs so an unsupported
@@ -1389,6 +1270,10 @@ function errorExitCode(err) {
     if (err instanceof ClientValidationError
         && (err.code === "ambiguous_outcome" || err.code === "internal_error"))
         return 2;
+    // A permission/environment refusal is not a usage error (exit 1 is usage only).
+    if ((err instanceof UsageError || err instanceof ClientValidationError)
+        && err.code === "target_absence_unverifiable")
+        return 2;
     if (err instanceof UsageError || err instanceof ClientValidationError)
         return 1;
     if (isAmbiguousMutationFailure(err, rawCommandContext()))

package/dist/src/client.d.ts

@@ -118,7 +118,7 @@ export interface DataikuClientConfig {
     projectKey?: string;
     /** 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) */
+    /** Maximum total attempts, initial request included, for idempotent requests (default 4, capped at 10; 1 = no retry) */
     retryMaxAttempts?: number;
     /**
      * Maximum bytes retained from a single response body by text/JSON consumers
@@ -336,6 +336,7 @@ export declare class DataikuClient {
     stream(path: string): Promise<Response>;
     /** Bound each pending read, not total transfer time; preserve large downloads and backpressure. */
     private withBodyDeadline;
+    /** JSON request headers; Content-Type only when a body is sent. */
     private getHeaders;
     private getAnyHeaders;
     private responseMeta;

package/dist/src/client.js

@@ -470,7 +470,7 @@ export class DataikuClient {
     /* ---- public: HTTP verbs ---- */
     async get(path, options) {
         const deadlineAt = resolveGetDeadlineAt(options);
-        const res = await this.fetchWithRetry(`${this.baseUrl}${path}`, { method: "GET", headers: this.getHeaders(), }, options?.noRetry === true ? 1 : undefined, deadlineAt);
+        const res = await this.fetchWithRetry(`${this.baseUrl}${path}`, { method: "GET", headers: this.getHeaders(false), }, options?.noRetry === true ? 1 : undefined, deadlineAt);
         return this.parseJsonResponse(res, deadlineAt);
     }
     /**
@@ -481,7 +481,7 @@ export class DataikuClient {
     async getWithMetadata(path) {
         const res = await this.fetchWithRetry(`${this.baseUrl}${path}`, {
             method: "GET",
-            headers: this.getHeaders(),
+            headers: this.getHeaders(false),
         });
         const data = await this.parseJsonResponse(res);
         return { data, meta: this.responseMeta(res.headers), };
@@ -543,7 +543,7 @@ export class DataikuClient {
         }
         const res = await this.fetchWithRetry(`${this.baseUrl}${path}`, {
             method: "POST",
-            headers: this.getHeaders(),
+            headers: this.getHeaders(body !== undefined),
             body: body !== undefined ? JSON.stringify(body) : undefined,
         }, retryMaxAttempts);
         return this.parseJsonResponse(res);
@@ -555,7 +555,7 @@ export class DataikuClient {
     async postText(path, body) {
         const res = await this.fetchWithRetry(`${this.baseUrl}${path}`, {
             method: "POST",
-            headers: this.getHeaders(),
+            headers: this.getHeaders(body !== undefined),
             body: body !== undefined ? JSON.stringify(body) : undefined,
         });
         const { text, truncated, } = await this.readBoundedBodyText(res, this.maxResponseBodyBytes);
@@ -600,7 +600,7 @@ export class DataikuClient {
     async put(path, body) {
         const res = await this.fetchWithRetry(`${this.baseUrl}${path}`, {
             method: "PUT",
-            headers: this.getHeaders(),
+            headers: this.getHeaders(true),
             body: JSON.stringify(body),
         });
         return this.parseJsonResponse(res);
@@ -608,13 +608,13 @@ export class DataikuClient {
     async del(path) {
         await this.fetchWithRetry(`${this.baseUrl}${path}`, {
             method: "DELETE",
-            headers: this.getHeaders(),
+            headers: this.getHeaders(false),
         });
     }
     async putVoid(path, body) {
         await this.fetchWithRetry(`${this.baseUrl}${path}`, {
             method: "PUT",
-            headers: this.getHeaders(),
+            headers: this.getHeaders(true),
             body: JSON.stringify(body),
         });
     }
@@ -626,7 +626,7 @@ export class DataikuClient {
     async putVoidNoBody(path) {
         await this.fetchWithRetry(`${this.baseUrl}${path}`, {
             method: "PUT",
-            headers: this.getHeaders(),
+            headers: this.getHeaders(false),
         });
     }
     /**
@@ -731,11 +731,12 @@ export class DataikuClient {
         return response;
     }
     /* ---- private: headers ---- */
-    getHeaders() {
+    /** JSON request headers; Content-Type only when a body is sent. */
+    getHeaders(withBody) {
         return {
             Authorization: `Bearer ${this.apiKey}`,
             Accept: "application/json",
-            "Content-Type": "application/json",
+            ...(withBody ? { "Content-Type": "application/json", } : {}),
         };
     }
     getAnyHeaders() {
@@ -1030,7 +1031,20 @@ export class DataikuClient {
                     elapsedMs: Date.now() - startedAt,
                 });
                 if (!res.ok) {
-                    const { text, truncated, } = await this.readBoundedBodyText(res, this.maxResponseBodyBytes, startedAt + attemptTimeoutMs);
+                    // The status is already known; a body that misses the deadline must not
+                    // turn a real 5xx/4xx into a bare transport timeout.
+                    let text = "";
+                    let truncated = false;
+                    try {
+                        ({ text, truncated, } = await this.readBoundedBodyText(res, this.maxResponseBodyBytes, startedAt + attemptTimeoutMs));
+                    }
+                    catch (bodyError) {
+                        // Oversized bodies keep their own classified error; any other read
+                        // failure (deadline abort, dropped connection) keeps the known status.
+                        if (bodyError instanceof DataikuError && bodyError.status !== 0)
+                            throw bodyError;
+                        text = `(response body not received within ${attemptTimeoutMs}ms)`;
+                    }
                     const canRetry = retryEnabled && attempt < maxAttempts && isTransientError(res.status, text);
                     const serverDelayMs = canRetry ? retryAfterDelayMs(res.headers.get("retry-after")) : 0;
                     // A longer server wait declines automatic retry; never clamp it into an early request.

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

@@ -3,6 +3,8 @@ import type { DataikuClient } from "../client.js";
 export declare function requireArrayResponse<T>(value: unknown, operation: string): T[];
 /** Validate identifiers without changing significant whitespace or encoding. */
 export declare function requireNonEmpty(value: unknown, name: string): string;
+export declare function requireObject(value: unknown, name: string): Record<string, unknown>;
+export declare function requireNonEmptyArray(value: string[], name: string): string[];
 export declare abstract class BaseResource {
     protected readonly client: DataikuClient;
     constructor(client: DataikuClient);

package/dist/src/resources/base.js

@@ -1,8 +1,8 @@
-import { ClientValidationError, DataikuError, } from "../errors.js";
+import { ClientValidationError, unexpectedResponseError, } from "../errors.js";
 /** Never disguise an unexpected successful HTTP payload as an empty listing. */
 export function requireArrayResponse(value, operation) {
     if (!Array.isArray(value)) {
-        throw new DataikuError(200, "Unexpected Response", `${operation}: DSS did not return an array.`);
+        throw unexpectedResponseError(`${operation}: DSS did not return an array.`);
     }
     return value;
 }
@@ -13,6 +13,18 @@ export function requireNonEmpty(value, name) {
     }
     return value;
 }
+export function requireObject(value, name) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new ClientValidationError(`${name} must be a JSON object.`, "validation_failed");
+    }
+    return value;
+}
+export function requireNonEmptyArray(value, name) {
+    if (!Array.isArray(value) || value.length === 0) {
+        throw new ClientValidationError(`${name} must be a non-empty array.`, "validation_failed");
+    }
+    return value;
+}
 export class BaseResource {
     client;
     constructor(client) {

package/dist/src/resources/code-envs.js

@@ -1,5 +1,6 @@
 import { ClientValidationError, } from "../errors.js";
 import { CodeEnvLogSummaryArraySchema, CodeEnvSummaryArraySchema, CodeEnvUsageArraySchema, CodeEnvVersionForProjectSchema, } from "../schemas.js";
+import { isRecord, } from "../utils/records.js";
 import { stableHash, } from "../utils/stable-hash.js";
 import { BaseResource, } from "./base.js";
 /** Byte cap applied to fetched code-env logs so stdout/JSON stays bounded. */
@@ -212,6 +213,3 @@ function normalizePackageList(packages) {
     const lines = Array.isArray(packages) ? packages : packages.split(/\r?\n/);
     return lines.map((line) => line.trim()).filter((line) => line.length > 0).join("\n");
 }
-function isRecord(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value);
-}