convex 1.45.0 → 1.47.0

package/src/cli/lib/formatValidationProgress.ts

@@ -0,0 +1,35 @@
+import { chalkStderr } from "chalk";
+import { DiscardedStagedValidator } from "./deployApi/evaluateSchema.js";
+
+export function formatValidationProgress({
+  numDocsValidated,
+  totalDocs,
+}: {
+  numDocsValidated: number;
+  totalDocs?: number | null | undefined;
+}): string {
+  const checked = numDocsValidated.toLocaleString();
+  return totalDocs === null || totalDocs === undefined
+    ? `${checked} documents checked`
+    : `${checked} of approximately ${totalDocs.toLocaleString()} documents checked`;
+}
+
+/** "validated; the push removes the staged validator" */
+export function formatDiscardedStagedValidator(
+  validator: DiscardedStagedValidator,
+): string {
+  let status;
+  switch (validator.state.state) {
+    case "pending": {
+      status = `validating in the background (${formatValidationProgress(validator.state)})`;
+      break;
+    }
+    case "valid":
+      status = chalkStderr.green("validated");
+      break;
+  }
+  const action = validator.replaced
+    ? "the push stages a different validator"
+    : "the push removes the staged validator";
+  return `${status}; ${action}`;
+}

package/src/cli/lib/generatedFunctionLogsApi.ts

