Let edit_workflow configure block retries

Author: Sg312

apps/sim/lib/copilot/generated/tool-catalog-v1.ts

@@ -2259,7 +2259,7 @@ export const EditWorkflow: ToolCatalogEntry = {
             params: {
               type: 'object',
               description:
-                'Parameters for the operation (optional).\nFor edit: {"inputs": {"temperature": 0.5}} NOT {"subBlocks": {"temperature": {"value": 0.5}}}\nFor add: {"type": "agent", "name": "My Agent", "inputs": {"model": "<model-id from agent.json>"}}\nFor delete: omit params entirely (none needed)',
+                'Parameters for the operation (optional).\nFor edit: {"inputs": {"temperature": 0.5}} NOT {"subBlocks": {"temperature": {"value": 0.5}}}\nFor add: {"type": "agent", "name": "My Agent", "inputs": {"model": "<model-id from agent.json>"}}\nFor delete: omit params entirely (none needed)\nBlock-level settings (retry, triggerMode, advancedMode) go beside "inputs", never inside it.',
             },
           },
           required: ['operation_type', 'block_id'],

apps/sim/lib/copilot/generated/tool-schemas-v1.ts

@@ -2224,7 +2224,7 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
               params: {
                 type: 'object',
                 description:
-                  'Parameters for the operation (optional).\nFor edit: {"inputs": {"temperature": 0.5}} NOT {"subBlocks": {"temperature": {"value": 0.5}}}\nFor add: {"type": "agent", "name": "My Agent", "inputs": {"model": "<model-id from agent.json>"}}\nFor delete: omit params entirely (none needed)',
+                  'Parameters for the operation (optional).\nFor edit: {"inputs": {"temperature": 0.5}} NOT {"subBlocks": {"temperature": {"value": 0.5}}}\nFor add: {"type": "agent", "name": "My Agent", "inputs": {"model": "<model-id from agent.json>"}}\nFor delete: omit params entirely (none needed)\nBlock-level settings (retry, triggerMode, advancedMode) go beside "inputs", never inside it.',
               },
             },
             required: ['operation_type', 'block_id'],

apps/sim/lib/copilot/tools/server/workflow/edit-workflow/builders.test.ts

@@ -3,11 +3,14 @@
  */
 import { describe, expect, it, vi } from 'vitest'
 import {
+  applyBlockRetry,
   applyTriggerConfigToBlockSubblocks,
   createBlockFromParams,
   filterDisallowedTools,
   normalizeSubblockValue,
+  resolveBlockRetryUpdate,
 } from '@/lib/copilot/tools/server/workflow/edit-workflow/builders'
+import type { SkippedItem } from '@/lib/copilot/tools/server/workflow/edit-workflow/types'
 
 const { mockIsIntegrationDeploymentAvailable } = vi.hoisted(() => ({
   mockIsIntegrationDeploymentAvailable: vi.fn(() => true),
@@ -245,3 +248,79 @@ describe('applyTriggerConfigToBlockSubblocks', () => {
     })
   })
 })
