dataiku-sdk 3.9.0 → 4.1.0

package/dist/src/cli.js

@@ -1,15 +1,15 @@
 #!/usr/bin/env node
-import * as fs from "node:fs/promises";
 import { homedir, } from "node:os";
 import { resolve, } from "node:path";
-import { num, seenJsonInputCredentials, unknownJsonInput, } from "./cli/coerce.js";
+import { num, resultRecord, seenJsonInputCredentials, stringField, unknownJsonInput, } from "./cli/coerce.js";
 import { commands, } from "./cli/commands/index.js";
 import { ambientProjectKey, loadEnvFile, } from "./cli/env.js";
 import { executionMode, FLAG_ALIASES, isFlagValueToken, parseArgs, rawPositionals, } from "./cli/flags.js";
-import { cleanupLedgerEntry, } from "./cli/helpers/cleanup.js";
-import { commandFailureExitCode, CommandResultFailure, enqueueCliWarning, flushCliWarnings, isFailedWaitResult, planResult, projectResultFields, setOutputFieldProjection, writeCommandResult, } from "./cli/output.js";
+import { cleanupInputIdentifierField, cleanupLedgerEntry, } from "./cli/helpers/cleanup.js";
+import { commandFailureExitCode, CommandResultFailure, enqueueCliWarning, flushCliWarnings, isFailedWaitResult, planResult, projectResultFields, setOutputFieldProjection, stdoutJson, writeCommandResult, } from "./cli/output.js";
 import { shapeCommandResult, } from "./cli/result-shapes.js";
 import { currentCommandContext, resolveCredentials, resolveLoginCredentials, } from "./cli/runtime.js";
+import { suggestSelectors, } from "./cli/selector-suggestions.js";
 import { commandSyntaxTree, commandUsage, } from "./cli/syntax.js";
 import { COMMANDS_RUN_HINT, inferRequiresProject, missingActionError, noCommandError, requireArgs, RESOURCE_NAMES, unknownActionError, unknownFlagError, unknownResourceError, UsageError, } from "./cli/usage.js";
 import { cliVersionResult, } from "./cli/version.js";
