deepline 0.1.220 → 0.1.222

package/dist/bundling-sources/sdk/src/release.ts

@@ -108,10 +108,10 @@ export const SDK_RELEASE = {
   // 0.1.175 ships loud `deepline enrich` empty-waterfall reporting.
   // 0.1.220 deprecates SDK CLI versions below 0.1.219 and updates them
   // automatically without blocking their current command.
-  version: '0.1.220',
+  version: '0.1.222',
   apiContract: '2026-06-dataset-handle-results-hard-cutover',
   supportPolicy: {
-    latest: '0.1.220',
+    latest: '0.1.222',
     minimumSupported: '0.1.53',
     deprecatedBelow: '0.1.219',
     commandMinimumSupported: [

package/dist/bundling-sources/sdk/src/types.ts

@@ -997,6 +997,27 @@ export interface PlayCheckResult {
   summary?: string;
   artifactHash?: string | null;
   graphHash?: string | null;
+  /** SHA-256 of the exact source bytes checked by Deepline. */
+  sourceHash?: string | null;
+  /** Enforceable byte budgets measured during cloud preflight. */
+  limits?: {
+    revisionStorage: {
+      usedBytes: number;
+      limitBytes: number;
+      withinLimit: boolean;
+      breakdown: {
+        sourceCodeBytes: number;
+        staticPipelineBytes: number;
+        bindingsBytes: number;
+        descriptionBytes: number;
+      };
+    };
+    bundle: {
+      usedBytes: number;
+      limitBytes: number;
+      withinLimit: boolean;
+    };
+  };
 }
 
 /** Severity of a {@link PlayCheckIssue}. `error` fails the check; `warning` does not. */

package/dist/bundling-sources/shared_libs/play-runtime/context.ts

@@ -288,6 +288,9 @@ const MAP_INCREMENTAL_PERSIST_CHUNK_ROWS = 100;
 const MAP_INCREMENTAL_PERSIST_CHUNK_BYTES = 1 * 1024 * 1024;
 const MAP_INCREMENTAL_PERSIST_INTERVAL_MS = 100;
 const MAP_FRAME_FLUSH_INTERVAL_MS = 250;
+// Batchable calls wait at most this long for same-key row continuations. The
+// window is fixed from the first item and never resets on later arrivals.
+const TOOL_BATCH_COALESCE_WINDOW_MS = 5;
 const TOOL_RETRY_AFTER_FALLBACK_MS = 1_000;
 const TOOL_RETRY_HEARTBEAT_INTERVAL_MS = 30_000;
 const DEEPLINEAGENT_TOOL_RUNTIME_TIMEOUT_MS = 15 * 60 * 1000;
@@ -1196,6 +1199,14 @@ function createPacingResolver(
 export class PlayContextImpl {
   private rowStates = new Map<number, RowState>();
   private toolCallQueue: ToolCallRequest[] = [];
+  /**
+   * Fixed, non-resetting coalescing deadlines for batchable ready work. A
+   * deadline starts when the first request enters an empty batch bucket. New
+   * arrivals never push it back, so sustained traffic cannot starve dispatch.
+   */
+  private readonly toolBatchQueuedAtByKey = new Map<string, number>();
+  private readonly toolDispatcherWakeWaiters = new Set<() => void>();
+  private toolDispatcherFailure: unknown | null = null;
   private toolCallResolvers = new Map<
     string,
     { resolve: (value: unknown) => void; reject: (reason: unknown) => void }
@@ -6064,33 +6075,172 @@ export class PlayContextImpl {
     }
   }
 
+  private toolBatchCoalesceKey(request: ToolCallRequest): string | null {
+    const strategy =
+      this.#options.getBatchOperationStrategy?.(request.toolId) ?? null;
+    if (!strategy) return null;
+    return [
+      request.toolId,
+      request.executionAuthScopeDigest ?? '',
+      String(strategy.toBucketKey(request.input)),
+    ].join('\u0000');
+  }
+
+  private wakeToolDispatcher(): void {
+    const waiters = [...this.toolDispatcherWakeWaiters];
+    this.toolDispatcherWakeWaiters.clear();
+    for (const wake of waiters) wake();
+  }
+
+  private enqueueToolCall(request: ToolCallRequest): void {
+    if (this.toolDispatcherFailure != null) {
+      const resolver = this.toolCallResolvers.get(request.callId);
+      if (resolver) {
+        resolver.reject(this.toolDispatcherFailure);
+        this.toolCallResolvers.delete(request.callId);
+      }
+      return;
+    }
+    this.toolCallQueue.push(request);
+    const batchKey = this.toolBatchCoalesceKey(request);
+    if (batchKey && !this.toolBatchQueuedAtByKey.has(batchKey)) {
+      this.toolBatchQueuedAtByKey.set(batchKey, Date.now());
+    }
+    this.wakeToolDispatcher();
+  }
+
+  private rejectQueuedToolCalls(error: unknown): void {
+    const queued = this.toolCallQueue;
+    this.toolCallQueue = [];
+    this.toolBatchQueuedAtByKey.clear();
+    for (const request of queued) {
+      const resolver = this.toolCallResolvers.get(request.callId);
+      if (!resolver) continue;
+      resolver.reject(error);
+      this.toolCallResolvers.delete(request.callId);
+    }
+  }
+
+  private takeDispatchableToolCalls(nowMs: number): {
+    requests: ToolCallRequest[];
+    nextDeadlineMs: number | null;
+  } {
+    if (this.toolCallQueue.length === 0) {
+      return { requests: [], nextDeadlineMs: null };
+    }
+
+    const batchCounts = new Map<string, number>();
+    const batchMaxSizes = new Map<string, number>();
+    for (const request of this.toolCallQueue) {
+      const batchKey = this.toolBatchCoalesceKey(request);
+      if (!batchKey) continue;
+      batchCounts.set(batchKey, (batchCounts.get(batchKey) ?? 0) + 1);
+      const strategy =
+        this.#options.getBatchOperationStrategy?.(request.toolId) ?? null;
+      if (strategy) batchMaxSizes.set(batchKey, strategy.maxBatchSize);
+    }
+
+    const readyBatchKeys = new Set<string>();
+    let nextDeadlineMs: number | null = null;
+    for (const [batchKey, count] of batchCounts) {
+      const queuedAt = this.toolBatchQueuedAtByKey.get(batchKey) ?? nowMs;
+      if (!this.toolBatchQueuedAtByKey.has(batchKey)) {
+        this.toolBatchQueuedAtByKey.set(batchKey, queuedAt);
+      }
+      const deadline = queuedAt + TOOL_BATCH_COALESCE_WINDOW_MS;
+      const maxBatchSize = batchMaxSizes.get(batchKey) ?? 1;
+      if (count >= maxBatchSize || deadline <= nowMs) {
+        readyBatchKeys.add(batchKey);
+      } else {
+        nextDeadlineMs =
+          nextDeadlineMs == null
+            ? deadline
+            : Math.min(nextDeadlineMs, deadline);
+      }
+    }
+
+    const requests: ToolCallRequest[] = [];
+    const remaining: ToolCallRequest[] = [];
+    for (const request of this.toolCallQueue) {
+      const batchKey = this.toolBatchCoalesceKey(request);
+      if (!batchKey || readyBatchKeys.has(batchKey)) {
+        requests.push(request);
+      } else {
+        remaining.push(request);
+      }
+    }
+    this.toolCallQueue = remaining;
+    for (const batchKey of readyBatchKeys) {
+      this.toolBatchQueuedAtByKey.delete(batchKey);
+    }
+    return { requests, nextDeadlineMs };
+  }
+
+  private waitForToolDispatcherWake(deadlineMs: number | null): Promise<void> {
+    return new Promise((resolve) => {
+      let timer: ReturnType<typeof setTimeout> | null = null;
+      const wake = () => {
+        if (timer) clearTimeout(timer);
+        this.toolDispatcherWakeWaiters.delete(wake);
+        resolve();
+      };
+      this.toolDispatcherWakeWaiters.add(wake);
+      if (deadlineMs != null) {
+        timer = setTimeout(wake, Math.max(0, deadlineMs - Date.now()));
+      }
+    });
+  }
+
   private async drainQueuedWork<T>(promises: Promise<T>[]): Promise<void> {
-    // Drain loop: each pass resolves queued tool calls.
-    // When a batch resolves, rows resume and may queue MORE calls
-    // (e.g. row does tools.execute('a') then tools.execute('b') sequentially).
-    // We keep looping until nothing new is queued and all rows finish.
-    //
-    // Important: an unresolved Promise by itself does not keep Node alive. The
-    // play runner is a short-lived child process, so parking on
-    // Promise.allSettled(promises) while there is no timer/socket/file handle can
-    // let Node exit 0 before main() emits the result envelope. That presents as
-    // "Local play runner produced no result" even though the real bug was a
-    // map row waiting for queued tool work. Always race row settlement
-    // against a small timer and re-check the queues instead of blocking forever
-    // on promises that may be waiting for this drain loop to do the next batch.
-    const raceSettled = () =>
-      Promise.race([
-        Promise.allSettled(promises).then(() => 'done' as const),
-        new Promise<'pending'>((r) => setTimeout(() => r('pending'), 50)),
-      ]);
-
-    let pass = 0;
-    while (true) {
-      const hasPendingWork = this.toolCallQueue.length > 0;
-
-      if (!hasPendingWork) {
-        const status = await raceSettled();
-        if (status === 'done' && this.toolCallQueue.length === 0) {
+    // One dispatcher owns ready work, fixed batch coalescing deadlines, and
+    // the in-flight registry. A row resumes after its own receipt persists; it
+    // never waits for unrelated sibling calls from the previous column.
+    const inFlightToolExecutions = new Set<Promise<void>>();
+    let rowsSettled = false;
+    void Promise.allSettled(promises).then(() => {
+      rowsSettled = true;
+      this.wakeToolDispatcher();
+    });
+    // A pending Promise does not keep a short-lived Node runner alive. Keep one
+    // handle open without polling scheduler state; actual work wakes the
+    // dispatcher through queue/in-flight/row-settlement signals.
+    const keepAlive = setInterval(() => undefined, 1_000);
+    try {
+      let pass = 0;
+      while (true) {
+        if (this.toolDispatcherFailure != null) {
+          this.rejectQueuedToolCalls(this.toolDispatcherFailure);
+          await Promise.allSettled([...inFlightToolExecutions]);
+          throw this.toolDispatcherFailure;
+        }
+
+        const dispatchable = this.takeDispatchableToolCalls(Date.now());
+        if (dispatchable.requests.length > 0) {
+          pass += 1;
+          this.log(`  Batch pass ${pass}`);
+          this.log(
+            `  Dispatcher launch: ready=${dispatchable.requests.length} ` +
+              `queued=${this.toolCallQueue.length} ` +
+              `in_flight_groups=${inFlightToolExecutions.size}`,
+          );
+          const tracked = this.executeBatchedToolCalls(dispatchable.requests)
+            .catch((error) => {
+              this.toolDispatcherFailure ??= error;
+              this.rejectQueuedToolCalls(error);
+            })
+            .finally(() => {
+              inFlightToolExecutions.delete(tracked);
+              this.wakeToolDispatcher();
+            });
+          inFlightToolExecutions.add(tracked);
+          continue;
+        }
+
+        if (
+          rowsSettled &&
+          this.toolCallQueue.length === 0 &&
+          inFlightToolExecutions.size === 0
+        ) {
           if (!this.activeDatasetStep) {
             const childPlaySuspension =
               this.consumePendingChildPlaySuspension();
@@ -6101,23 +6251,10 @@ export class PlayContextImpl {
           break;
         }
 
-        // Promises are still running, or they settled while scheduling one last
-        // batch. Give resolver microtasks a turn, then loop back and drain any
-        // newly queued work. This timer is deliberately tiny; it is here for
-        // correctness/liveness, not throughput throttling.
-        await new Promise((r) => setTimeout(r, 10));
-        continue;
-      }
-
-      pass++;
-      this.log(`  Batch pass ${pass}`);
-      this.log(
-        `  Queue depth before drain: tool_calls=${this.toolCallQueue.length}`,
-      );
-
-      if (this.toolCallQueue.length > 0) {
-        await this.executeBatchedToolCalls();
+        await this.waitForToolDispatcherWake(dispatchable.nextDeadlineMs);
       }
+    } finally {
+      clearInterval(keepAlive);
     }
   }
 
@@ -6392,7 +6529,7 @@ export class PlayContextImpl {
           toolId,
           options?.timeoutMs,
         );
-        this.toolCallQueue.push({
+        this.enqueueToolCall({
           callId,
           cacheKey: toolResultCacheKey,
           cacheable: cacheableToolResult,
@@ -7407,10 +7544,9 @@ export class PlayContextImpl {
 
   // ——— Batched tool call execution ———
 
-  private async executeBatchedToolCalls(): Promise<void> {
-    const queuedToolCalls = this.toolCallQueue;
-    this.toolCallQueue = [];
-
+  private async executeBatchedToolCalls(
+    queuedToolCalls: ToolCallRequest[],
+  ): Promise<void> {
     // Group by toolId
     const byTool = new Map<string, ToolCallRequest[]>();
     for (const req of queuedToolCalls) {
@@ -7418,7 +7554,7 @@ export class PlayContextImpl {
       byTool.get(req.toolId)!.push(req);
     }
 
-    await Promise.all(
+    const toolSettlements = await Promise.allSettled(
       [...byTool.entries()].map(async ([toolId, requests]) => {
         this.log(`Executing tool batch ${toolId}: ${requests.length} calls`);
         const liveStepResults = new Map<string, unknown>();
@@ -8341,6 +8477,11 @@ export class PlayContextImpl {
         }
       }),
     );
+    const rejected = toolSettlements.find(
+      (settlement): settlement is PromiseRejectedResult =>
+        settlement.status === 'rejected',
+    );
+    if (rejected) throw rejected.reason;
   }
 
   private async executeResolvedPlay(
@@ -8741,6 +8882,7 @@ export class PlayContextImpl {
               const httpFailureAttempt = httpFailureAttempts.next({
                 toolId,
                 status: response.status,
+                bodyText: text,
                 transientHttpRetrySafe: retrySafeTransientHttp,
               });
               const failure = classifyToolExecuteHttpFailure({

package/dist/bundling-sources/shared_libs/play-runtime/runner-backends/backends/daytona-lifecycle.ts

@@ -7,17 +7,15 @@ import { isIsolatedRuntimeSchedulerSchema } from '@shared_libs/play-runtime/runt
 
 const DAYTONA_CREATE_TIMEOUT_SECONDS = 10;
 const DAYTONA_CREATE_RETRY_DELAYS_MS = [0, 500, 1_500] as const;
-const DAYTONA_AUTO_STOP_INTERVAL_MINUTES = 5;
+// A detached runner is bounded by both the play runtime ceiling and Daytona's
+// own inactivity stop. No background activity refresh keeps a wedged sandbox
+// alive past those limits.
+const DAYTONA_AUTO_STOP_INTERVAL_MINUTES = 30;
 const DAYTONA_AUTO_ARCHIVE_INTERVAL_MINUTES = 15;
 const DAYTONA_SANDBOX_LABEL_SOURCE = 'deepline-play-runner';
-// The hosted Daytona API pins sandbox resources to the creating snapshot: it
-// rejects create-time resource overrides for snapshot sandboxes (400 "Cannot
-// specify Sandbox resources when using a snapshot") and does not serve
-// POST /sandbox/:id/resize (404 "Cannot POST"). The resource boundary is
-// therefore the default snapshot's grant, verified against these pins after
-// create. If Daytona changes the default snapshot's resources, sandbox
-// acquisition fails loudly instead of silently running plays on a different
-// compute boundary; bump these pins deliberately when that happens.
+// The sandbox must be created at its final resource boundary. Do not add a
+// resize call here: sandbox acquisition is launch-critical, and every extra
+// control-plane round trip raises cold-start latency.
 export const DAYTONA_SANDBOX_CPU = 1;
 export const DAYTONA_SANDBOX_MEMORY_GIB = 1;
 export const DAYTONA_SANDBOX_DISK_GIB = 3;

package/dist/bundling-sources/shared_libs/play-runtime/runner-backends/backends/daytona.ts

@@ -132,10 +132,7 @@ function redactDaytonaErrorDetail(value: string): string {
       '$1[redacted]',
     )
     .replace(/(bearer\s+)[^\s,;]+/gi, '$1[redacted]')
-    .replace(
-      /((?:api[_-]?key|token)\s*[=:]\s*)[^\s,;]+/gi,
-      '$1[redacted]',
-    )
+    .replace(/((?:api[_-]?key|token)\s*[=:]\s*)[^\s,;]+/gi, '$1[redacted]')
     .replace(/\s+/g, ' ')
     .trim()
     .slice(0, 1_000);

package/dist/bundling-sources/shared_libs/play-runtime/runtime-constants.ts

@@ -1,12 +1,12 @@
 /** Maximum active user-code runtime for a standard play, in seconds. */
-export const STANDARD_PLAY_RUNTIME_LIMIT_SECONDS = 20 * 60;
-export const STANDARD_PLAY_RUNTIME_LIMIT_LABEL = '20 minutes';
+export const STANDARD_PLAY_RUNTIME_LIMIT_SECONDS = 30 * 60;
+export const STANDARD_PLAY_RUNTIME_LIMIT_LABEL = '30 minutes';
 
 /**
  * Runner timeout includes setup, cleanup, and billing headroom after the
  * user-code runtime cap.
  */
-export const PLAY_RUNNER_TIMEOUT_SECONDS = 30 * 60;
+export const PLAY_RUNNER_TIMEOUT_SECONDS = 40 * 60;
 
 /** TTL for workflow executor tokens, in seconds. */
 export const WORKFLOW_EXECUTOR_TOKEN_TTL_SECONDS = PLAY_RUNNER_TIMEOUT_SECONDS;

package/dist/bundling-sources/shared_libs/play-runtime/scheduler-backend.ts

@@ -173,6 +173,7 @@ export type PlaySchedulerSubmitInput = {
    * case the worker falls back to the dev-collapse id (today's queue).
    */
   absurdReleaseId?: string | null;
+  absurdReleaseEnvironment?: 'preview' | 'production';
   /** Request-scoped Vercel Deployment Protection bypass for preview runtime callbacks. */
   vercelProtectionBypassToken?: string | null;
   /** Request-scoped, dev-only runtime fault injection header for black-box durability tests. */

package/dist/bundling-sources/shared_libs/play-runtime/tool-execute-retry-policy.ts

@@ -5,6 +5,14 @@ import {
 } from './tool-http-errors';
 
 export const TOOL_EXECUTE_TRANSIENT_HTTP_MAX_ATTEMPTS = 2;
+// A provider may need to finish the original request before it can replay the
+// result for this key. With no Retry-After signal, these two polls give the
+// original request ten seconds to finish without repeatedly hammering it.
+export const TOOL_EXECUTE_IDEMPOTENCY_IN_PROGRESS_RETRY_DELAYS_MS = [
+  5_000, 5_000,
+] as const;
+export const TOOL_EXECUTE_IDEMPOTENCY_IN_PROGRESS_MAX_ATTEMPTS =
+  TOOL_EXECUTE_IDEMPOTENCY_IN_PROGRESS_RETRY_DELAYS_MS.length + 1;
 export const TOOL_EXECUTE_RATE_LIMIT_MAX_ATTEMPTS = 8;
 export const TOOL_EXECUTE_BARE_RATE_LIMIT_MAX_ATTEMPTS = 2;
 export const TOOL_EXECUTE_TRANSPORT_MAX_ATTEMPTS = 3;
@@ -13,6 +21,13 @@ export const TOOL_EXECUTE_RETRY_DELAY_FALLBACK_MS = 1_000;
 export const TOOL_EXECUTE_RETRY_DELAY_MAX_MS = 5_000;
 export const TOOL_EXECUTE_BARE_RATE_LIMIT_BACKPRESSURE_MS = 60_000;
 export const TOOL_EXECUTE_AUTH_SCOPE_CHANGED_CODE = 'AUTH_SCOPE_CHANGED';
+/**
+ * A provider/action-local outcome contract emits this only when a provider has
+ * explicitly said that the same idempotency key is still executing. It is not
+ * a generic HTTP 409 policy.
+ */
+export const TOOL_EXECUTE_IDEMPOTENCY_IN_PROGRESS_CODE =
+  'UPSTREAM_IDEMPOTENCY_IN_PROGRESS';
 
 export class ToolExecuteAuthScopeChangedError extends Error {
   readonly code = TOOL_EXECUTE_AUTH_SCOPE_CHANGED_CODE;
@@ -29,6 +44,7 @@ export type ToolExecuteHttpRetryDecision = {
   attemptCap: number;
   reason:
     | 'rate_limit'
+    | 'idempotency_in_progress'
     | 'retry_safe_transient_5xx'
     | 'unsafe_transient_5xx'
     | 'hard_billing_error'
@@ -49,6 +65,7 @@ export type ToolExecuteHttpFailureAttemptTracker = {
   next(input: {
     toolId: string;
     status: number;
+    bodyText?: string;
     transientHttpRetrySafe?: boolean;
   }): number;
 };
@@ -65,6 +82,29 @@ function parseJsonObject(text: string): Record<string, unknown> | null {
   }
 }
 
+function isIdempotencyInProgressResponse(input: {
+  status: number;
+  bodyText: string;
+}): boolean {
+  if (input.status !== 409) return false;
+  const body = parseJsonObject(input.bodyText);
+  return (
+    body?.code === TOOL_EXECUTE_IDEMPOTENCY_IN_PROGRESS_CODE &&
+    body.error_category === 'idempotency_in_progress'
+  );
+}
+
+function idempotencyInProgressRetryDelayMs(attempt: number): number {
+  return (
+    TOOL_EXECUTE_IDEMPOTENCY_IN_PROGRESS_RETRY_DELAYS_MS[
+      Math.min(
+        Math.max(0, attempt - 1),
+        TOOL_EXECUTE_IDEMPOTENCY_IN_PROGRESS_RETRY_DELAYS_MS.length - 1,
+      )
+    ] ?? TOOL_EXECUTE_RETRY_DELAY_FALLBACK_MS
+  );
+}
+
 export function parseToolExecuteAuthScopeChangedError(input: {
   status: number;
   bodyText: string;
@@ -84,6 +124,7 @@ export function parseToolExecuteAuthScopeChangedError(input: {
 
 function decideToolExecuteHttpRetry(input: {
   status: number;
+  idempotencyInProgress?: boolean;
   hardBillingFailure?: boolean;
   hasRetryAfterHeader?: boolean;
   transientHttpRetrySafe?: boolean;
@@ -110,6 +151,13 @@ function decideToolExecuteHttpRetry(input: {
       reason: 'rate_limit',
     };
   }
+  if (input.idempotencyInProgress) {
+    return {
+      retryable: true,
+      attemptCap: TOOL_EXECUTE_IDEMPOTENCY_IN_PROGRESS_MAX_ATTEMPTS,
+      reason: 'idempotency_in_progress',
+    };
+  }
   if (input.status >= 500 && input.status < 600) {
     if (!input.transientHttpRetrySafe) {
       return {
@@ -137,6 +185,7 @@ export function createToolExecuteHttpFailureAttemptTracker(): ToolExecuteHttpFai
     number
   > = {
     rate_limit: 0,
+    idempotency_in_progress: 0,
     retry_safe_transient_5xx: 0,
     unsafe_transient_5xx: 0,
     hard_billing_error: 0,
@@ -147,6 +196,10 @@ export function createToolExecuteHttpFailureAttemptTracker(): ToolExecuteHttpFai
     next(input) {
       const decision = decideToolExecuteHttpRetry({
         status: input.status,
+        idempotencyInProgress: isIdempotencyInProgressResponse({
+          status: input.status,
+          bodyText: input.bodyText ?? '',
+        }),
         hasRetryAfterHeader: true,
         transientHttpRetrySafe: input.transientHttpRetrySafe === true,
       });
@@ -186,8 +239,10 @@ export function classifyToolExecuteHttpFailure(input: {
   const hasRetryAfterHeader =
     typeof input.retryAfterHeader === 'string' &&
     input.retryAfterHeader.trim().length > 0;
+  const idempotencyInProgress = isIdempotencyInProgressResponse(input);
   const initialRetryDecision = decideToolExecuteHttpRetry({
     status: input.status,
+    idempotencyInProgress,
     hasRetryAfterHeader,
     transientHttpRetrySafe,
   });
@@ -208,6 +263,7 @@ export function classifyToolExecuteHttpFailure(input: {
   const hardBillingFailure = isHardBillingToolHttpError(error);
   const retryDecision = decideToolExecuteHttpRetry({
     status: input.status,
+    idempotencyInProgress,
     hardBillingFailure,
     hasRetryAfterHeader,
     transientHttpRetrySafe,
@@ -238,9 +294,12 @@ export function classifyToolExecuteHttpFailure(input: {
             TOOL_EXECUTE_RETRY_DELAY_FALLBACK_MS * input.attempt,
           ),
         )
-      : retryAfterMs > 0
-        ? Math.min(TOOL_EXECUTE_RETRY_DELAY_MAX_MS, retryAfterMs)
-        : TOOL_EXECUTE_RETRY_DELAY_FALLBACK_MS;
+      : retryDecision.reason === 'idempotency_in_progress' &&
+          !hasRetryAfterHeader
+        ? idempotencyInProgressRetryDelayMs(input.attempt)
+        : retryAfterMs > 0
+          ? Math.min(TOOL_EXECUTE_RETRY_DELAY_MAX_MS, retryAfterMs)
+          : TOOL_EXECUTE_RETRY_DELAY_FALLBACK_MS;
   return {
     ...retryDecision,
     error,