+
+describe('block retry policy', () => {
+  it('defaults the numbers when only enabling', () => {
+    expect(resolveBlockRetryUpdate({ enabled: true }, undefined)).toEqual({
+      enabled: true,
+      maxTries: 3,
+      waitBetweenTriesMs: 1000,
+    })
+  })
+
+  it('treats numbers alone as an intent to retry', () => {
+    expect(resolveBlockRetryUpdate({ maxTries: 4 }, undefined)).toMatchObject({
+      enabled: true,
+      maxTries: 4,
+    })
+  })
+
+  it('keeps configured numbers when retry is switched off', () => {
+    const existing = { enabled: true, maxTries: 5, waitBetweenTriesMs: 250 }
+    expect(resolveBlockRetryUpdate({ enabled: false }, existing)).toEqual({
+      enabled: false,
+      maxTries: 5,
+      waitBetweenTriesMs: 250,
+    })
+  })
+
+  it('clamps out-of-range values instead of rejecting them', () => {
+    expect(resolveBlockRetryUpdate({ enabled: true, maxTries: 99 }, undefined).maxTries).toBe(5)
+    expect(resolveBlockRetryUpdate({ enabled: true, maxTries: 1 }, undefined).maxTries).toBe(2)
+    expect(
+      resolveBlockRetryUpdate({ enabled: true, waitBetweenTriesMs: 999999 }, undefined)
+        .waitBetweenTriesMs
+    ).toBe(5000)
+  })
+
+  it('applies a policy to an eligible block', () => {
+    const block: Record<string, unknown> = { type: 'agent' }
+    applyBlockRetry(
+      block,
+      { enabled: true, maxTries: 4 },
+      {
+        operationType: 'edit',
+        blockId: 'b1',
+      }
+    )
+    expect(block.retry).toMatchObject({ enabled: true, maxTries: 4 })
+  })
+
+  it('reports why an ineligible block cannot retry instead of storing dead config', () => {
+    const skippedItems: SkippedItem[] = []
+    const block: Record<string, unknown> = { type: 'agent', triggerMode: true }
+
+    applyBlockRetry(
+      block,
+      { enabled: true },
+      {
+        operationType: 'edit',
+        blockId: 'b1',
+        skippedItems,
+      }
+    )
+
+    expect(block.retry).toBeUndefined()
+    expect(skippedItems).toHaveLength(1)
+    expect(skippedItems[0]).toMatchObject({ type: 'retry_not_supported', blockId: 'b1' })
+  })
+
+  it('clears the policy when null is sent', () => {
+    const block: Record<string, unknown> = {
+      type: 'agent',
+      retry: { enabled: true, maxTries: 3, waitBetweenTriesMs: 1000 },
+    }
+    applyBlockRetry(block, null, { operationType: 'edit', blockId: 'b1' })
+    expect(block.retry).toBeUndefined()
+  })
+})

apps/sim/lib/copilot/tools/server/workflow/edit-workflow/builders.ts

@@ -1,9 +1,15 @@
 import { createLogger } from '@sim/logger'
 import { generateId, isValidUuid } from '@sim/utils/id'
 import { sortObjectKeysDeep } from '@sim/utils/object'
+import {
+  type BlockRetryConfig,
+  normalizeBlockRetryTries,
+  normalizeBlockRetryWaitMs,
+} from '@sim/workflow-types/workflow'
 import { isIntegrationDeploymentAvailableForVisibility } from '@/lib/integrations/availability.server'
 import type { PermissionGroupConfig } from '@/lib/permission-groups/types'
 import { getEffectiveBlockOutputs } from '@/lib/workflows/blocks/block-outputs'
