fix(copilot): resolve same-id subblock variants before validating

A block may declare one field id several times, each variant conditioned
on another field — the embeddings block declares model, dimensions, and
taskType once per provider, and the image and video generators do the
same. Validation keyed a map by id alone, so whichever variant was
declared last silently became the validator for every write to that
field.

Programmatic edits to an embeddings block were therefore checked against
Mistral's option lists whatever the saved provider: `text-embedding-3-small`
was rejected as not one of mistral-embed/codestral-embed, and dimensions
valid only elsewhere (3072, 768) could not be set at all. Values that
happened to overlap the last variant passed, so automation saw partial
success rather than a clean failure.

Keep every candidate per id and pick the one whose condition holds,
evaluating against the mutation's inputs merged over the block's saved
values so a partial write still resolves. When no condition matches, fall
back to the union of all variants' options rather than guessing.

Conditions still never gate whether a field may be written — that was a
deliberate choice and a hidden field stays writable. They only select
which definition describes the field, and an unresolved condition widens
the accepted set instead of narrowing it.

Author: mzxchandra

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

@@ -1,5 +1,6 @@
 import { createLogger } from '@sim/logger'
 import { isValidKey } from '@/lib/workflows/sanitization/key-validation'
+import { buildSubBlockValues } from '@/lib/workflows/subblocks/visibility'
 import { TriggerUtils } from '@/lib/workflows/triggers/triggers'
 import { getBlock } from '@/blocks/registry'
 import { normalizeName, RESERVED_BLOCK_NAMES } from '@/executor/constants'
