chore(embeddings): scope this branch to the multi-provider block

Two changes made while building the Embeddings block are not part of it and
ship separately, so their files are restored to staging here:

- copilot edit-workflow validation resolving same-id conditional subblock
  variants. The embeddings block surfaced it, but it is a platform fix
  affecting ~20 blocks that declare a field id more than once, and it
  narrows what programmatic edits accept — that deserves its own review.
- the sync-engine test de-flake, which is unrelated test hygiene.

Both are preserved in full on feat/embeddings-full-snapshot.

Note this restores the reported bug where a programmatic edit to an
embeddings block validates model/dimensions against the last-declared
provider variant. The block is unaffected in the editor and at runtime.

Author: mzxchandra

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

@@ -1,6 +1,5 @@
 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'
@@ -202,8 +201,7 @@ function mergeNestedNodesForParent(
         const childValidation = validateInputsForBlock(
           existingBlock.type,
           childBlock.inputs,
-          existingId,
-          buildSubBlockValues(existingBlock.subBlocks)
+          existingId
         )
         validationErrors.push(...childValidation.errors)
 
@@ -428,12 +426,7 @@ 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,
-      buildSubBlockValues(block.subBlocks ?? {})
-    )
+    const validationResult = validateInputsForBlock(block.type, params.inputs, block_id)
     validationErrors.push(...validationResult.errors)
 
     Object.entries(validationResult.validInputs).forEach(([inputKey, value]) => {
@@ -905,12 +898,7 @@ 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,
-        buildSubBlockValues(existingBlock.subBlocks ?? {})
-      )
+      const validationResult = validateInputsForBlock(existingBlock.type, params.inputs, block_id)
       validationErrors.push(...validationResult.errors)
 
       Object.entries(validationResult.validInputs).forEach(([key, value]) => {

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

@@ -202,83 +202,7 @@ 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' },
-    },
-    // Catch-all declared first: it matches everything, so it must not shadow
-    // the conditioned variant below purely by declaration order.
-    {
-      id: 'mode',
-      type: 'dropdown',
-      options: [{ label: 'default', id: 'default' }],
-    },
-    {
-      id: 'mode',
-      type: 'dropdown',
-      options: [
-        { label: 'fast', id: 'fast' },
-        { label: 'slow', id: 'slow' },
-      ],
-      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,
@@ -355,91 +279,6 @@ 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('prefers a conditioned variant over an unconditioned catch-all', () => {
-      // `mode` declares the catch-all first; it must not shadow the beta variant.
-      const result = validateInputsForBlock(
-        'multi_variant_block',
-        { provider: 'beta', mode: 'fast' },
-        'mv-7'
-      )
-
-      expect(result.errors).toHaveLength(0)
-      expect(result.validInputs.mode).toBe('fast')
-    })
-
-    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,7 +11,6 @@ import { getSkillById } from '@/lib/workflows/skills/operations'
 import {
   buildCanonicalIndex,
   buildSubBlockValues,
-  evaluateSubBlockCondition,
   isCanonicalPair,
   resolveCanonicalMode,
 } from '@/lib/workflows/subblocks/visibility'
@@ -58,13 +57,7 @@ export function findBlockWithDuplicateNormalizedName(
 export function validateInputsForBlock(
   blockType: string,
   inputs: Record<string, any>,
-  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>
+  blockId: string
 ): ValidationResult {
   const errors: ValidationError[] = []
 
@@ -91,32 +84,20 @@ export function validateInputsForBlock(
   }
 
   const validatedInputs: Record<string, any> = {}
+  const subBlockMap = new Map<string, SubBlockConfig>()
 
-  /**
-   * 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[]>()
+  // Build map of subBlock id -> config
   for (const subBlock of blockConfig.subBlocks) {
-    const existing = subBlockCandidates.get(subBlock.id)
-    if (existing) existing.push(subBlock)
-    else subBlockCandidates.set(subBlock.id, [subBlock])
+    subBlockMap.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 candidates = subBlockCandidates.get(key)
-    const subBlockConfig = candidates
-      ? (resolveActiveSubBlock(candidates, effectiveValues) ?? unionSubBlock(candidates))
-      : undefined
+    const subBlockConfig = subBlockMap.get(key)
 
     // If subBlock doesn't exist in config, skip it (unless it's a known dynamic field)
     if (!subBlockConfig) {
@@ -160,10 +141,10 @@ export function validateInputsForBlock(
       continue
     }
 
-    // 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.
+    // 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.
 
     // Validate value based on subBlock type
     const validationResult = validateValueForSubBlockType(
@@ -294,69 +275,6 @@ 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)
-  )
-  if (active.length === 0) return null
-  /**
-   * An unconditioned variant matches everything, so it would shadow a genuinely
-   * selected one purely by being declared earlier. Prefer a variant that
-   * actually asserted something about the current values.
-   */
-  return active.find((candidate) => candidate.condition) ?? active[0]
-}
-
-/**
- * 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
@@ -378,7 +296,10 @@ export function validateValueForSubBlockType(
   switch (type) {
     case 'dropdown': {
       // Validate against allowed options
-      const options = readOptions(subBlockConfig)
+      const options =
+        typeof subBlockConfig.options === 'function'
+          ? subBlockConfig.options()
+          : subBlockConfig.options
       if (options && Array.isArray(options)) {
         const validIds = options.map((opt) => opt.id)
         if (!validIds.includes(value)) {