@@ -480,7 +480,7 @@ async function validateBatchStep(argv) {
         return { positional, flags, resource, action: metaAction, };
     const resourceActions = commands[resource];
     if (!resourceActions)
-        throw unknownResourceError(resource);
+        throw unknownResourceError(resource, action);
     if (!action) {
         throw missingActionError(resource, Object.keys(resourceActions), `dss ${resource} <action>`);
     }
@@ -767,6 +767,8 @@ async function commandsRunResult(flags) {
         return contract.commandActionSummary();
     }
     const registry = selectors.length === 0 ? contract.buildCommandRegistry() : {};
+    const knownSelectors = [];
+    const unknownSelectors = {};
     for (const selector of selectors) {
         const selectorParts = selector.split(".");
         if (selectorParts.some((part) => part.length === 0)) {
@@ -774,19 +776,65 @@ async function commandsRunResult(flags) {
         }
         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));
+        const error = !resourceActions
+            ? unknownResourceError(selectedResource)
+            : selectedAction && !resourceActions[selectedAction]
+                ? unknownActionError(selectedResource, selectedAction, Object.keys(resourceActions))
+                : undefined;
+        if (resourceActions && !error) {
+            registry[selectedResource] = resourceActions;
+            knownSelectors.push(selector);
+            continue;
         }
+        unknownSelectors[selector] = {
+            error: error,
+            suggestions: suggestSelectors(selector, contract.commandActionSummary()),
+        };
+    }
+    const unknownNames = Object.keys(unknownSelectors);
+    if (unknownNames.length > 0) {
+        if (knownSelectors.length === 0 && selectors.length > 0) {
+            const { error, suggestions, } = unknownSelectors[unknownNames[0]];
+            // The shared error suggests `dss resource action` commands; here the fix is a selector.
+            const hint = suggestions.length === 0
+                ? COMMANDS_RUN_HINT
+                : `Did you mean ${suggestions.map((name) => `\`--fields ${name}\``).join(" or ")}? ${COMMANDS_RUN_HINT}`;
+            const { suggestions: _commandSuggestions, ...details } = error.details ?? {};
+            throw new UsageError(error.message, error.code, hint, {
+                ...details,
+                ...(suggestions.length > 0 ? { suggestions, } : {}),
+            });
+        }
+        enqueueCliWarning({
+            code: "unknown_fields",
+            fields: unknownNames,
+            suggestions: Object.fromEntries(unknownNames.flatMap((name) => unknownSelectors[name].suggestions.length > 0
+                ? [[name, unknownSelectors[name].suggestions,],]
+                : [])),
+            hint: "Unknown selectors were skipped; the result holds the known ones. Run `dss commands run` for resource/action names.",
+        });
+    }
+    // On stdout a bare RESOURCE selector lists its actions (usage, description, side effect):
+    // the full entries (flags, schemas, examples) run 30-55 KB per resource, more than an agent
+    // can read in one result. RESOURCE.ACTION and --output keep the full entries.
+    const fullSelectors = typeof outputPath === "string"
+        ? knownSelectors
+        : knownSelectors.filter((selector) => selector.includes("."));
+    const selectedRegistry = selectors.length === 0 ? registry : {};
+    if (fullSelectors.length > 0) {
+        Object.assign(selectedRegistry, projectResultFields(registry, fullSelectors, () => Object.keys(contract.commandActionSummary()).sort()));
+    }
+    for (const resource of knownSelectors) {
+        if (fullSelectors.includes(resource))
+            continue;
+        selectedRegistry[resource] = Object.fromEntries(Object.entries(registry[resource]).map(([action, entry,]) => [
+            action,
+            { usage: entry.usage, description: entry.description, sideEffect: entry.sideEffect, },
+        ]));
     }
-    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");
+        await Bun.write(outputPath, `${JSON.stringify(exported)}\n`);
         return { path: outputPath, };
     }
     return selectedRegistry;
@@ -802,8 +850,9 @@ function assertCleanupLedgerSupported(resource, action, flags) {
     if (!contract.supportsCleanupLedger(resource, action)) {
         throw new UsageError(`--record-cleanup is not supported for ${resource} ${action}.`);
     }
-    if (resource === "workspace" && action === "create" && flags["stdin"] === true) {
-        throw new UsageError("workspace create cannot combine --record-cleanup with --stdin because the cleanup identifier cannot be replayed from a consumed stream.", "conflicting_input_sources", "Use --data or --data-file so the workspaceKey remains available for the cleanup ledger.");
+    const pinnedField = cleanupInputIdentifierField(resource, action);
+    if (pinnedField !== undefined && flags["stdin"] === true) {
+        throw new UsageError(`${resource} ${action} cannot combine --record-cleanup with --stdin because the cleanup identifier cannot be replayed from a consumed stream.`, "conflicting_input_sources", `Use --data or --data-file so the ${pinnedField} remains available for the cleanup ledger.`);
     }
 }
 /**
@@ -856,11 +905,36 @@ async function preflightCleanupLedgerForFlags(client, flags) {
     }
 }
 /**
- * Append the cleanup entry for a completed handler result. Callers must pass the
- * raw, unprojected result and must call this before any failure exit code is
- * raised: an indeterminate post-POST outcome stays addressable only when the
- * ledger records it first. Eligibility (dry runs, skipped work, an explicit
- * `cleanupEligible:false`) is decided by `cleanupLedgerEntry`, never here.
+ * What the command result already says about the created object, so a failed
+ * ledger write never hides it: the `created`/`saved` receipt, the object `id`
+ * and `name`, and the project key DSS landed it in. Fields stay distinct (a
+ * name is not an id) and absent ones are omitted rather than guessed.
+ */
+function createdObjectFromResult(result, fallbackProjectKey) {
+    const record = resultRecord(result);
+    const created = stringField(record, ["created", "saved", "usedProjectKey",]);
+    const id = stringField(record, ["id",]);
+    const name = stringField(record, ["name",]);
+    const projectKey = stringField(record, ["projectKey", "usedProjectKey", "targetProjectKey",])
+        ?? fallbackProjectKey;
+    return {
+        ...(created ? { created, } : {}),
+        ...(id ? { id, } : {}),
+        ...(name ? { name, } : {}),
+        ...(projectKey ? { projectKey, } : {}),
+    };
+}
+/**
+ * Append the cleanup entry for a completed handler result. Callers must call
+ * this before any failure exit code is raised: an indeterminate post-POST
+ * outcome stays addressable only when the ledger records it first. Eligibility
+ * (dry runs, skipped work, an explicit `cleanupEligible:false`) is decided by
+ * `cleanupLedgerEntry`, never here.
+ *
+ * The mutation has already happened when this runs, so every failure here is
+ * an `ambiguous_outcome` that says so (`mutationSucceeded: true`,
+ * `cleanupRecorded: false`) and carries the created identifier/project key:
+ * callers must never retry the create, only clean up or record it themselves.
  */
 async function recordCleanupLedgerEntry(client, resource, action, args, flags, result, projectKey) {
     const ledgerPath = flags["record-cleanup"];
@@ -868,15 +942,33 @@ async function recordCleanupLedgerEntry(client, resource, action, args, flags, r
         return;
     const entry = cleanupLedgerEntry(resource, action, args, flags, result, projectKey);
     if (entry) {
-        await appendCleanupLedgerEntry(ledgerPath, entry, client.getBaseUrl());
+        try {
+            await appendCleanupLedgerEntry(ledgerPath, entry, client.getBaseUrl());
+        }
+        catch (error) {
+            throw new ClientValidationError(`Mutation completed but the cleanup entry for ${resource} ${action} could not be recorded: ${error instanceof Error ? error.message : String(error)}`, "ambiguous_outcome", "The mutation already succeeded: do not retry it. Remove the created object manually or append this cleanup entry to the ledger yourself.", {
+                resource,
+                action,
+                ledgerPath,
+                mutationSucceeded: true,
+                cleanupRecorded: false,
+                ...createdObjectFromResult(result, projectKey),
+                cleanup: entry.cleanup,
+            });
+        }
         return;
     }
-    const record = result !== null && typeof result === "object" && !Array.isArray(result)
-        ? result
-        : {};
+    const record = resultRecord(result);
     if (record.skipped !== undefined || record.cleanupEligible === false)
         return;
-    throw new ClientValidationError(`Mutation completed but no cleanup entry could be derived for ${resource} ${action}.`, "ambiguous_outcome", "Inspect the created object and remove it manually; do not assume the requested cleanup ledger contains it.", { resource, action, ledgerPath, });
+    throw new ClientValidationError(`Mutation completed but no cleanup entry could be derived for ${resource} ${action}.`, "ambiguous_outcome", "The mutation already succeeded: do not retry it. Inspect the created object and remove it manually; the requested cleanup ledger does not contain it.", {
+        resource,
+        action,
+        ledgerPath,
+        mutationSucceeded: true,
+        cleanupRecorded: false,
+        ...createdObjectFromResult(result, projectKey),
+    });
 }
 async function runBatch(flags) {
     const payload = unknownJsonInput(flags);
@@ -1003,7 +1095,7 @@ async function runBatch(flags) {
             else {
                 const resourceActions = commands[resource];
                 if (!resourceActions)
-                    throw unknownResourceError(resource);
+                    throw unknownResourceError(resource, action);
                 if (!action) {
                     throw missingActionError(resource, Object.keys(resourceActions), `dss ${resource} <action>`);
                 }
@@ -1306,15 +1398,21 @@ function buildErrorReport(err, contextOverride) {
     if (err instanceof ClientValidationError
         && (err.code === "ambiguous_outcome" || err.code === "assertion_failed"
             || err.code === "long_running_failure")) {
+        // The DSS response behind an indeterminate outcome stays visible (status,
+        // sanitized message), e.g. a 500 that names the conflicting project key.
+        const cause = err.cause instanceof DataikuError ? err.cause : undefined;
+        const diagnostics = cause ? dssDiagnosticDetails(cause) : {};
+        const details = { ...diagnostics, ...err.details, };
         return {
             type: "error",
             error: err.message,
             code: err.code,
             category: "dss",
             exitCode,
+            ...(cause ? { status: cause.status, } : {}),
             retryable: false,
             ...(err.hint ? { hint: err.hint, } : {}),
-            ...(err.details ? { details: err.details, } : {}),
+            ...(Object.keys(details).length > 0 ? { details, } : {}),
             ...scope,
         };
     }
@@ -1412,7 +1510,7 @@ function buildErrorReport(err, contextOverride) {
 }
 function writeErrorReport(err) {
     flushCliWarnings();
-    process.stdout.write(`${JSON.stringify(buildErrorReport(err))}\n`);
+    process.stdout.write(stdoutJson(buildErrorReport(err)));
 }
 /** Only ambiguous mutation failures require full contract metadata. */
 function errorReportNeedsCommandRuntime(err) {
@@ -1460,7 +1558,7 @@ async function main() {
     }
     // Resource and action recovery require only this resource's definitions.
     if (!RESOURCE_NAMES.includes(resource))
-        throw unknownResourceError(resource);
+        throw unknownResourceError(resource, positional[1]);
     const resourceActions = commands[resource];
     if (positional.length === 1) {
         throw missingActionError(resource, Object.keys(resourceActions), `dss ${resource} <action> [args...]`);

package/dist/src/client.d.ts

@@ -153,7 +153,13 @@ export declare class DataikuClient {
     private readonly maxResponseBodyBytes;
     private readonly retryMaxAttempts;
     private readonly verbose;
-    private readonly tlsOptions;
+    /**
+     * Connection pool carrying this client's TLS settings (custom CA, disabled
+     * verification). A session never shares connections with plain `fetch` or
+     * another client, so a connection opened with relaxed TLS cannot serve a
+     * client that expects strict verification. Default-TLS clients use plain fetch.
+     */
+    private readonly session;
     private readonly onTrace;
     private readonly onValidationWarning;
     private projectsResource?;
@@ -294,7 +300,8 @@ export declare class DataikuClient {
      * When the response exceeds the cap, earlier bytes are discarded, only
      * the tail is kept and `truncated` is true — so callers that need the end
      * of a large document (e.g. job logs) stay bounded without losing the most
-     * recent content. The read runs under the request deadline.
+     * recent content. The request timeout applies per received chunk (a stall
+     * deadline); the whole transfer is capped at 10x the request timeout.
      */
     getTextTailLimited(path: string, maxBytes: number): Promise<{
         text: string;
@@ -385,6 +392,12 @@ export declare class DataikuClient {
      * Returns `truncated: true` when bytes had to be dropped. Bytes that fall
      * in the middle of a UTF-8 character are dropped from both ends so the
      * decoded text never contains a replacement character.
+     *
+     * The request timeout applies per chunk (a stall deadline), like the
+     * streaming path: a body that stops sending for longer than the timeout
+     * fails with the body-read timeout error. A total budget of
+     * {@link TAIL_READ_TOTAL_BUDGET_FACTOR} x the request timeout bounds a body
+     * that keeps trickling, with an error naming that limit.
      */
     private readBodyTextTail;
     private buildResponseTooLargeError;

package/dist/src/client.js

@@ -2,7 +2,7 @@ import { readFileSync, } from "node:fs";
 import { basename, } from "node:path";
 import { Value, } from "@sinclair/typebox/value";
 import { safeParseSchema, } from "./schemas.js";
-import { classifyDataikuError, ClientValidationError, DataikuError, nonJsonResponseBody, } from "./errors.js";
+import { classifyDataikuError, ClientValidationError, DataikuError, nonJsonResponseBody, RESPONSE_TOO_LARGE_STATUS_TEXT, } from "./errors.js";
 /* ------------------------------------------------------------------ */
 /*  Constants                                                          */
 /* ------------------------------------------------------------------ */
@@ -18,7 +18,6 @@ const DEFAULT_REQUEST_TIMEOUT_MS = 30_000;
  * streaming methods (stream, postStream) are unaffected.
  */
 const DEFAULT_MAX_BUFFERED_BODY_BYTES = 50 * 1024 * 1024;
-const RESPONSE_TOO_LARGE_STATUS_TEXT = "Response Too Large";
 /* ------------------------------------------------------------------ */
 /*  Helpers                                                            */
 /* ------------------------------------------------------------------ */
@@ -115,6 +114,8 @@ function trimFromUtf8BoundaryStart(bytes) {
 function buildBodyReadTimeoutError(timeoutMs) {
     return new DataikuError(0, "Request Timeout", `Request timed out after ${timeoutMs}ms while reading the response body.`);
 }
+/** Total budget of a tail read (e.g. `job log`) as a multiple of the per-chunk stall timeout. */
+const TAIL_READ_TOTAL_BUDGET_FACTOR = 10;
 /**
  * Read the next chunk of a response body under a hard deadline.
  * When `remainingMs` elapses, the stream is cancelled and the caller's
@@ -211,7 +212,13 @@ export class DataikuClient {
     maxResponseBodyBytes;
     retryMaxAttempts;
     verbose;
-    tlsOptions;
+    /**
+     * Connection pool carrying this client's TLS settings (custom CA, disabled
+     * verification). A session never shares connections with plain `fetch` or
+     * another client, so a connection opened with relaxed TLS cannot serve a
+     * client that expects strict verification. Default-TLS clients use plain fetch.
+     */
+    session;
     onTrace;
     onValidationWarning;
     /* Resource namespaces — lazily initialized to break circular imports */
@@ -606,7 +613,8 @@ export class DataikuClient {
         const rawMax = config?.retryMaxAttempts ?? DEFAULT_RETRY_MAX_ATTEMPTS;
         this.retryMaxAttempts = Math.min(Math.max(1, rawMax), MAX_RETRY_ATTEMPTS_CAP);
         this.verbose = config?.verbose === true;
-        this.tlsOptions = config ? buildFetchTlsOptions(config) : undefined;
+        const tls = config ? buildFetchTlsOptions(config) : undefined;
+        this.session = tls ? new Bun.FetchSession({ tls, }) : undefined;
         this.onTrace = config?.onTrace ?? defaultTrace;
         this.onValidationWarning = config?.onValidationWarning ?? defaultValidationWarning;
     }
@@ -691,7 +699,8 @@ export class DataikuClient {
      * When the response exceeds the cap, earlier bytes are discarded, only
      * the tail is kept and `truncated` is true — so callers that need the end
      * of a large document (e.g. job logs) stay bounded without losing the most
-     * recent content. The read runs under the request deadline.
+     * recent content. The request timeout applies per received chunk (a stall
+     * deadline); the whole transfer is capped at 10x the request timeout.
      */
     async getTextTailLimited(path, maxBytes) {
         const limit = Math.max(0, Math.floor(maxBytes));
@@ -1080,6 +1089,12 @@ export class DataikuClient {
      * Returns `truncated: true` when bytes had to be dropped. Bytes that fall
      * in the middle of a UTF-8 character are dropped from both ends so the
      * decoded text never contains a replacement character.
+     *
+     * The request timeout applies per chunk (a stall deadline), like the
+     * streaming path: a body that stops sending for longer than the timeout
+     * fails with the body-read timeout error. A total budget of
+     * {@link TAIL_READ_TOTAL_BUDGET_FACTOR} x the request timeout bounds a body
+     * that keeps trickling, with an error naming that limit.
      */
     async readBodyTextTail(res, maxBytes) {
         const limit = Math.max(0, Math.floor(maxBytes));
@@ -1090,13 +1105,24 @@ export class DataikuClient {
         let writeOffset = 0;
         let retainedBytes = 0;
         let truncated = false;
+        // Stall deadline per chunk, plus an overall cap so a body that trickles
+        // forever still ends; the error names which limit fired.
+        const totalBudgetMs = this.requestTimeoutMs * TAIL_READ_TOTAL_BUDGET_FACTOR;
         const startedAt = Date.now();
         try {
             while (true) {
-                const remainingMs = this.requestTimeoutMs - (Date.now() - startedAt);
-                if (remainingMs <= 0)
-                    throw buildBodyReadTimeoutError(this.requestTimeoutMs);
-                const { done, value, } = await readChunkWithDeadline(reader, remainingMs, this.requestTimeoutMs);
+                const totalRemainingMs = totalBudgetMs - (Date.now() - startedAt);
+                const totalBound = totalRemainingMs < this.requestTimeoutMs;
+                let chunk;
+                try {
+                    chunk = await readChunkWithDeadline(reader, Math.max(0, Math.min(this.requestTimeoutMs, totalRemainingMs)), this.requestTimeoutMs);
+                }
+                catch (error) {
+                    if (!totalBound || !(error instanceof DataikuError) || error.status !== 0)
+                        throw error;
+                    throw new DataikuError(0, "Request Timeout", `Response body was still arriving after ${totalBudgetMs}ms (the total read limit is ${TAIL_READ_TOTAL_BUDGET_FACTOR}x --request-timeout); raise --request-timeout to allow more time.`);
+                }
+                const { done, value, } = chunk;
                 if (done)
                     break;
                 if (limit === 0) {
@@ -1187,9 +1213,8 @@ export class DataikuClient {
                     ...init,
                     method,
                     signal: controller.signal,
+                    ...(this.session ? { session: this.session, } : {}),
                 };
-                if (this.tlsOptions)
-                    requestInit.tls = this.tlsOptions;
                 const res = await fetch(url, requestInit);
                 this.logTrace({
                     phase: "response",

package/dist/src/errors.d.ts

@@ -51,6 +51,8 @@ export declare const UNEXPECTED_RESPONSE_MARKER = "Unexpected DSS response";
 export declare function unexpectedResponseError(detail: string, status?: number): DataikuError;
 /** Prefix for a SQL query failure reported by DSS on a 2xx finish-streaming response. */
 export declare const SQL_QUERY_FAILED_MARKER = "SQL query failed in DSS";
+/** statusText of a DataikuError raised when a response exceeds a client-side byte budget. */
+export declare const RESPONSE_TOO_LARGE_STATUS_TEXT = "Response Too Large";
 /** Generic permission hint; the CLI names the project when the request was project-scoped. */
 export declare const FORBIDDEN_HINT = "Check API key validity and project permissions for the requested action.";
 /** Generic 404 hint; the CLI names the resource and project when it knows them. */

package/dist/src/errors.js

@@ -78,6 +78,9 @@ export function unexpectedResponseError(detail, status = 200) {
 const DEFINITE_FAILURE_HINT = "DSS reported that the request failed (for SQL: syntax error, missing object, or missing privileges of the connection's role). Fix the request or grants; do not retry unchanged.";
 /** Prefix for a SQL query failure reported by DSS on a 2xx finish-streaming response. */
 export const SQL_QUERY_FAILED_MARKER = "SQL query failed in DSS";
+/** statusText of a DataikuError raised when a response exceeds a client-side byte budget. */
+export const RESPONSE_TOO_LARGE_STATUS_TEXT = "Response Too Large";
+const RESPONSE_TOO_LARGE_HINT = "The response exceeded a client-side size limit; retrying returns the same body. Narrow the request (fewer rows or columns, --preview, --output PATH) instead.";
 const TLS_CERTIFICATE_HINT = "TLS certificate verification failed. Trust the DSS/corporate CA with --ca-cert PATH or NODE_EXTRA_CA_CERTS, or save it for every process and directory with `dss auth login --ca-cert PATH` (a project .env applies only when dss runs in that directory); use --insecure only for temporary troubleshooting.";
 /** Generic permission hint; the CLI names the project when the request was project-scoped. */
 export const FORBIDDEN_HINT = "Check API key validity and project permissions for the requested action.";
@@ -388,14 +391,21 @@ export class DataikuError extends Error {
         this.body = body;
         this.name = "DataikuError";
         const definite = trustedMetadata?.definiteFailure === true;
+        // A client-side byte budget tripped: the same request returns the same
+        // oversized body, so retrying cannot help (it is not a transport fault).
+        const overBudget = statusText === RESPONSE_TOO_LARGE_STATUS_TEXT;
         // A definite DSS refusal is not a transport/server fault: replaying it
         // unchanged cannot succeed. Keep a more specific forbidden/not_found class.
-        const reclassify = definite
+        const reclassify = overBudget || definite
             && (details.category === "transient" || details.category === "unknown"
                 || details.category === "unexpected_response");
         this.category = reclassify ? "validation" : details.category;
         this.retryable = reclassify ? false : details.retryable;
-        this.retryHint = reclassify ? DEFINITE_FAILURE_HINT : details.retryHint;
+        this.retryHint = overBudget
+            ? RESPONSE_TOO_LARGE_HINT
+            : reclassify
+                ? DEFINITE_FAILURE_HINT
+                : details.retryHint;
         this.retry = retry;
         this.requestId = requestId;
         this.trustedTarget = trustedMetadata?.target;