@@ -201,7 +202,8 @@ function mergeNestedNodesForParent(
         const childValidation = validateInputsForBlock(
           existingBlock.type,
           childBlock.inputs,
-          existingId
+          existingId,
+          buildSubBlockValues(existingBlock.subBlocks)
         )
         validationErrors.push(...childValidation.errors)
 
@@ -426,7 +428,12 @@ export function handleEditOperation(op: EditWorkflowOperation, ctx: OperationCon
     if (!block.subBlocks) block.subBlocks = {}
 
     // Validate inputs against block configuration
-    const validationResult = validateInputsForBlock(block.type, params.inputs, block_id)
+    const validationResult = validateInputsForBlock(
+      block.type,
+      params.inputs,
+      block_id,
+      buildSubBlockValues(block.subBlocks ?? {})
+    )
     validationErrors.push(...validationResult.errors)
 
     Object.entries(validationResult.validInputs).forEach(([inputKey, value]) => {
@@ -898,7 +905,12 @@ export function handleInsertIntoSubflowOperation(
     // Update inputs if provided (with validation)
     if (params.inputs) {
       // Validate inputs against block configuration
-      const validationResult = validateInputsForBlock(existingBlock.type, params.inputs, block_id)
+      const validationResult = validateInputsForBlock(
+        existingBlock.type,
+        params.inputs,
+        block_id,
+        buildSubBlockValues(existingBlock.subBlocks ?? {})
+      )
       validationErrors.push(...validationResult.errors)
 
       Object.entries(validationResult.validInputs).forEach(([key, value]) => {

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

@@ -202,7 +202,67 @@ const toolsByIdMock: Record<string, unknown> = {
   },
 }
 
+/**
+ * Declares one field id several times, each variant conditioned on another
+ * field — the shape used by the embeddings, image-generator, and
+ * video-generator blocks. `size` deliberately overlaps on 50 so a test can
+ * distinguish "resolved the right variant" from "happened to overlap".
+ */
+const multiVariantBlockConfig = {
+  type: 'multi_variant_block',
+  name: 'Multi Variant Block',
+  outputs: {},
+  subBlocks: [
+    {
+      id: 'provider',
+      type: 'dropdown',
+      options: [
+        { label: 'Alpha', id: 'alpha' },
+        { label: 'Beta', id: 'beta' },
+      ],
+    },
+    {
+      id: 'model',
+      type: 'dropdown',
+      options: [
+        { label: 'a1', id: 'a1' },
+        { label: 'a2', id: 'a2' },
+      ],
+      condition: { field: 'provider', value: 'alpha' },
+    },
+    {
+      id: 'model',
+      type: 'dropdown',
+      options: [
+        { label: 'b1', id: 'b1' },
+        { label: 'b2', id: 'b2' },
+      ],
+      condition: { field: 'provider', value: 'beta' },
+    },
+    {
+      id: 'size',
+      type: 'dropdown',
+      options: [
+        { label: '100', id: '100' },
+        { label: '50', id: '50' },
+      ],
+      condition: { field: 'provider', value: 'alpha', and: { field: 'model', value: 'a1' } },
+    },
+    {
+      id: 'size',
+      type: 'dropdown',
+      options: [
+        { label: '50', id: '50' },
+        { label: '25', id: '25' },
+      ],
+      condition: { field: 'provider', value: 'beta' },
+    },
+  ],
+  tools: { access: ['multi_variant_tool'], config: { tool: () => 'multi_variant_tool' } },
+}
+
 const blockConfigsByType: Record<string, unknown> = {
+  multi_variant_block: multiVariantBlockConfig,
   condition: conditionBlockConfig,
   slack: oauthBlockConfig,
   router_v2: routerBlockConfig,
@@ -279,6 +339,79 @@ describe('validateInputsForBlock', () => {
     mockValidateSelectorIds.mockResolvedValue({ valid: [], invalid: [] })
   })
 
+  /**
+   * A block may declare one field id several times, each variant conditioned on
+   * another field. Keying a map by id alone kept whichever variant was declared
+   * last, so a value valid for the selected provider was checked against an
+   * unrelated provider's options and rejected.
+   */
+  describe('same-id conditional field variants', () => {
+    it('validates against the variant selected in the same mutation', () => {
+      // 'a1' belongs to the first variant; the last-declared one offers b1/b2.
+      const result = validateInputsForBlock(
+        'multi_variant_block',
+        { provider: 'alpha', model: 'a1' },
+        'mv-1'
+      )
+
+      expect(result.errors).toHaveLength(0)
+      expect(result.validInputs.model).toBe('a1')
+    })
+
+    it('accepts a value absent from the last-declared variant', () => {
+      // 100 exists only on the alpha `size` variant.
+      const result = validateInputsForBlock(
+        'multi_variant_block',
+        { provider: 'alpha', model: 'a1', size: '100' },
+        'mv-2'
+      )
+
+      expect(result.errors).toHaveLength(0)
+      expect(result.validInputs.size).toBe('100')
+    })
+
+    it('resolves against saved values when the mutation is partial', () => {
+      const result = validateInputsForBlock('multi_variant_block', { size: '100' }, 'mv-3', {
+        provider: 'alpha',
+        model: 'a1',
+      })
+
+      expect(result.errors).toHaveLength(0)
+      expect(result.validInputs.size).toBe('100')
+    })
+
+    it('rejects a value belonging to a different variant', () => {
+      // 25 is beta-only, so it must not pass while alpha is selected.
+      const result = validateInputsForBlock(
+        'multi_variant_block',
+        { provider: 'alpha', model: 'a1', size: '25' },
+        'mv-4'
+      )
+
+      expect(result.errors).toHaveLength(1)
+      expect(result.errors[0].field).toBe('size')
+    })
+
+    it('rejects a value no variant offers', () => {
+      const result = validateInputsForBlock(
+        'multi_variant_block',
+        { provider: 'alpha', model: 'nope' },
+        'mv-5'
+      )
+
+      expect(result.errors).toHaveLength(1)
+      expect(result.errors[0].field).toBe('model')
+    })
+
+    it('falls back to the union when no variant condition matches', () => {
+      // Without a provider nothing resolves, so widen rather than guess.
+      const result = validateInputsForBlock('multi_variant_block', { model: 'b1' }, 'mv-6')
+
+      expect(result.errors).toHaveLength(0)
+      expect(result.validInputs.model).toBe('b1')
+    })
+  })
+
   it('accepts condition-input arrays with arbitrary item ids', () => {
     const result = validateInputsForBlock(
       'condition',

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

@@ -11,6 +11,7 @@ import { getSkillById } from '@/lib/workflows/skills/operations'
 import {
   buildCanonicalIndex,
   buildSubBlockValues,
+  evaluateSubBlockCondition,
   isCanonicalPair,
   resolveCanonicalMode,
 } from '@/lib/workflows/subblocks/visibility'
@@ -57,7 +58,13 @@ export function findBlockWithDuplicateNormalizedName(
 export function validateInputsForBlock(
   blockType: string,
   inputs: Record<string, any>,
-  blockId: string
+  blockId: string,
+  /**
+   * The block's already-saved subblock values, when editing an existing block.
+   * Lets a partial mutation resolve conditional field variants against state it
+   * is not itself rewriting.
+   */
+  existingValues?: Record<string, unknown>
 ): ValidationResult {
   const errors: ValidationError[] = []
 
@@ -84,20 +91,32 @@ export function validateInputsForBlock(
   }
 
   const validatedInputs: Record<string, any> = {}
-  const subBlockMap = new Map<string, SubBlockConfig>()
 
-  // Build map of subBlock id -> config
+  /**
+   * A field id can be declared more than once, each variant conditioned on
+   * another field, so every candidate is kept and the active one is resolved
+   * per field below.
+   */
+  const subBlockCandidates = new Map<string, SubBlockConfig[]>()
   for (const subBlock of blockConfig.subBlocks) {
-    subBlockMap.set(subBlock.id, subBlock)
+    const existing = subBlockCandidates.get(subBlock.id)
+    if (existing) existing.push(subBlock)
+    else subBlockCandidates.set(subBlock.id, [subBlock])
   }
 
+  /** Incoming values win over saved ones so a single mutation resolves itself. */
+  const effectiveValues: Record<string, unknown> = { ...existingValues, ...inputs }
+
   for (const [key, value] of Object.entries(inputs)) {
     // Skip runtime subblock IDs
     if (TRIGGER_RUNTIME_SUBBLOCK_IDS.includes(key)) {
       continue
     }
 
-    const subBlockConfig = subBlockMap.get(key)
+    const candidates = subBlockCandidates.get(key)
+    const subBlockConfig = candidates
+      ? (resolveActiveSubBlock(candidates, effectiveValues) ?? unionSubBlock(candidates))
+      : undefined
 
     // If subBlock doesn't exist in config, skip it (unless it's a known dynamic field)
     if (!subBlockConfig) {
@@ -141,10 +160,10 @@ export function validateInputsForBlock(
       continue
     }
 
-    // Note: We do NOT check subBlockConfig.condition here.
-    // Conditions are for UI display logic (show/hide fields in the editor).
-    // For API/Copilot, any valid field in the block schema should be accepted.
-    // The runtime will use the relevant fields based on the actual operation.
+    // A field is never rejected for being conditionally hidden — conditions are
+    // UI display logic, and any field in the block schema stays writable. They
+    // are consulted only to pick which same-id variant defines this field, and
+    // an unresolved condition widens the accepted set rather than narrowing it.
 
     // Validate value based on subBlock type
     const validationResult = validateValueForSubBlockType(
@@ -275,6 +294,63 @@ function validateAgentSkillEntry(item: any, index: number): string | null {
   return null
 }
 
+/** Reads a subblock's options list, which may be declared as a thunk. */
+function readOptions(subBlockConfig: SubBlockConfig) {
+  return typeof subBlockConfig.options === 'function'
+    ? subBlockConfig.options()
+    : subBlockConfig.options
+}
+
+/**
+ * Picks which of several same-id subblock definitions applies.
+ *
+ * A block may declare one field id several times, each variant conditioned on
+ * another field — the embeddings block declares `model`, `dimensions`, and
+ * `taskType` once per provider, and the image/video generators do the same.
+ * Keying a map by id alone silently keeps whichever variant happens to be
+ * declared last, so a value valid for the selected provider is checked against
+ * an unrelated provider's option list.
+ *
+ * Conditions are evaluated against the mutation's inputs merged over the
+ * block's saved values, so a write that sets only `model` still resolves
+ * against an already-persisted `provider`.
+ *
+ * Returns null when no variant's condition matches, which leaves the caller to
+ * fall back to accepting anything valid for any variant rather than guessing.
+ */
+function resolveActiveSubBlock(
+  candidates: SubBlockConfig[],
+  effectiveValues: Record<string, unknown>
+): SubBlockConfig | null {
+  if (candidates.length === 1) return candidates[0]
+  const active = candidates.filter((candidate) =>
+    evaluateSubBlockCondition(candidate.condition, effectiveValues)
+  )
+  return active.length > 0 ? active[0] : null
+}
+
+/**
+ * Collapses same-id variants into one definition whose options are the union of
+ * every variant's. Used only when the active variant cannot be resolved, so an
+ * unresolvable write is never rejected for a value that is legal somewhere.
+ */
+function unionSubBlock(candidates: SubBlockConfig[]): SubBlockConfig {
+  const seen = new Set<string>()
+  const merged: Array<{ id: string; label?: string }> = []
+  for (const candidate of candidates) {
+    const options = readOptions(candidate)
+    if (!Array.isArray(options)) continue
+    for (const option of options) {
+      if (seen.has(option.id)) continue
+      seen.add(option.id)
+      merged.push(option)
+    }
+  }
+  return merged.length > 0
+    ? ({ ...candidates[0], options: merged } as SubBlockConfig)
+    : candidates[0]
+}
+
 /**
  * Validates a value against its expected subBlock type
  * Returns validation result with the value or an error
@@ -296,10 +372,7 @@ export function validateValueForSubBlockType(
   switch (type) {
     case 'dropdown': {
       // Validate against allowed options
-      const options =
-        typeof subBlockConfig.options === 'function'
-          ? subBlockConfig.options()
-          : subBlockConfig.options
+      const options = readOptions(subBlockConfig)
       if (options && Array.isArray(options)) {
         const validIds = options.map((opt) => opt.id)
         if (!validIds.includes(value)) {