+import { isRetryEligibleBlock } from '@/lib/workflows/blocks/retry-eligibility'
 import {
   buildCanonicalIndex,
   buildDefaultCanonicalModes,
@@ -22,6 +28,73 @@ import {
   validateTargetHandle,
 } from './validation'
 
+/**
+ * Merges a requested retry policy onto whatever the block already had, clamped
+ * to the executor's bounds.
+ *
+ * `enabled` is optional and falls back to the block's current state (or `true`
+ * for a block with no policy yet), so `{maxTries: 4}` reads as "retry four
+ * times" rather than silently storing a disabled policy. Numbers are kept when
+ * only `enabled` changes, matching the editor: toggling retry off and back on
+ * restores what was configured instead of resetting to the defaults.
+ *
+ * Clamped through the shared normalizers rather than rejected, so a value that
+ * drifts outside the bounds still yields a runnable policy — same contract the
+ * editor and executor already follow.
+ */
+export function resolveBlockRetryUpdate(
+  requested: Partial<BlockRetryConfig>,
+  existing: BlockRetryConfig | undefined
+): BlockRetryConfig {
+  return {
+    enabled:
+      typeof requested.enabled === 'boolean' ? requested.enabled : (existing?.enabled ?? true),
+    maxTries: normalizeBlockRetryTries(requested.maxTries ?? existing?.maxTries),
+    waitBetweenTriesMs: normalizeBlockRetryWaitMs(
+      requested.waitBetweenTriesMs ?? existing?.waitBetweenTriesMs
+    ),
+  }
+}
+
+/**
+ * Applies a requested retry policy to a block, or records why it could not be.
+ *
+ * Eligibility is checked with the same predicate the executor uses, so a policy
+ * the runtime would ignore (triggers, human-in-the-loop, sentinels) is reported
+ * back instead of being written as dead configuration.
+ */
+export function applyBlockRetry(
+  block: any,
+  requested: unknown,
+  context: { operationType: string; blockId: string; skippedItems?: SkippedItem[] }
+): void {
+  if (requested === null) {
+    block.retry = undefined
+    return
+  }
+  if (typeof requested !== 'object' || Array.isArray(requested)) return
+
+  if (
+    !isRetryEligibleBlock({
+      blockType: block.type,
+      category: getBlock(block.type)?.category,
+      triggerMode: block.triggerMode,
+    })
+  ) {
+    if (context.skippedItems) {
+      logSkippedItem(context.skippedItems, {
+        type: 'retry_not_supported',
+        operationType: context.operationType,
+        blockId: context.blockId,
+        reason: `Block "${context.blockId}" (${block.type}) cannot retry - triggers, human-in-the-loop, and container blocks always run once`,
+      })
+    }
+    return
+  }
+
+  block.retry = resolveBlockRetryUpdate(requested as Partial<BlockRetryConfig>, block.retry)
+}
+
 /**
  * Helper to create a block state from operation params
  */
@@ -88,6 +161,16 @@ export function createBlockFromParams(
     locked: false,
   }
 
+  // Block-level setting like `enabled`, not a subBlock input — the executor
+  // reads it from block state when wrapping the run, never from the tool params.
+  if (params.retry !== undefined) {
+    applyBlockRetry(blockState, params.retry, {
+      operationType: 'add',
+      blockId,
+      skippedItems,
+    })
+  }
+
   // Add validated inputs as subBlocks
   if (validatedInputs) {
     Object.entries(validatedInputs).forEach(([key, value]) => {

apps/sim/lib/copilot/tools/server/workflow/edit-workflow/operations.ts

@@ -5,6 +5,7 @@ import { getBlock } from '@/blocks/registry'
 import { normalizeName, RESERVED_BLOCK_NAMES } from '@/executor/constants'
 import { TRIGGER_RUNTIME_SUBBLOCK_IDS } from '@/triggers/constants'
 import {
+  applyBlockRetry,
   applyTriggerConfigToBlockSubblocks,
   createBlockFromParams,
   filterDisallowedTools,
@@ -631,6 +632,17 @@ export function handleEditOperation(op: EditWorkflowOperation, ctx: OperationCon
     block.advancedMode = params.advancedMode
   }
 
+  // Handle retry policy. Runs after the trigger-mode branch above so eligibility
+  // sees the block's post-update mode: turning a block into a trigger in the
+  // same operation makes it ineligible, exactly as the editor treats it.
+  if (params?.retry !== undefined) {
+    applyBlockRetry(block, params.retry, {
+      operationType: 'edit',
+      blockId: block_id,
+      skippedItems,
+    })
+  }
+
   // Handle nested nodes update (for loops/parallels) using merge strategy.
   // Existing children that match an incoming node by name are updated in place
   // (preserving their block ID). New children are created. Children not present

apps/sim/lib/copilot/tools/server/workflow/edit-workflow/types.ts

@@ -48,6 +48,7 @@ export type SkippedItemType =
   | 'nested_subflow_not_allowed'
   | 'duplicate_block_name'
   | 'reserved_block_name'
+  | 'retry_not_supported'
   | 'duplicate_trigger'
   | 'duplicate_single_instance_block'
 

apps/sim/lib/copilot/vfs/serializers.ts

@@ -14,6 +14,7 @@ import {
 import { type FilterFieldType, getOperatorsForFieldType } from '@/lib/knowledge/filters/types'
 import { SLACK_CUSTOM_BOT_PROVIDER_ID } from '@/lib/oauth/types'
 import { getServiceAccountProviderForProviderId } from '@/lib/oauth/utils'
+import { isRetryEligibleBlock } from '@/lib/workflows/blocks/retry-eligibility'
 import { isSubBlockHidden } from '@/lib/workflows/subblocks/visibility'
 import { getBlock } from '@/blocks'
 import { isCustomBlockType } from '@/blocks/custom/build-config'
@@ -692,6 +693,15 @@ export function serializeBlockSchema(
       longDescription: block.longDescription || undefined,
       bestPractices: block.bestPractices || undefined,
       triggerAllowed: block.triggerAllowed || undefined,
+      // Retry is block STATE (like `enabled`), not a subBlock input — set it via
+      // edit_workflow's `retry` param, never through `inputs`. Emitted only when
+      // eligible so the agent never proposes a policy the executor would ignore.
+      retryAllowed:
+        isRetryEligibleBlock({
+          blockType: block.type,
+          category: block.category,
+          triggerMode: undefined,
+        }) || undefined,
       singleInstance: block.singleInstance || undefined,
       authMode: block.authMode || undefined,
       // Custom (deploy-as-block) blocks execute via a baked `workflow_executor`