@@ -103,6 +103,8 @@ export interface components {
             /** Format: int64 */
             databaseWriteDocuments: number;
             /** Format: int64 */
+            databaseWriteIndexRows: number;
+            /** Format: int64 */
             storageReadBytes: number;
             /** Format: int64 */
             storageWriteBytes: number;

package/src/cli/lib/indexes.ts

@@ -27,7 +27,7 @@ export type LargeIndexDeletionCheck =
   | "no verification"
   // If large indexes are being deleted, ask for confirmation (and fail in non-interactive envs)
   | "ask for confirmation"
-  // If large indexes are being deleted, confirm (the user has used --allow-deleting-large-indexes)
+  // If large indexes are being deleted, confirm (the user has used --skip-large-indexes-check)
   | "has confirmation";
 
 export function addProgressLinkIfSlow(

package/src/cli/lib/localDeployment/run.ts

@@ -13,10 +13,28 @@ import detect from "detect-port";
 import { LOCAL_BACKEND_SENTRY_DSN } from "../utils/sentry.js";
 import { createHash } from "crypto";
 import { LocalDeploymentError } from "./errors.js";
-import { LOCAL_BACKEND_INSTANCE_SECRET } from "./utils.js";
+import { LOCAL_BACKEND_INSTANCE_SECRET, releaseDate } from "./utils.js";
 import { DeploymentType, DetailedDeploymentCredentials } from "../api.js";
+import { productionProvisionHost, provisionHost } from "../config.js";
 
 const DEFAULT_STARTUP_TIMEOUT_SECS = 30;
+const FIRST_CONTROL_PLANE_AUTH_BACKEND_VERSION =
+  "precompiled-2026-09-15-4e9b83a";
+
+export function _backendSupportsControlPlaneAuth(version: string): boolean {
+  if (version === FIRST_CONTROL_PLANE_AUTH_BACKEND_VERSION) {
+    return true;
+  }
+  const backendDate = releaseDate(version);
+  const firstSupportedDate = releaseDate(
+    FIRST_CONTROL_PLANE_AUTH_BACKEND_VERSION,
+  );
+  return (
+    backendDate !== null &&
+    firstSupportedDate !== null &&
+    backendDate > firstSupportedDate
+  );
+}
 
 async function parseStartupTimeoutSecs(ctx: Context): Promise<number> {
   const raw = process.env.CONVEX_LOCAL_BACKEND_STARTUP_TIMEOUT_SECS;
@@ -44,6 +62,7 @@ export async function runLocalBackend(
     deploymentKind: LocalDeploymentKind;
     deploymentName: string;
     binaryPath: string;
+    backendVersion: string;
     instanceSecret: string;
     isLatestVersion: boolean;
   },
@@ -128,7 +147,29 @@ export async function runLocalBackend(
       errForSentry: new LocalDeploymentError(message),
     });
   }
-  const commandStr = `${args.binaryPath} ${commandArgs.join(" ")}`;
+  const supportsControlPlane = _backendSupportsControlPlaneAuth(
+    args.backendVersion,
+  );
+  if (supportsControlPlane && provisionHost !== productionProvisionHost) {
+    commandArgs.push("--control-plane-url", provisionHost);
+  }
+  const auth = ctx.bigBrainAuth();
+  if (
+    supportsControlPlane &&
+    args.deploymentKind === "local" &&
+    auth?.kind === "accessToken"
+  ) {
+    commandArgs.push("--control-plane-access-token", auth.accessToken);
+  }
+  const displayArgs = commandArgs.map((arg, index) =>
+    index > 0 &&
+    ["--instance-secret", "--control-plane-access-token"].includes(
+      commandArgs[index - 1],
+    )
+      ? "[REDACTED]"
+      : arg,
+  );
+  const commandStr = `${args.binaryPath} ${displayArgs.join(" ")}`;
   logVerbose(`Starting local backend: \`${commandStr}\``);
   const p = child_process
     .spawn(args.binaryPath, commandArgs, {
@@ -428,6 +469,7 @@ async function startEphemeralLocalBackend(
 
   const { cleanupHandle } = await runLocalBackend(ctx, {
     binaryPath,
+    backendVersion: config.backendVersion,
     ports: config.ports,
     deploymentKind,
     deploymentName: args.deploymentName,

package/src/cli/lib/localDeployment/upgrade.ts

@@ -10,6 +10,7 @@ import {
   saveDeploymentConfig,
 } from "./filePaths.js";
 import { runLocalBackend } from "./run.js";
+import { releaseDate } from "./utils.js";
 import { promptYesNo } from "../utils/prompts.js";
 import { ensureBackendBinaryDownloaded } from "./download.js";
 import {
@@ -66,6 +67,7 @@ export async function handlePotentialUpgradeAndStart(
     );
     const { cleanupHandle } = await runLocalBackend(ctx, {
       binaryPath: args.newBinaryPath,
+      backendVersion: args.newVersion,
       deploymentKind: args.deploymentKind,
       deploymentName: args.deploymentName,
       ports: args.ports,
@@ -99,6 +101,7 @@ export async function handlePotentialUpgradeAndStart(
     });
     const { cleanupHandle } = await runLocalBackend(ctx, {
       binaryPath: oldBinaryPath,
+      backendVersion: args.oldVersion,
       ports: args.ports,
       deploymentKind: args.deploymentKind,
       deploymentName: args.deploymentName,
@@ -155,6 +158,7 @@ async function handleUpgrade(
   logVerbose(`Running backend on new version ${args.newVersion}`);
   const { cleanupHandle } = await runLocalBackend(ctx, {
     binaryPath: args.newBinaryPath,
+    backendVersion: args.newVersion,
     ports: args.ports,
     deploymentKind: args.deploymentKind,
     deploymentName: args.deploymentName,
@@ -182,9 +186,3 @@ export function _isDowngrade(oldVersion: string, newVersion: string): boolean {
   const newDate = releaseDate(newVersion);
   return oldDate !== null && newDate !== null && newDate < oldDate;
 }
-
-// Backend releases are tagged `precompiled-YYYY-MM-DD-<commit>`, so the dates
-// sort lexicographically.
-function releaseDate(version: string): string | null {
-  return /^precompiled-(\d{4}-\d{2}-\d{2})-/.exec(version)?.[1] ?? null;
-}

package/src/cli/lib/localDeployment/utils.ts

@@ -92,3 +92,9 @@ export function printLocalDeploymentWelcomeMessage() {
 
 export const LOCAL_BACKEND_INSTANCE_SECRET =
   "4361726e697461732c206c69746572616c6c79206d65616e696e6720226c6974";
+
+// Backend releases are tagged `precompiled-YYYY-MM-DD-<commit>`, so the dates
+// sort lexicographically.
+export function releaseDate(version: string): string | null {
+  return /^precompiled-(\d{4}-\d{2}-\d{2})-/.exec(version)?.[1] ?? null;
+}

package/src/cli/lib/mcp/tools/env.ts

@@ -12,13 +12,22 @@ const envListInputSchema = z.object({
     .describe(
       "Deployment selector (from the status tool) to list environment variables from.",
     ),
+  includeValues: z
+    .boolean()
+    .optional()
+    .describe(
+      "Also return each variable's value. Values are often secrets like API keys, so leave this off unless you need every value, and use envGet to read a single variable instead.",
+    ),
 });
 
 const envListOutputSchema = z.object({
   variables: z.array(
     z.object({
       name: z.string(),
-      value: z.string(),
+      value: z
+        .string()
+        .optional()
+        .describe("Only present when includeValues is true."),
     }),
   ),
 });
@@ -28,7 +37,8 @@ export const EnvListTool: ConvexTool<
   typeof envListOutputSchema
 > = {
   name: "envList",
-  description: "List all environment variables in your Convex deployment.",
+  description:
+    "List the names of all environment variables in your Convex deployment. Values are left out unless includeValues is true.",
   inputSchema: envListInputSchema,
   outputSchema: envListOutputSchema,
   handler: async (ctx, args) => {
@@ -51,7 +61,11 @@ export const EnvListTool: ConvexTool<
       componentPath: undefined,
       args: {},
     })) as EnvVar[];
-    return { variables };
+    return {
+      variables: variables.map(({ name, value }) =>
+        args.includeValues ? { name, value } : { name },
+      ),
+    };
   },
 };
 

package/src/cli/lib/run.ts

@@ -535,6 +535,9 @@ export async function pushToDeployment(
       liveComponentSources: args.liveComponentSources,
       pushAllModules: false,
       largeIndexDeletionCheck: "no verification", // `convex run` can’t push to prod
+      largeIndexBackfillCheck: "no verification", // ditto
+      stagedValidatorDeletionCheck: "no verification", // ditto
+      warnOnSlowSchemaValidation: true,
       message: null,
     },
     {

package/src/cli/lib/schemaEvaluation.ts

@@ -0,0 +1,88 @@
+import { Context } from "../../bundler/context.js";
+import { logVerbose } from "../../bundler/log.js";
+import { EvaluateSchemaResponse } from "./deployApi/evaluateSchema.js";
+import { StartPushRequest } from "./deployApi/startPush.js";
+import { evaluateSchema } from "./deploy2.js";
+import { Span } from "./tracing.js";
+
+type EvaluateOptions = {
+  url: string;
+  deploymentName: string | null;
+  adminKey: string;
+};
+
+/**
+ * A schema evaluation shared by the pre-push checks. Resolves to `null` when
+ * the deployment doesn't support `evaluate_schema` or the request failed, in
+ * which case each check skips itself.
+ */
+export type SchemaEvaluation = (
+  span: Span,
+) => Promise<EvaluateSchemaResponse | null>;
+
+/**
+ * Evaluate the schema at most once per push however many checks consume it:
+ * the first check to call sends the request under its own span, and the rest
+ * await the same promise. Each request makes the backend evaluate the schema
+ * module in an isolate and predict against a fresh snapshot, so repeating it
+ * per check would add that work and a round trip to the deploy's critical
+ * path for every check.
+ */
+/**
+ * Whether a schema module in the push calls `.staged(`. Bundles aren't
+ * minified, so the call survives bundling. A false positive from a comment or
+ * string costs one evaluation, while a push without staged validators skips
+ * the evaluation round trip on its critical path.
+ */
+export function pushStagesValidators(request: StartPushRequest): boolean {
+  return [
+    request.appDefinition.schema,
+    ...request.componentDefinitions.map((definition) => definition.schema),
+  ].some((schema) => schema?.source.includes(".staged(") ?? false);
+}
+
+export function sharedSchemaEvaluation(
+  ctx: Context,
+  request: StartPushRequest,
+  options: EvaluateOptions,
+): SchemaEvaluation {
+  let evaluation: Promise<EvaluateSchemaResponse | null> | undefined;
+  return (span) => {
+    evaluation ??= evaluateSchemaBestEffort({ ctx, span, request, options });
+    return evaluation;
+  };
+}
+
+// The checks are advisory: if evaluation fails, fall back to skipping them
+// rather than aborting the push over a check that isn't required for
+// correctness. Plausibly transient failures — network errors and 5xx
+// responses (e.g. table summaries still bootstrapping) — are retried with
+// backoff by the shared fetch wrapper (see `pushCode`); anything else is
+// deterministic, including a 2xx whose shape the CLI doesn't recognize, so
+// it skips the checks immediately.
+async function evaluateSchemaBestEffort({
+  ctx,
+  span,
+  request,
+  options,
+}: {
+  ctx: Context;
+  span: Span;
+  request: StartPushRequest;
+  options: EvaluateOptions;
+}): Promise<EvaluateSchemaResponse | null> {
+  try {
+    return await evaluateSchema(
+      ctx,
+      span,
+      request,
+      options,
+      /* bestEffort */ true,
+    );
+  } catch (error: unknown) {
+    logVerbose(
+      `Skipping schema evaluation checks: ${error instanceof Error ? error.message : String(error)}`,
+    );
+    return null;
+  }
+}

package/src/cli/lib/usageLimits.ts

@@ -21,6 +21,7 @@ export const USAGE_LIMIT_METRICS = [
   "databaseIoGb",
   "searchQueryGb",
   "dataEgressGb",
+  "aiGatewayCostDollars",
 ] as const satisfies readonly UsageLimitMetric[];
 
 // Fails to compile if the backend's `UsageLimitMetric` gains a metric not listed
@@ -47,6 +48,7 @@ export const METRIC_LABELS: Record<UsageLimitMetric, string> = {
   databaseIoGb: "Database I/O",
   searchQueryGb: "Search queries",
   dataEgressGb: "Data egress",
+  aiGatewayCostDollars: "AI Gateway",
 };
 
 export function metricLabel(metric: string): string {

package/src/cli/lib/utils/mutex.ts

@@ -1,32 +1,14 @@
 export class Mutex {
-  currentlyRunning: Promise<void> | null = null;
-  waiting: Array<() => Promise<void>> = [];
+  private tail: Promise<void> = Promise.resolve();
 
   async runExclusive<T>(fn: () => Promise<T>): Promise<T> {
-    const outerPromise = new Promise<T>((resolve, reject) => {
-      const wrappedCallback: () => Promise<void> = () => {
-        return fn()
-          .then((v: T) => resolve(v))
-          .catch((e: any) => reject(e));
-      };
-      this.enqueueCallbackForMutex(wrappedCallback);
-    });
-    return outerPromise;
-  }
-
-  private enqueueCallbackForMutex(callback: () => Promise<void>) {
-    if (this.currentlyRunning === null) {
-      this.currentlyRunning = callback().finally(() => {
-        const nextCb = this.waiting.shift();
-        if (nextCb === undefined) {
-          this.currentlyRunning = null;
-        } else {
-          this.enqueueCallbackForMutex(nextCb);
-        }
-      });
-      this.waiting.length = 0;
-    } else {
-      this.waiting.push(callback);
-    }
+    const result = this.tail.then(fn);
+    // Reserve the next position before running fn, and allow the queue to
+    // continue even if fn rejects or throws synchronously.
+    this.tail = result.then(
+      () => {},
+      () => {},
+    );
+    return result;
   }
 }

package/src/cli/lib/utils/utils.ts

@@ -517,6 +517,23 @@ export async function selectRegionOrUseDefault(
   return selectedRegionName;
 }
 
+// Mirrors the order of `REGION_PRESENTATION` in
+// `npm-packages/dashboard/src/lib/regions.ts`, so both region pickers list
+// regions in the same order.
+const REGION_ORDER: string[] = [
+  "aws-us-east-1",
+  "aws-eu-west-1",
+  "aws-ca-central-1",
+  "aws-ap-southeast-2",
+];
+
+// Regions missing from `REGION_ORDER` (e.g. newly launched ones) go last, in
+// server order, since `Array.prototype.sort` is stable.
+function regionSortIndex(regionName: string): number {
+  const index = REGION_ORDER.indexOf(regionName);
+  return index === -1 ? REGION_ORDER.length : index;
+}
+
 export async function selectRegion(
   ctx: Context,
   teamId: number,
@@ -538,12 +555,7 @@ export async function selectRegion(
       name: item.displayName,
       value: item.name,
     }))
-    .sort((a, b) => {
-      // Show US region first if it exists
-      if (a.value === "aws-us-east-1") return -1;
-      if (b.value === "aws-us-east-1") return 1;
-      return 0;
-    });
+    .sort((a, b) => regionSortIndex(a.value) - regionSortIndex(b.value));
   return await promptOptions(ctx, {
     message: `Where should this ${deploymentType} deployment run?`,
     suffix: `\n${chalkStderr.gray(
@@ -559,16 +571,18 @@ export async function hasProject(
   projectSlug: string,
 ) {
   try {
-    const projects: Project[] = (
-      await typedBigBrainClient(ctx).GET("/teams/{team_slug}/projects", {
+    await typedPlatformClient(ctx, { throw: true }).GET(
+      "/teams/{team_id_or_slug}/projects/{project_slug}",
+      {
         params: {
           path: {
-            team_slug: teamSlug,
+            team_id_or_slug: teamSlug,
+            project_slug: projectSlug,
           },
         },
-      })
-    ).data!;
-    return !!projects.find((project) => project.slug === projectSlug);
+      },
+    );
+    return true;
   } catch {
     return false;
   }
@@ -581,19 +595,27 @@ export async function hasProjects(ctx: Context) {
 export async function validateOrSelectProject(
   ctx: Context,
   projectSlug: string | undefined,
-  teamSlug: string,
+  teamId: number,
   singleProjectPrompt: string,
   multiProjectPrompt: string,
 ): Promise<string | null> {
-  const projects: Project[] = (
-    await typedBigBrainClient(ctx).GET("/teams/{team_slug}/projects", {
-      params: {
-        path: {
-          team_slug: teamSlug,
+  const projects: Project[] = [];
+  const client = typedPlatformClient(ctx);
+  let cursor: string | undefined;
+  do {
+    const { items, pagination } = (
+      await client.GET("/teams/{team_id}/projects", {
+        params: {
+          path: { team_id: teamId },
+          query: cursor === undefined ? {} : { cursor },
         },
-      },
-    })
-  ).data!;
+      })
+    ).data!;
+    projects.push(...items);
+    cursor = pagination.hasMore
+      ? (pagination.nextCursor ?? undefined)
+      : undefined;
+  } while (cursor !== undefined);
   if (projects.length === 0) {
     return await ctx.crash({
       exitCode: 1,
@@ -972,40 +994,49 @@ export function waitUntilCalled(): [Promise<unknown>, () => void] {
   return [waitPromise, () => onCalled(null)];
 }
 
-const BYTE_UNITS: [number, string][] = [
-  [1 << 30, "GiB"],
-  [1_000_000_000, "GB"],
-  [1 << 20, "MiB"],
-  [1_000_000, "MB"],
-  [1 << 10, "KiB"],
-  [1_000, "KB"],
-];
+const BYTE_UNITS = ["bytes", "KiB", "MiB", "GiB", "TiB", "PiB"];
 
 /**
- * Format a byte count into a human-friendly string.
- *
- * Picks the unit (binary or decimal) that divides most cleanly.
- * Shows one decimal place only when it divides exactly (e.g. "4.1 MiB").
- * Falls back to raw bytes when no unit divides cleanly.
+ * Format a byte count into a human-friendly string, rounded to one decimal
+ * place (dropped when it would be ".0"), e.g. "4.1 MiB" or "128 MiB".
  */
 export function formatSize(n: number): string {
-  if (n === 0) {
-    return "0 bytes";
+  let value = n;
+  let unitIndex = 0;
+  while (value >= 1024 && unitIndex < BYTE_UNITS.length - 1) {
+    value /= 1024;
+    unitIndex++;
   }
-  for (const [unitSize, unitName] of BYTE_UNITS) {
-    if (n < unitSize) {
-      continue;
-    }
-    if (n % unitSize === 0) {
-      return `${n / unitSize} ${unitName}`;
-    }
-    if ((n * 10) % unitSize === 0) {
-      const whole = Math.floor(n / unitSize);
-      const frac = Math.floor((n * 10) / unitSize) % 10;
-      return `${whole}.${frac} ${unitName}`;
-    }
+  // Rounding to one decimal place can itself reach the next unit's
+  // boundary (e.g. 1023.999 KiB -> "1024.0 KiB" instead of "1.0 MiB").
+  const roundedValue = Number(value.toFixed(1));
+  if (roundedValue >= 1024 && unitIndex < BYTE_UNITS.length - 1) {
+    value /= 1024;
+    unitIndex++;
+  }
+  const formatted = value.toFixed(1).replace(/\.0$/, "");
+  return `${formatted} ${BYTE_UNITS[unitIndex]}`;
+}
+
+/**
+ * Read an integer override from the environment, falling back to
+ * `defaultValue` when the variable is unset. The whole value must be a
+ * base-10 integer: `parseInt` would read a typo like `100_000` or `100k` as
+ * 100 and silently move the threshold, so anything else is rejected with a
+ * warning instead.
+ */
+export function integerFromEnv(envVar: string, defaultValue: number): number {
+  const envValue = process.env[envVar];
+  if (envValue === undefined) {
+    return defaultValue;
+  }
+  if (!/^[+-]?\d+$/.test(envValue.trim())) {
+    logWarning(
+      `Ignoring ${envVar}=${JSON.stringify(envValue)}: expected an integer, using ${defaultValue}`,
+    );
+    return defaultValue;
   }
-  return `${n} bytes`;
+  return Number(envValue);
 }
 
 export function formatDuration(ms: number): string {
@@ -1195,12 +1226,12 @@ export function spawnAsync(
 
 const IDEMPOTENT_METHODS = ["GET", "HEAD", "PUT", "DELETE", "OPTIONS", "TRACE"];
 
-function retryDelay(
+// immediate, 1s delay, 2s delay, 4s delay, etc.
+export function retryDelay(
   attempt: number,
   _error: Error | null,
   _response: Response | null,
 ): number {
-  // immediate, 1s delay, 2s delay, 4s delay, etc.
   const delay = attempt === 0 ? 1 : 2 ** (attempt - 1) * 1000;
   const randomSum = delay * 0.2 * Math.random();
   return delay + randomSum;
@@ -1209,8 +1240,13 @@ function retryDelay(
 function deploymentFetchRetryOn(
   onError?: (err: any, attempt: number) => void,
   method?: string,
+  maxRetries: number = MAX_RETRIES,
+  shouldRetryOverride?: (
+    error: Error | null,
+    response: Response | null,
+  ) => boolean,
 ) {
-  const shouldRetry = function (
+  const defaultShouldRetry = function (
     _attempt: number,
     error: Error | null,
     response: Response | null,
@@ -1266,6 +1302,21 @@ function deploymentFetchRetryOn(
     return { kind: "stop" };
   };
 
+  const shouldRetry = shouldRetryOverride
+    ? function (
+        _attempt: number,
+        error: Error | null,
+        response: Response | null,
+      ): { kind: "retry"; error: any } | { kind: "stop" } {
+        return shouldRetryOverride(error, response)
+          ? {
+              kind: "retry",
+              error:
+                error ?? `Received response with status ${response?.status}`,
+            }
+          : { kind: "stop" };
+      }
+    : defaultShouldRetry;
   return function (
     attempt: number,
     error: Error | null,
@@ -1275,7 +1326,7 @@ function deploymentFetchRetryOn(
     if (result.kind === "retry") {
       onError?.(result.error, attempt);
     }
-    if (attempt >= MAX_RETRIES) {
+    if (attempt >= maxRetries) {
       // Stop retrying if we've exhausted all retries, but do this after we've
       // called `onError` so that the caller can still log the error.
       return false;
@@ -1334,15 +1385,30 @@ export function deploymentFetch(
     deploymentUrl: string;
     adminKey: string;
     onError?: (err: any) => void;
+    // Defaults to MAX_RETRIES. Lower this for best-effort requests (e.g.
+    // advisory checks) where a slow retry loop against an unsupported or
+    // unhealthy endpoint shouldn't hold up the surrounding command.
+    maxRetries?: number | undefined;
+    // Replaces the default retry policy (which is tuned for pushes: network
+    // errors, 404s on fresh deployments, retries of idempotent methods).
+    // Return true to retry the request. Backoff and retry logging are
+    // shared either way.
+    shouldRetry?: (error: Error | null, response: Response | null) => boolean;
   },
 ): typeof fetch {
-  const { deploymentUrl, adminKey, onError } = options;
+  const {
+    deploymentUrl,
+    adminKey,
+    onError,
+    maxRetries = MAX_RETRIES,
+    shouldRetry,
+  } = options;
   const onErrorWithAttempt = (err: any, attempt: number) => {
     onError?.(err);
     if (attempt >= RETRY_LOG_THRESHOLD) {
       logMessage(
         chalkStderr.gray(
-          `Retrying request (attempt ${attempt}/${MAX_RETRIES})...`,
+          `Retrying request (attempt ${attempt}/${maxRetries})...`,
         ),
       );
     }
@@ -1367,7 +1433,12 @@ export function deploymentFetch(
     }
     const func = throwingFetch(url, {
       retryDelay,
-      retryOn: deploymentFetchRetryOn(onErrorWithAttempt, options?.method),
+      retryOn: deploymentFetchRetryOn(
+        onErrorWithAttempt,
+        options?.method,
+        maxRetries,
+        shouldRetry,
+      ),
       ...options,
       headers,
     });