Merge remote-tracking branch 'origin/staging' into feat/canonical-subblock

# Conflicts:
#	apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/sub-block.tsx

apps/docs/content/docs/en/execution/meta.json

@@ -1,3 +1,3 @@
 {
-  "pages": ["index", "basics", "api", "form", "logging", "costs"]
+  "pages": ["index", "basics", "api", "logging", "costs"]
 }

apps/sim/app/api/copilot/execute-tool/route.ts

@@ -14,8 +14,7 @@ import {
 import { generateRequestId } from '@/lib/core/utils/request'
 import { getEffectiveDecryptedEnv } from '@/lib/environment/utils'
 import { refreshTokenIfNeeded } from '@/app/api/auth/oauth/utils'
-import { REFERENCE } from '@/executor/constants'
-import { createEnvVarPattern } from '@/executor/utils/reference-validation'
+import { resolveEnvVarReferences } from '@/executor/utils/reference-validation'
 import { executeTool } from '@/tools'
 import { getTool, resolveToolId } from '@/tools/utils'
 
@@ -28,45 +27,6 @@ const ExecuteToolSchema = z.object({
   workflowId: z.string().optional(),
 })
 
-/**
- * Resolves all {{ENV_VAR}} references in a value recursively
- * Works with strings, arrays, and objects
- */
-function resolveEnvVarReferences(value: any, envVars: Record<string, string>): any {
-  if (typeof value === 'string') {
-    // Check for exact match: entire string is "{{VAR_NAME}}"
-    const exactMatchPattern = new RegExp(
-      `^\\${REFERENCE.ENV_VAR_START}([^}]+)\\${REFERENCE.ENV_VAR_END}$`
-    )
-    const exactMatch = exactMatchPattern.exec(value)
-    if (exactMatch) {
-      const envVarName = exactMatch[1].trim()
-      return envVars[envVarName] ?? value
-    }
-
-    // Check for embedded references: "prefix {{VAR}} suffix"
-    const envVarPattern = createEnvVarPattern()
-    return value.replace(envVarPattern, (match, varName) => {
-      const trimmedName = varName.trim()
-      return envVars[trimmedName] ?? match
-    })
-  }
-
-  if (Array.isArray(value)) {
-    return value.map((item) => resolveEnvVarReferences(item, envVars))
-  }
-
-  if (value !== null && typeof value === 'object') {
-    const resolved: Record<string, any> = {}
-    for (const [key, val] of Object.entries(value)) {
-      resolved[key] = resolveEnvVarReferences(val, envVars)
-    }
-    return resolved
-  }
-
-  return value
-}
-
 export async function POST(req: NextRequest) {
   const tracker = createRequestTracker()
 
@@ -145,7 +105,17 @@ export async function POST(req: NextRequest) {
 
     // Build execution params starting with LLM-provided arguments
     // Resolve all {{ENV_VAR}} references in the arguments
-    const executionParams: Record<string, any> = resolveEnvVarReferences(toolArgs, decryptedEnvVars)
+    const executionParams: Record<string, any> = resolveEnvVarReferences(
+      toolArgs,
+      decryptedEnvVars,
+      {
+        resolveExactMatch: true,
+        allowEmbedded: true,
+        trimKeys: true,
+        onMissing: 'keep',
+        deep: true,
+      }
+    ) as Record<string, any>
 
     logger.info(`[${tracker.requestId}] Resolved env var references in arguments`, {
       toolName,

apps/sim/app/api/function/execute/route.ts

@@ -9,6 +9,7 @@ import { escapeRegExp, normalizeName, REFERENCE } from '@/executor/constants'
 import {
   createEnvVarPattern,
   createWorkflowVariablePattern,
+  resolveEnvVarReferences,
 } from '@/executor/utils/reference-validation'
 export const dynamic = 'force-dynamic'
 export const runtime = 'nodejs'
@@ -479,9 +480,29 @@ function resolveEnvironmentVariables(
   const replacements: Array<{ match: string; index: number; varName: string; varValue: string }> =
     []
 
+  const resolverVars: Record<string, string> = {}
+  Object.entries(params).forEach(([key, value]) => {
+    if (value) {
+      resolverVars[key] = String(value)
+    }
+  })
+  Object.entries(envVars).forEach(([key, value]) => {
+    if (value) {
+      resolverVars[key] = value
+    }
+  })
+
   while ((match = regex.exec(code)) !== null) {
     const varName = match[1].trim()
-    const varValue = envVars[varName] || params[varName] || ''
+    const resolved = resolveEnvVarReferences(match[0], resolverVars, {
+      allowEmbedded: true,
+      resolveExactMatch: true,
+      trimKeys: true,
+      onMissing: 'empty',
+      deep: false,
+    })
+    const varValue =
+      typeof resolved === 'string' ? resolved : resolved == null ? '' : String(resolved)
     replacements.push({
       match: match[0],
       index: match.index,

apps/sim/app/api/mcp/servers/test-connection/route.ts

@@ -5,8 +5,7 @@ import { McpClient } from '@/lib/mcp/client'
 import { getParsedBody, withMcpAuth } from '@/lib/mcp/middleware'
 import type { McpServerConfig, McpTransport } from '@/lib/mcp/types'
 import { createMcpErrorResponse, createMcpSuccessResponse } from '@/lib/mcp/utils'
-import { REFERENCE } from '@/executor/constants'
-import { createEnvVarPattern } from '@/executor/utils/reference-validation'
+import { resolveEnvVarReferences } from '@/executor/utils/reference-validation'
 
 const logger = createLogger('McpServerTestAPI')
 
@@ -24,22 +23,23 @@ function isUrlBasedTransport(transport: McpTransport): boolean {
  * Resolve environment variables in strings
  */
 function resolveEnvVars(value: string, envVars: Record<string, string>): string {
-  const envVarPattern = createEnvVarPattern()
-  const envMatches = value.match(envVarPattern)
-  if (!envMatches) return value
+  const missingVars: string[] = []
+  const resolvedValue = resolveEnvVarReferences(value, envVars, {
+    allowEmbedded: true,
+    resolveExactMatch: true,
+    trimKeys: true,
+    onMissing: 'keep',
+    deep: false,
+    missingKeys: missingVars,
+  }) as string
 
-  let resolvedValue = value
-  for (const match of envMatches) {
-    const envKey = match.slice(REFERENCE.ENV_VAR_START.length, -REFERENCE.ENV_VAR_END.length).trim()
-    const envValue = envVars[envKey]
-
-    if (envValue === undefined) {
+  if (missingVars.length > 0) {
+    const uniqueMissing = Array.from(new Set(missingVars))
+    uniqueMissing.forEach((envKey) => {
       logger.warn(`Environment variable "${envKey}" not found in MCP server test`)
-      continue
-    }
-
-    resolvedValue = resolvedValue.replace(match, envValue)
+    })
   }
+
   return resolvedValue
 }
 

apps/sim/app/api/schedules/execute/route.test.ts

@@ -93,6 +93,11 @@ describe('Scheduled Workflow Execution API Route', () => {
           nextRunAt: 'nextRunAt',
           lastQueuedAt: 'lastQueuedAt',
         },
+        workflow: {
+          id: 'id',
+          userId: 'userId',
+          workspaceId: 'workspaceId',
+        },
       }
     })
 
@@ -170,6 +175,11 @@ describe('Scheduled Workflow Execution API Route', () => {
           nextRunAt: 'nextRunAt',
           lastQueuedAt: 'lastQueuedAt',
         },
+        workflow: {
+          id: 'id',
+          userId: 'userId',
+          workspaceId: 'workspaceId',
+        },
       }
     })
 
@@ -229,6 +239,11 @@ describe('Scheduled Workflow Execution API Route', () => {
           nextRunAt: 'nextRunAt',
           lastQueuedAt: 'lastQueuedAt',
         },
+        workflow: {
+          id: 'id',
+          userId: 'userId',
+          workspaceId: 'workspaceId',
+        },
       }
     })
 
@@ -311,6 +326,11 @@ describe('Scheduled Workflow Execution API Route', () => {
           nextRunAt: 'nextRunAt',
           lastQueuedAt: 'lastQueuedAt',
         },
+        workflow: {
+          id: 'id',
+          userId: 'userId',
+          workspaceId: 'workspaceId',
+        },
       }
     })
 

apps/sim/app/api/webhooks/trigger/[path]/route.ts

@@ -152,7 +152,6 @@ export async function POST(
     const response = await queueWebhookExecution(foundWebhook, foundWorkflow, body, request, {
       requestId,
       path,
-      executionTarget: 'deployed',
     })
     responses.push(response)
   }

apps/sim/app/api/workflows/[id]/execute/route.ts

@@ -110,6 +110,7 @@ type AsyncExecutionParams = {
   userId: string
   input: any
   triggerType: CoreTriggerType
+  preflighted?: boolean
 }
 
 /**
@@ -132,6 +133,7 @@ async function handleAsyncExecution(params: AsyncExecutionParams): Promise<NextR
     userId,
     input,
     triggerType,
+    preflighted: params.preflighted,
   }
 
   try {
@@ -264,6 +266,7 @@ export async function POST(req: NextRequest, { params }: { params: Promise<{ id:
       requestId
     )
 
+    const shouldPreflightEnvVars = isAsyncMode && isTriggerDevEnabled
     const preprocessResult = await preprocessExecution({
       workflowId,
       userId,
@@ -272,6 +275,9 @@ export async function POST(req: NextRequest, { params }: { params: Promise<{ id:
       requestId,
       checkDeployment: !shouldUseDraftState,
       loggingSession,
+      preflightEnvVars: shouldPreflightEnvVars,
+      useDraftState: shouldUseDraftState,
+      envUserId: isClientSession ? userId : undefined,
     })
 
     if (!preprocessResult.success) {
@@ -303,6 +309,7 @@ export async function POST(req: NextRequest, { params }: { params: Promise<{ id:
         userId: actorUserId,
         input,
         triggerType: loggingTriggerType,
+        preflighted: shouldPreflightEnvVars,
       })
     }
 

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/combobox/combobox.tsx

@@ -2,16 +2,19 @@ import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
 import { useReactFlow } from 'reactflow'
 import { Combobox, type ComboboxOption } from '@/components/emcn/components'
 import { cn } from '@/lib/core/utils/cn'
+import { buildCanonicalIndex, resolveDependencyValue } from '@/lib/workflows/subblocks/visibility'
 import { formatDisplayText } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/formatted-text'
 import { SubBlockInputController } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/sub-block-input-controller'
 import { useSubBlockValue } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/hooks/use-sub-block-value'
 import { useAccessibleReferencePrefixes } from '@/app/workspace/[workspaceId]/w/[workflowId]/hooks/use-accessible-reference-prefixes'
+import { getBlock } from '@/blocks/registry'
 import type { SubBlockConfig } from '@/blocks/types'
 import { getDependsOnFields } from '@/blocks/utils'
 import { usePermissionConfig } from '@/hooks/use-permission-config'
 import { getProviderFromModel } from '@/providers/utils'
 import { useWorkflowRegistry } from '@/stores/workflows/registry/store'
 import { useSubBlockStore } from '@/stores/workflows/subblock/store'
+import { useWorkflowStore } from '@/stores/workflows/workflow/store'
 
 /**
  * Constants for ComboBox component behavior
@@ -91,15 +94,24 @@ export function ComboBox({
   // Dependency tracking for fetchOptions
   const dependsOnFields = useMemo(() => getDependsOnFields(dependsOn), [dependsOn])
   const activeWorkflowId = useWorkflowRegistry((s) => s.activeWorkflowId)
+  const blockState = useWorkflowStore((state) => state.blocks[blockId])
+  const blockConfig = blockState?.type ? getBlock(blockState.type) : null
+  const canonicalIndex = useMemo(
+    () => buildCanonicalIndex(blockConfig?.subBlocks || []),
+    [blockConfig?.subBlocks]
+  )
+  const canonicalModeOverrides = blockState?.data?.canonicalModes
   const dependencyValues = useSubBlockStore(
     useCallback(
       (state) => {
         if (dependsOnFields.length === 0 || !activeWorkflowId) return []
         const workflowValues = state.workflowValues[activeWorkflowId] || {}
         const blockValues = workflowValues[blockId] || {}
-        return dependsOnFields.map((depKey) => blockValues[depKey] ?? null)
+        return dependsOnFields.map((depKey) =>
+          resolveDependencyValue(depKey, blockValues, canonicalIndex, canonicalModeOverrides)
+        )
       },
-      [dependsOnFields, activeWorkflowId, blockId]
+      [dependsOnFields, activeWorkflowId, blockId, canonicalIndex, canonicalModeOverrides]
     )
   )
 

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/dropdown/dropdown.tsx

@@ -1,12 +1,15 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
 import { Badge } from '@/components/emcn'
 import { Combobox, type ComboboxOption } from '@/components/emcn/components'
+import { buildCanonicalIndex, resolveDependencyValue } from '@/lib/workflows/subblocks/visibility'
 import { useSubBlockValue } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/hooks/use-sub-block-value'
+import { getBlock } from '@/blocks/registry'
 import type { SubBlockConfig } from '@/blocks/types'
 import { getDependsOnFields } from '@/blocks/utils'
 import { ResponseBlockHandler } from '@/executor/handlers/response/response-handler'
 import { useWorkflowRegistry } from '@/stores/workflows/registry/store'
 import { useSubBlockStore } from '@/stores/workflows/subblock/store'
+import { useWorkflowStore } from '@/stores/workflows/workflow/store'
 
 /**
  * Dropdown option type - can be a simple string or an object with label, id, and optional icon
@@ -89,15 +92,24 @@ export function Dropdown({
   const dependsOnFields = useMemo(() => getDependsOnFields(dependsOn), [dependsOn])
 
   const activeWorkflowId = useWorkflowRegistry((s) => s.activeWorkflowId)
+  const blockState = useWorkflowStore((state) => state.blocks[blockId])
+  const blockConfig = blockState?.type ? getBlock(blockState.type) : null
+  const canonicalIndex = useMemo(
+    () => buildCanonicalIndex(blockConfig?.subBlocks || []),
+    [blockConfig?.subBlocks]
+  )
+  const canonicalModeOverrides = blockState?.data?.canonicalModes
   const dependencyValues = useSubBlockStore(
     useCallback(
       (state) => {
         if (dependsOnFields.length === 0 || !activeWorkflowId) return []
         const workflowValues = state.workflowValues[activeWorkflowId] || {}
         const blockValues = workflowValues[blockId] || {}
-        return dependsOnFields.map((depKey) => blockValues[depKey] ?? null)
+        return dependsOnFields.map((depKey) =>
+          resolveDependencyValue(depKey, blockValues, canonicalIndex, canonicalModeOverrides)
+        )
       },
-      [dependsOnFields, activeWorkflowId, blockId]
+      [dependsOnFields, activeWorkflowId, blockId, canonicalIndex, canonicalModeOverrides]
     )
   )
 

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/file-selector/file-selector-input.tsx

@@ -4,15 +4,19 @@ import { useMemo } from 'react'
 import { useParams } from 'next/navigation'
 import { Tooltip } from '@/components/emcn'
 import { getProviderIdFromServiceId } from '@/lib/oauth'
+import { buildCanonicalIndex, resolveDependencyValue } from '@/lib/workflows/subblocks/visibility'
 import { SelectorCombobox } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/selector-combobox/selector-combobox'
 import { useDependsOnGate } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/hooks/use-depends-on-gate'
 import { useForeignCredential } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/hooks/use-foreign-credential'
 import { useSubBlockValue } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/hooks/use-sub-block-value'
+import { getBlock } from '@/blocks/registry'
 import type { SubBlockConfig } from '@/blocks/types'
 import { isDependency } from '@/blocks/utils'
 import { resolveSelectorForSubBlock, type SelectorResolution } from '@/hooks/selectors/resolution'
 import { useCollaborativeWorkflow } from '@/hooks/use-collaborative-workflow'
 import { useWorkflowRegistry } from '@/stores/workflows/registry/store'
+import { useSubBlockStore } from '@/stores/workflows/subblock/store'
+import { useWorkflowStore } from '@/stores/workflows/workflow/store'
 
 interface FileSelectorInputProps {
   blockId: string
@@ -42,21 +46,59 @@ export function FileSelectorInput({
     previewContextValues,
   })
 
-  const [connectedCredentialFromStore] = useSubBlockValue(blockId, 'credential')
-  const [domainValueFromStore] = useSubBlockValue(blockId, 'domain')
-  const [projectIdValueFromStore] = useSubBlockValue(blockId, 'projectId')
-  const [planIdValueFromStore] = useSubBlockValue(blockId, 'planId')
-  const [teamIdValueFromStore] = useSubBlockValue(blockId, 'teamId')
-  const [siteIdValueFromStore] = useSubBlockValue(blockId, 'siteId')
-  const [collectionIdValueFromStore] = useSubBlockValue(blockId, 'collectionId')
+  const blockState = useWorkflowStore((state) => state.blocks[blockId])
+  const blockConfig = blockState?.type ? getBlock(blockState.type) : null
+  const canonicalIndex = useMemo(
+    () => buildCanonicalIndex(blockConfig?.subBlocks || []),
+    [blockConfig?.subBlocks]
+  )
+  const canonicalModeOverrides = blockState?.data?.canonicalModes
 
-  const connectedCredential = previewContextValues?.credential ?? connectedCredentialFromStore
+  const blockValues = useSubBlockStore((state) => {
+    if (!activeWorkflowId) return {}
+    const workflowValues = state.workflowValues[activeWorkflowId] || {}
+    return (workflowValues as Record<string, Record<string, unknown>>)[blockId] || {}
+  })
+
+  const [domainValueFromStore] = useSubBlockValue(blockId, 'domain')
+
+  const connectedCredential = previewContextValues?.credential ?? blockValues.credential
   const domainValue = previewContextValues?.domain ?? domainValueFromStore
-  const projectIdValue = previewContextValues?.projectId ?? projectIdValueFromStore
-  const planIdValue = previewContextValues?.planId ?? planIdValueFromStore
-  const teamIdValue = previewContextValues?.teamId ?? teamIdValueFromStore
-  const siteIdValue = previewContextValues?.siteId ?? siteIdValueFromStore
-  const collectionIdValue = previewContextValues?.collectionId ?? collectionIdValueFromStore
+
+  const teamIdValue = useMemo(
+    () =>
+      previewContextValues?.teamId ??
+      resolveDependencyValue('teamId', blockValues, canonicalIndex, canonicalModeOverrides),
+    [previewContextValues?.teamId, blockValues, canonicalIndex, canonicalModeOverrides]
+  )
+
+  const siteIdValue = useMemo(
+    () =>
+      previewContextValues?.siteId ??
+      resolveDependencyValue('siteId', blockValues, canonicalIndex, canonicalModeOverrides),
+    [previewContextValues?.siteId, blockValues, canonicalIndex, canonicalModeOverrides]
+  )
+
+  const collectionIdValue = useMemo(
+    () =>
+      previewContextValues?.collectionId ??
+      resolveDependencyValue('collectionId', blockValues, canonicalIndex, canonicalModeOverrides),
+    [previewContextValues?.collectionId, blockValues, canonicalIndex, canonicalModeOverrides]
+  )
+
+  const projectIdValue = useMemo(
+    () =>
+      previewContextValues?.projectId ??
+      resolveDependencyValue('projectId', blockValues, canonicalIndex, canonicalModeOverrides),
+    [previewContextValues?.projectId, blockValues, canonicalIndex, canonicalModeOverrides]
+  )
+
+  const planIdValue = useMemo(
+    () =>
+      previewContextValues?.planId ??
+      resolveDependencyValue('planId', blockValues, canonicalIndex, canonicalModeOverrides),
+    [previewContextValues?.planId, blockValues, canonicalIndex, canonicalModeOverrides]
+  )
 
   const normalizedCredentialId =
     typeof connectedCredential === 'string'
@@ -65,7 +107,6 @@ export function FileSelectorInput({
         ? ((connectedCredential as Record<string, any>).id ?? '')
         : ''
 
-  // Derive provider from serviceId using OAuth config (same pattern as credential-selector)
   const serviceId = subBlock.serviceId || ''
   const effectiveProviderId = useMemo(() => getProviderIdFromServiceId(serviceId), [serviceId])
 

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/project-selector/project-selector-input.tsx

@@ -4,14 +4,17 @@ import { useEffect, useMemo, useState } from 'react'
 import { useParams } from 'next/navigation'
 import { Tooltip } from '@/components/emcn'
 import { getProviderIdFromServiceId } from '@/lib/oauth'
+import { buildCanonicalIndex, resolveDependencyValue } from '@/lib/workflows/subblocks/visibility'
 import { SelectorCombobox } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/selector-combobox/selector-combobox'
 import { useDependsOnGate } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/hooks/use-depends-on-gate'
 import { useForeignCredential } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/hooks/use-foreign-credential'
 import { useSubBlockValue } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/hooks/use-sub-block-value'
+import { getBlock } from '@/blocks/registry'
 import type { SubBlockConfig } from '@/blocks/types'
 import { resolveSelectorForSubBlock } from '@/hooks/selectors/resolution'
-import { useCollaborativeWorkflow } from '@/hooks/use-collaborative-workflow'
 import { useWorkflowRegistry } from '@/stores/workflows/registry/store'
+import { useSubBlockStore } from '@/stores/workflows/subblock/store'
+import { useWorkflowStore } from '@/stores/workflows/workflow/store'
 
 interface ProjectSelectorInputProps {
   blockId: string
@@ -32,21 +35,36 @@ export function ProjectSelectorInput({
   previewValue,
   previewContextValues,
 }: ProjectSelectorInputProps) {
-  const { collaborativeSetSubblockValue } = useCollaborativeWorkflow()
   const params = useParams()
+  const activeWorkflowId = useWorkflowRegistry((s) => s.activeWorkflowId) as string | null
   const [selectedProjectId, setSelectedProjectId] = useState<string>('')
-  // Use the proper hook to get the current value and setter
   const [storeValue] = useSubBlockValue(blockId, subBlock.id)
-  const [connectedCredentialFromStore] = useSubBlockValue(blockId, 'credential')
-  const [linearTeamIdFromStore] = useSubBlockValue(blockId, 'teamId')
   const [jiraDomainFromStore] = useSubBlockValue(blockId, 'domain')
 
-  // Use previewContextValues if provided (for tools inside agent blocks), otherwise use store values
-  const connectedCredential = previewContextValues?.credential ?? connectedCredentialFromStore
-  const linearTeamId = previewContextValues?.teamId ?? linearTeamIdFromStore
+  const blockState = useWorkflowStore((state) => state.blocks[blockId])
+  const blockConfig = blockState?.type ? getBlock(blockState.type) : null
+  const canonicalIndex = useMemo(
+    () => buildCanonicalIndex(blockConfig?.subBlocks || []),
+    [blockConfig?.subBlocks]
+  )
+  const canonicalModeOverrides = blockState?.data?.canonicalModes
+
+  const blockValues = useSubBlockStore((state) => {
+    if (!activeWorkflowId) return {}
+    const workflowValues = state.workflowValues[activeWorkflowId] || {}
+    return (workflowValues as Record<string, Record<string, unknown>>)[blockId] || {}
+  })
+
+  const connectedCredential = previewContextValues?.credential ?? blockValues.credential
   const jiraDomain = previewContextValues?.domain ?? jiraDomainFromStore
 
-  // Derive provider from serviceId using OAuth config
+  const linearTeamId = useMemo(
+    () =>
+      previewContextValues?.teamId ??
+      resolveDependencyValue('teamId', blockValues, canonicalIndex, canonicalModeOverrides),
+    [previewContextValues?.teamId, blockValues, canonicalIndex, canonicalModeOverrides]
+  )
+
   const serviceId = subBlock.serviceId || ''
   const effectiveProviderId = useMemo(() => getProviderIdFromServiceId(serviceId), [serviceId])
 
@@ -54,7 +72,6 @@ export function ProjectSelectorInput({
     effectiveProviderId,
     (connectedCredential as string) || ''
   )
-  const activeWorkflowId = useWorkflowRegistry((s) => s.activeWorkflowId) as string | null
   const workflowIdFromUrl = (params?.workflowId as string) || activeWorkflowId || ''
   const { finalDisabled } = useDependsOnGate(blockId, subBlock, {
     disabled,
@@ -62,12 +79,8 @@ export function ProjectSelectorInput({
     previewContextValues,
   })
 
-  // Jira/Discord upstream fields - use values from previewContextValues or store
   const domain = (jiraDomain as string) || ''
 
-  // Verify Jira credential belongs to current user; if not, treat as absent
-
-  // Get the current value from the store or prop value if in preview mode
   useEffect(() => {
     if (isPreview && previewValue !== undefined) {
       setSelectedProjectId(previewValue)

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/sheet-selector/sheet-selector-input.tsx

@@ -4,14 +4,17 @@ import { useMemo } from 'react'
 import { useParams } from 'next/navigation'
 import { Tooltip } from '@/components/emcn'
 import { getProviderIdFromServiceId } from '@/lib/oauth'
+import { buildCanonicalIndex, resolveDependencyValue } from '@/lib/workflows/subblocks/visibility'
 import { SelectorCombobox } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/selector-combobox/selector-combobox'
 import { useDependsOnGate } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/hooks/use-depends-on-gate'
 import { useForeignCredential } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/hooks/use-foreign-credential'
-import { useSubBlockValue } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/hooks/use-sub-block-value'
+import { getBlock } from '@/blocks/registry'
 import type { SubBlockConfig } from '@/blocks/types'
 import { resolveSelectorForSubBlock, type SelectorResolution } from '@/hooks/selectors/resolution'
 import { useCollaborativeWorkflow } from '@/hooks/use-collaborative-workflow'
 import { useWorkflowRegistry } from '@/stores/workflows/registry/store'
+import { useSubBlockStore } from '@/stores/workflows/subblock/store'
+import { useWorkflowStore } from '@/stores/workflows/workflow/store'
 
 interface SheetSelectorInputProps {
   blockId: string
@@ -41,16 +44,32 @@ export function SheetSelectorInput({
     previewContextValues,
   })
 
-  const [connectedCredentialFromStore] = useSubBlockValue(blockId, 'credential')
-  const [spreadsheetIdFromStore] = useSubBlockValue(blockId, 'spreadsheetId')
-  const [manualSpreadsheetIdFromStore] = useSubBlockValue(blockId, 'manualSpreadsheetId')
+  const blockState = useWorkflowStore((state) => state.blocks[blockId])
+  const blockConfig = blockState?.type ? getBlock(blockState.type) : null
+  const canonicalIndex = useMemo(
+    () => buildCanonicalIndex(blockConfig?.subBlocks || []),
+    [blockConfig?.subBlocks]
+  )
+  const canonicalModeOverrides = blockState?.data?.canonicalModes
+
+  const blockValues = useSubBlockStore((state) => {
+    if (!activeWorkflowId) return {}
+    const workflowValues = state.workflowValues[activeWorkflowId] || {}
+    return (workflowValues as Record<string, Record<string, unknown>>)[blockId] || {}
+  })
+
+  const connectedCredentialFromStore = blockValues.credential
+
+  const spreadsheetIdFromStore = useMemo(
+    () =>
+      resolveDependencyValue('spreadsheetId', blockValues, canonicalIndex, canonicalModeOverrides),
+    [blockValues, canonicalIndex, canonicalModeOverrides]
+  )
 
   const connectedCredential = previewContextValues?.credential ?? connectedCredentialFromStore
-  const spreadsheetId =
-    previewContextValues?.spreadsheetId ??
-    spreadsheetIdFromStore ??
-    previewContextValues?.manualSpreadsheetId ??
-    manualSpreadsheetIdFromStore
+  const spreadsheetId = previewContextValues
+    ? (previewContextValues.spreadsheetId ?? previewContextValues.manualSpreadsheetId)
+    : spreadsheetIdFromStore
 
   const normalizedCredentialId =
     typeof connectedCredential === 'string'
@@ -61,7 +80,6 @@ export function SheetSelectorInput({
 
   const normalizedSpreadsheetId = typeof spreadsheetId === 'string' ? spreadsheetId.trim() : ''
 
-  // Derive provider from serviceId using OAuth config
   const serviceId = subBlock.serviceId || ''
   const effectiveProviderId = useMemo(() => getProviderIdFromServiceId(serviceId), [serviceId])
 

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/hooks/use-depends-on-gate.ts

@@ -1,9 +1,16 @@
 'use client'
 
 import { useMemo } from 'react'
+import {
+  buildCanonicalIndex,
+  isNonEmptyValue,
+  resolveDependencyValue,
+} from '@/lib/workflows/subblocks/visibility'
+import { getBlock } from '@/blocks/registry'
 import type { SubBlockConfig } from '@/blocks/types'
 import { useWorkflowRegistry } from '@/stores/workflows/registry/store'
 import { useSubBlockStore } from '@/stores/workflows/subblock/store'
+import { useWorkflowStore } from '@/stores/workflows/workflow/store'
 
 type DependsOnConfig = string[] | { all?: string[]; any?: string[] }
 
@@ -50,6 +57,13 @@ export function useDependsOnGate(
   const previewContextValues = opts?.previewContextValues
 
   const activeWorkflowId = useWorkflowRegistry((s) => s.activeWorkflowId)
+  const blockState = useWorkflowStore((state) => state.blocks[blockId])
+  const blockConfig = blockState?.type ? getBlock(blockState.type) : null
+  const canonicalIndex = useMemo(
+    () => buildCanonicalIndex(blockConfig?.subBlocks || []),
+    [blockConfig?.subBlocks]
+  )
+  const canonicalModeOverrides = blockState?.data?.canonicalModes
 
   // Parse dependsOn config to get all/any field lists
   const { allFields, anyFields, allDependsOnFields } = useMemo(
@@ -91,7 +105,13 @@ export function useDependsOnGate(
     if (previewContextValues) {
       const map: Record<string, unknown> = {}
       for (const key of allDependsOnFields) {
-        map[key] = normalizeDependencyValue(previewContextValues[key])
+        const resolvedValue = resolveDependencyValue(
+          key,
+          previewContextValues,
+          canonicalIndex,
+          canonicalModeOverrides
+        )
+        map[key] = normalizeDependencyValue(resolvedValue)
       }
       return map
     }
@@ -108,32 +128,25 @@ export function useDependsOnGate(
     const blockValues = (workflowValues as any)[blockId] || {}
     const map: Record<string, unknown> = {}
     for (const key of allDependsOnFields) {
-      map[key] = normalizeDependencyValue((blockValues as any)[key])
+      const resolvedValue = resolveDependencyValue(
+        key,
+        blockValues,
+        canonicalIndex,
+        canonicalModeOverrides
+      )
+      map[key] = normalizeDependencyValue(resolvedValue)
     }
     return map
   })
 
-  // For backward compatibility, also provide array of values
-  const dependencyValues = useMemo(
-    () => allDependsOnFields.map((key) => dependencyValuesMap[key]),
-    [allDependsOnFields, dependencyValuesMap]
-  ) as any[]
-
-  const isValueSatisfied = (value: unknown): boolean => {
-    if (value === null || value === undefined) return false
-    if (typeof value === 'string') return value.trim().length > 0
-    if (Array.isArray(value)) return value.length > 0
-    return value !== ''
-  }
-
   const depsSatisfied = useMemo(() => {
     // Check all fields (AND logic) - all must be satisfied
     const allSatisfied =
-      allFields.length === 0 || allFields.every((key) => isValueSatisfied(dependencyValuesMap[key]))
+      allFields.length === 0 || allFields.every((key) => isNonEmptyValue(dependencyValuesMap[key]))
 
     // Check any fields (OR logic) - at least one must be satisfied
     const anySatisfied =
-      anyFields.length === 0 || anyFields.some((key) => isValueSatisfied(dependencyValuesMap[key]))
+      anyFields.length === 0 || anyFields.some((key) => isNonEmptyValue(dependencyValuesMap[key]))
 
     return allSatisfied && anySatisfied
   }, [allFields, anyFields, dependencyValuesMap])
@@ -146,7 +159,6 @@ export function useDependsOnGate(
 
   return {
     dependsOn,
-    dependencyValues,
     depsSatisfied,
     blocked,
     finalDisabled,

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/sub-block.tsx

@@ -1,5 +1,5 @@
 import { type JSX, type MouseEvent, memo, useRef, useState } from 'react'
-import { AlertTriangle, ArrowUp } from 'lucide-react'
+import { AlertTriangle, ArrowLeftRight, ArrowUp } from 'lucide-react'
 import { Button, Input, Label, Tooltip } from '@/components/emcn/components'
 import { cn } from '@/lib/core/utils/cn'
 import type { FieldDiffStatus } from '@/lib/workflows/diff/types'
@@ -67,6 +67,11 @@ interface SubBlockProps {
   disabled?: boolean
   fieldDiffStatus?: FieldDiffStatus
   allowExpandInPreview?: boolean
+  canonicalToggle?: {
+    mode: 'basic' | 'advanced'
+    disabled?: boolean
+    onToggle?: () => void
+  }
 }
 
 /**
@@ -182,6 +187,11 @@ const renderLabel = (
     onSearchSubmit: () => void
     onSearchCancel: () => void
     searchInputRef: React.RefObject<HTMLInputElement | null>
+  },
+  canonicalToggle?: {
+    mode: 'basic' | 'advanced'
+    disabled?: boolean
+    onToggle?: () => void
   }
 ): JSX.Element | null => {
   if (config.type === 'switch') return null
@@ -189,6 +199,8 @@ const renderLabel = (
 
   const required = isFieldRequired(config, subBlockValues)
   const showWand = wandState?.isWandEnabled && !wandState.isPreview && !wandState.disabled
+  const showCanonicalToggle = !!canonicalToggle && !wandState?.isPreview
+  const canonicalToggleDisabled = wandState?.disabled || canonicalToggle?.disabled
 
   return (
     <Label
@@ -214,56 +226,80 @@ const renderLabel = (
           </Tooltip.Root>
         )}
       </div>
-      {showWand && (
-        <>
-          {!wandState.isSearchActive ? (
-            <Button
-              variant='active'
-              className='-my-1 h-5 px-2 py-0 text-[11px]'
-              onClick={wandState.onSearchClick}
-            >
-              Generate
-            </Button>
-          ) : (
-            <div className='-my-1 flex items-center gap-[4px]'>
-              <Input
-                ref={wandState.searchInputRef}
-                value={wandState.isStreaming ? 'Generating...' : wandState.searchQuery}
-                onChange={(e) => wandState.onSearchChange(e.target.value)}
-                onBlur={wandState.onSearchBlur}
-                onKeyDown={(e) => {
-                  if (e.key === 'Enter' && wandState.searchQuery.trim() && !wandState.isStreaming) {
-                    wandState.onSearchSubmit()
-                  } else if (e.key === 'Escape') {
-                    wandState.onSearchCancel()
-                  }
-                }}
-                disabled={wandState.isStreaming}
-                className={cn(
-                  'h-5 max-w-[200px] flex-1 text-[11px]',
-                  wandState.isStreaming && 'text-muted-foreground'
-                )}
-                placeholder='Generate...'
-              />
+      <div className='flex items-center gap-[6px]'>
+        {showWand && (
+          <>
+            {!wandState.isSearchActive ? (
               <Button
-                variant='tertiary'
-                disabled={!wandState.searchQuery.trim() || wandState.isStreaming}
-                onMouseDown={(e) => {
-                  e.preventDefault()
-                  e.stopPropagation()
-                }}
-                onClick={(e) => {
-                  e.stopPropagation()
-                  wandState.onSearchSubmit()
-                }}
-                className='h-[20px] w-[20px] flex-shrink-0 p-0'
+                variant='active'
+                className='-my-1 h-5 px-2 py-0 text-[11px]'
+                onClick={wandState.onSearchClick}
               >
-                <ArrowUp className='h-[12px] w-[12px]' />
+                Generate
               </Button>
-            </div>
-          )}
-        </>
-      )}
+            ) : (
+              <div className='-my-1 flex items-center gap-[4px]'>
+                <Input
+                  ref={wandState.searchInputRef}
+                  value={wandState.isStreaming ? 'Generating...' : wandState.searchQuery}
+                  onChange={(e) => wandState.onSearchChange(e.target.value)}
+                  onBlur={wandState.onSearchBlur}
+                  onKeyDown={(e) => {
+                    if (
+                      e.key === 'Enter' &&
+                      wandState.searchQuery.trim() &&
+                      !wandState.isStreaming
+                    ) {
+                      wandState.onSearchSubmit()
+                    } else if (e.key === 'Escape') {
+                      wandState.onSearchCancel()
+                    }
+                  }}
+                  disabled={wandState.isStreaming}
+                  className={cn(
+                    'h-5 max-w-[200px] flex-1 text-[11px]',
+                    wandState.isStreaming && 'text-muted-foreground'
+                  )}
+                  placeholder='Generate...'
+                />
+                <Button
+                  variant='tertiary'
+                  disabled={!wandState.searchQuery.trim() || wandState.isStreaming}
+                  onMouseDown={(e) => {
+                    e.preventDefault()
+                    e.stopPropagation()
+                  }}
+                  onClick={(e) => {
+                    e.stopPropagation()
+                    wandState.onSearchSubmit()
+                  }}
+                  className='h-[20px] w-[20px] flex-shrink-0 p-0'
+                >
+                  <ArrowUp className='h-[12px] w-[12px]' />
+                </Button>
+              </div>
+            )}
+          </>
+        )}
+        {showCanonicalToggle && (
+          <button
+            type='button'
+            className='flex h-[12px] w-[12px] flex-shrink-0 items-center justify-center bg-transparent p-0 disabled:opacity-50'
+            onClick={canonicalToggle?.onToggle}
+            disabled={canonicalToggleDisabled}
+            aria-label={canonicalToggle?.mode === 'advanced' ? 'Use selector' : 'Enter manual ID'}
+          >
+            <ArrowLeftRight
+              className={cn(
+                '!h-[12px] !w-[12px]',
+                canonicalToggle?.mode === 'advanced'
+                  ? 'text-[var(--text-primary)]'
+                  : 'text-[var(--text-secondary)]'
+              )}
+            />
+          </button>
+        )}
+      </div>
     </Label>
   )
 }
@@ -287,7 +323,9 @@ const arePropsEqual = (prevProps: SubBlockProps, nextProps: SubBlockProps): bool
     prevProps.subBlockValues === nextProps.subBlockValues &&
     prevProps.disabled === nextProps.disabled &&
     prevProps.fieldDiffStatus === nextProps.fieldDiffStatus &&
-    prevProps.allowExpandInPreview === nextProps.allowExpandInPreview
+    prevProps.allowExpandInPreview === nextProps.allowExpandInPreview &&
+    prevProps.canonicalToggle?.mode === nextProps.canonicalToggle?.mode &&
+    prevProps.canonicalToggle?.disabled === nextProps.canonicalToggle?.disabled
   )
 }
 
@@ -316,6 +354,7 @@ function SubBlockComponent({
   disabled = false,
   fieldDiffStatus,
   allowExpandInPreview,
+  canonicalToggle,
 }: SubBlockProps): JSX.Element {
   const [isValidJson, setIsValidJson] = useState(true)
   const [isSearchActive, setIsSearchActive] = useState(false)
@@ -887,20 +926,26 @@ function SubBlockComponent({
 
   return (
     <div onMouseDown={handleMouseDown} className='subblock-content flex flex-col gap-[10px]'>
-      {renderLabel(config, isValidJson, subBlockValues, {
-        isSearchActive,
-        searchQuery,
-        isWandEnabled,
-        isPreview,
-        isStreaming: wandControlRef.current?.isWandStreaming ?? false,
-        disabled: isDisabled,
-        onSearchClick: handleSearchClick,
-        onSearchBlur: handleSearchBlur,
-        onSearchChange: handleSearchChange,
-        onSearchSubmit: handleSearchSubmit,
-        onSearchCancel: handleSearchCancel,
-        searchInputRef,
-      })}
+      {renderLabel(
+        config,
+        isValidJson,
+        subBlockValues,
+        {
+          isSearchActive,
+          searchQuery,
+          isWandEnabled,
+          isPreview,
+          isStreaming: wandControlRef.current?.isWandStreaming ?? false,
+          disabled: isDisabled,
+          onSearchClick: handleSearchClick,
+          onSearchBlur: handleSearchBlur,
+          onSearchChange: handleSearchChange,
+          onSearchSubmit: handleSearchSubmit,
+          onSearchCancel: handleSearchCancel,
+          searchInputRef,
+        },
+        canonicalToggle
+      )}
       {renderInput()}
     </div>
   )

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/editor.tsx

@@ -1,8 +1,15 @@
 'use client'
 
-import { useCallback, useEffect, useRef, useState } from 'react'
-import { BookOpen, Check, ChevronUp, Pencil, Settings } from 'lucide-react'
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
+import { BookOpen, Check, ChevronDown, ChevronUp, Pencil } from 'lucide-react'
 import { Button, Tooltip } from '@/components/emcn'
+import {
+  buildCanonicalIndex,
+  hasAdvancedValues,
+  hasStandaloneAdvancedFields,
+  isCanonicalPair,
+  resolveCanonicalMode,
+} from '@/lib/workflows/subblocks/visibility'
 import { useUserPermissionsContext } from '@/app/workspace/[workspaceId]/providers/workspace-permissions-provider'
 import {
   ConnectionBlocks,
@@ -89,11 +96,28 @@ export function Editor() {
     )
   )
 
+  const canonicalIndex = useMemo(
+    () => buildCanonicalIndex(blockConfig?.subBlocks || []),
+    [blockConfig?.subBlocks]
+  )
+  const canonicalModeOverrides = currentBlock?.data?.canonicalModes
+  const advancedValuesPresent = hasAdvancedValues(
+    blockConfig?.subBlocks || [],
+    blockSubBlockValues,
+    canonicalIndex
+  )
+  const displayAdvancedOptions = advancedMode || advancedValuesPresent
+
+  const hasAdvancedOnlyFields = useMemo(
+    () => hasStandaloneAdvancedFields(blockConfig?.subBlocks || [], canonicalIndex),
+    [blockConfig?.subBlocks, canonicalIndex]
+  )
+
   // Get subblock layout using custom hook
   const { subBlocks, stateToUse: subBlockState } = useEditorSubblockLayout(
     blockConfig || ({} as any),
     currentBlockId || '',
-    advancedMode,
+    displayAdvancedOptions,
     triggerMode,
     activeWorkflowId,
     blockSubBlockValues,
@@ -109,21 +133,23 @@ export function Editor() {
   })
 
   // Collaborative actions
-  const { collaborativeToggleBlockAdvancedMode, collaborativeUpdateBlockName } =
-    useCollaborativeWorkflow()
+  const {
+    collaborativeSetBlockCanonicalMode,
+    collaborativeUpdateBlockName,
+    collaborativeToggleBlockAdvancedMode,
+  } = useCollaborativeWorkflow()
+
+  // Advanced mode toggle handler
+  const handleToggleAdvancedMode = useCallback(() => {
+    if (!currentBlockId || !userPermissions.canEdit) return
+    collaborativeToggleBlockAdvancedMode(currentBlockId)
+  }, [currentBlockId, userPermissions.canEdit, collaborativeToggleBlockAdvancedMode])
 
   // Rename state
   const [isRenaming, setIsRenaming] = useState(false)
   const [editedName, setEditedName] = useState('')
   const nameInputRef = useRef<HTMLInputElement>(null)
 
-  // Mode toggle handlers
-  const handleToggleAdvancedMode = useCallback(() => {
-    if (currentBlockId && userPermissions.canEdit) {
-      collaborativeToggleBlockAdvancedMode(currentBlockId)
-    }
-  }, [currentBlockId, userPermissions.canEdit, collaborativeToggleBlockAdvancedMode])
-
   /**
    * Handles starting the rename process.
    */
@@ -183,9 +209,6 @@ export function Editor() {
     }
   }
 
-  // Check if block has advanced mode or trigger mode available
-  const hasAdvancedMode = blockConfig?.subBlocks?.some((sb) => sb.mode === 'advanced')
-
   // Determine if connections are at minimum height (collapsed state)
   const isConnectionsAtMinHeight = connectionsHeight <= 35
 
@@ -278,25 +301,6 @@ export function Editor() {
               </Tooltip.Content>
             </Tooltip.Root>
           )} */}
-          {/* Mode toggles - Only show for regular blocks, not subflows */}
-          {currentBlock && !isSubflow && hasAdvancedMode && (
-            <Tooltip.Root>
-              <Tooltip.Trigger asChild>
-                <Button
-                  variant='ghost'
-                  className='p-0'
-                  onClick={handleToggleAdvancedMode}
-                  disabled={!userPermissions.canEdit}
-                  aria-label='Toggle advanced mode'
-                >
-                  <Settings className='h-[14px] w-[14px]' />
-                </Button>
-              </Tooltip.Trigger>
-              <Tooltip.Content side='top'>
-                <p>Advanced mode</p>
-              </Tooltip.Content>
-            </Tooltip.Root>
-          )}
           {currentBlock && (isSubflow ? subflowConfig?.docsLink : blockConfig?.docsLink) && (
             <Tooltip.Root>
               <Tooltip.Trigger asChild>
@@ -355,6 +359,19 @@ export function Editor() {
                       subBlock,
                       subBlockState
                     )
+                    const canonicalId = canonicalIndex.canonicalIdBySubBlockId[subBlock.id]
+                    const canonicalGroup = canonicalId
+                      ? canonicalIndex.groupsById[canonicalId]
+                      : undefined
+                    const isCanonicalSwap = isCanonicalPair(canonicalGroup)
+                    const canonicalMode =
+                      canonicalGroup && isCanonicalSwap
+                        ? resolveCanonicalMode(
+                            canonicalGroup,
+                            blockSubBlockValues,
+                            canonicalModeOverrides
+                          )
+                        : undefined
 
                     return (
                       <div key={stableKey} className='subblock-row'>
@@ -366,6 +383,24 @@ export function Editor() {
                           disabled={!userPermissions.canEdit}
                           fieldDiffStatus={undefined}
                           allowExpandInPreview={false}
+                          canonicalToggle={
+                            isCanonicalSwap && canonicalMode && canonicalId
+                              ? {
+                                  mode: canonicalMode,
+                                  disabled: !userPermissions.canEdit,
+                                  onToggle: () => {
+                                    if (!currentBlockId) return
+                                    const nextMode =
+                                      canonicalMode === 'advanced' ? 'basic' : 'advanced'
+                                    collaborativeSetBlockCanonicalMode(
+                                      currentBlockId,
+                                      canonicalId,
+                                      nextMode
+                                    )
+                                  },
+                                }
+                              : undefined
+                          }
                         />
                         {index < subBlocks.length - 1 && (
                           <div className='subblock-divider px-[2px] pt-[16px] pb-[13px]'>
@@ -383,6 +418,30 @@ export function Editor() {
                   })}
                 </div>
               )}
+
+              {/* Advanced Mode Toggle - Only show when block has standalone advanced-only fields */}
+              {hasAdvancedOnlyFields && userPermissions.canEdit && (
+                <div className='flex items-center justify-center pt-[8px] pb-[4px]'>
+                  <Button
+                    variant='ghost'
+                    size='sm'
+                    onClick={handleToggleAdvancedMode}
+                    className='h-[28px] gap-[6px] px-[10px] text-[12px] text-[var(--text-secondary)] hover:text-[var(--text-primary)]'
+                  >
+                    {displayAdvancedOptions ? (
+                      <>
+                        <ChevronUp className='h-[14px] w-[14px]' />
+                        Hide advanced fields
+                      </>
+                    ) : (
+                      <>
+                        <ChevronDown className='h-[14px] w-[14px]' />
+                        Show advanced fields
+                      </>
+                    )}
+                  </Button>
+                </div>
+              )}
             </div>
           </div>
 

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/hooks/use-editor-subblock-layout.ts

@@ -1,5 +1,10 @@
-import { useMemo } from 'react'
-import { getEnv, isTruthy } from '@/lib/core/config/env'
+import { useCallback, useMemo } from 'react'
+import {
+  buildCanonicalIndex,
+  evaluateSubBlockCondition,
+  isSubBlockFeatureEnabled,
+  isSubBlockVisibleForMode,
+} from '@/lib/workflows/subblocks/visibility'
 import type { BlockConfig, SubBlockConfig, SubBlockType } from '@/blocks/types'
 import { useWorkflowDiffStore } from '@/stores/workflow-diff'
 import { mergeSubblockState } from '@/stores/workflows/utils'
@@ -27,6 +32,10 @@ export function useEditorSubblockLayout(
   blockSubBlockValues: Record<string, any>,
   isSnapshotView: boolean
 ) {
+  const blockDataFromStore = useWorkflowStore(
+    useCallback((state) => state.blocks?.[blockId]?.data, [blockId])
+  )
+
   return useMemo(() => {
     // Guard against missing config or block selection
     if (!config || !Array.isArray((config as any).subBlocks) || !blockId) {
@@ -46,6 +55,7 @@ export function useEditorSubblockLayout(
 
     const mergedState = mergedMap ? mergedMap[blockId] : undefined
     const mergedSubBlocks = mergedState?.subBlocks || {}
+    const blockData = isSnapshotView ? mergedState?.data || {} : blockDataFromStore || {}
 
     const stateToUse = Object.keys(mergedSubBlocks).reduce(
       (acc, key) => {
@@ -69,13 +79,23 @@ export function useEditorSubblockLayout(
     }
 
     // Filter visible blocks and those that meet their conditions
+    const rawValues = Object.entries(stateToUse).reduce<Record<string, unknown>>(
+      (acc, [key, entry]) => {
+        acc[key] = entry?.value
+        return acc
+      },
+      {}
+    )
+
+    const canonicalIndex = buildCanonicalIndex(config.subBlocks || [])
+    const effectiveAdvanced = displayAdvancedMode
+    const canonicalModeOverrides = blockData?.canonicalModes
+
     const visibleSubBlocks = (config.subBlocks || []).filter((block) => {
       if (block.hidden) return false
 
       // Check required feature if specified - declarative feature gating
-      if (block.requiresFeature && !isTruthy(getEnv(block.requiresFeature))) {
-        return false
-      }
+      if (!isSubBlockFeatureEnabled(block)) return false
 
       // Special handling for trigger-config type (legacy trigger configuration UI)
       if (block.type === ('trigger-config' as SubBlockType)) {
@@ -84,13 +104,8 @@ export function useEditorSubblockLayout(
       }
 
       // Filter by mode if specified
-      if (block.mode) {
-        if (block.mode === 'basic' && displayAdvancedMode) return false
-        if (block.mode === 'advanced' && !displayAdvancedMode) return false
-        if (block.mode === 'trigger') {
-          // Show trigger mode blocks only when in trigger mode
-          if (!displayTriggerMode) return false
-        }
+      if (block.mode === 'trigger') {
+        if (!displayTriggerMode) return false
       }
 
       // When in trigger mode, hide blocks that don't have mode: 'trigger'
@@ -98,42 +113,22 @@ export function useEditorSubblockLayout(
         return false
       }
 
+      if (
+        !isSubBlockVisibleForMode(
+          block,
+          effectiveAdvanced,
+          canonicalIndex,
+          rawValues,
+          canonicalModeOverrides
+        )
+      ) {
+        return false
+      }
+
       // If there's no condition, the block should be shown
       if (!block.condition) return true
 
-      // If condition is a function, call it to get the actual condition object
-      const actualCondition =
-        typeof block.condition === 'function' ? block.condition() : block.condition
-
-      // Get the values of the fields this block depends on from the appropriate state
-      const fieldValue = stateToUse[actualCondition.field]?.value
-      const andFieldValue = actualCondition.and
-        ? stateToUse[actualCondition.and.field]?.value
-        : undefined
-
-      // Check if the condition value is an array
-      const isValueMatch = Array.isArray(actualCondition.value)
-        ? fieldValue != null &&
-          (actualCondition.not
-            ? !actualCondition.value.includes(fieldValue as string | number | boolean)
-            : actualCondition.value.includes(fieldValue as string | number | boolean))
-        : actualCondition.not
-          ? fieldValue !== actualCondition.value
-          : fieldValue === actualCondition.value
-
-      // Check both conditions if 'and' is present
-      const isAndValueMatch =
-        !actualCondition.and ||
-        (Array.isArray(actualCondition.and.value)
-          ? andFieldValue != null &&
-            (actualCondition.and.not
-              ? !actualCondition.and.value.includes(andFieldValue as string | number | boolean)
-              : actualCondition.and.value.includes(andFieldValue as string | number | boolean))
-          : actualCondition.and.not
-            ? andFieldValue !== actualCondition.and.value
-            : andFieldValue === actualCondition.and.value)
-
-      return isValueMatch && isAndValueMatch
+      return evaluateSubBlockCondition(block.condition, rawValues)
     })
 
     return { subBlocks: visibleSubBlocks, stateToUse }
@@ -147,5 +142,6 @@ export function useEditorSubblockLayout(
     blockSubBlockValues,
     activeWorkflowId,
     isSnapshotView,
+    blockDataFromStore,
   ])
 }

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/workflow-block/workflow-block.tsx

@@ -3,11 +3,18 @@ import { createLogger } from '@sim/logger'
 import { useParams } from 'next/navigation'
 import { Handle, type NodeProps, Position, useUpdateNodeInternals } from 'reactflow'
 import { Badge, Tooltip } from '@/components/emcn'
-import { getEnv, isTruthy } from '@/lib/core/config/env'
 import { cn } from '@/lib/core/utils/cn'
 import { getBaseUrl } from '@/lib/core/utils/urls'
 import { createMcpToolId } from '@/lib/mcp/utils'
 import { getProviderIdFromServiceId } from '@/lib/oauth'
+import {
+  buildCanonicalIndex,
+  evaluateSubBlockCondition,
+  hasAdvancedValues,
+  isSubBlockFeatureEnabled,
+  isSubBlockVisibleForMode,
+  resolveDependencyValue,
+} from '@/lib/workflows/subblocks/visibility'
 import { useUserPermissionsContext } from '@/app/workspace/[workspaceId]/providers/workspace-permissions-provider'
 import { ActionBar } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/action-bar/action-bar'
 import {
@@ -329,6 +336,9 @@ const SubBlockRow = ({
   workflowId,
   blockId,
   allSubBlockValues,
+  displayAdvancedOptions,
+  canonicalIndex,
+  canonicalModeOverrides,
 }: {
   title: string
   value?: string
@@ -338,6 +348,9 @@ const SubBlockRow = ({
   workflowId?: string
   blockId?: string
   allSubBlockValues?: Record<string, { value: unknown }>
+  displayAdvancedOptions?: boolean
+  canonicalIndex?: ReturnType<typeof buildCanonicalIndex>
+  canonicalModeOverrides?: Record<string, 'basic' | 'advanced'>
 }) => {
   const getStringValue = useCallback(
     (key?: string): string | undefined => {
@@ -348,17 +361,43 @@ const SubBlockRow = ({
     [allSubBlockValues]
   )
 
+  const rawValues = useMemo(() => {
+    if (!allSubBlockValues) return {}
+    return Object.entries(allSubBlockValues).reduce<Record<string, unknown>>(
+      (acc, [key, entry]) => {
+        acc[key] = entry?.value
+        return acc
+      },
+      {}
+    )
+  }, [allSubBlockValues])
+
   const dependencyValues = useMemo(() => {
     const fields = getDependsOnFields(subBlock?.dependsOn)
     if (!fields.length) return {}
     return fields.reduce<Record<string, string>>((accumulator, dependency) => {
-      const dependencyValue = getStringValue(dependency)
-      if (dependencyValue) {
-        accumulator[dependency] = dependencyValue
+      const dependencyValue = resolveDependencyValue(
+        dependency,
+        rawValues,
+        canonicalIndex || buildCanonicalIndex([]),
+        canonicalModeOverrides
+      )
+      const dependencyString =
+        typeof dependencyValue === 'string' && dependencyValue.length > 0
+          ? dependencyValue
+          : undefined
+      if (dependencyString) {
+        accumulator[dependency] = dependencyString
       }
       return accumulator
     }, {})
-  }, [getStringValue, subBlock?.dependsOn])
+  }, [
+    canonicalIndex,
+    canonicalModeOverrides,
+    displayAdvancedOptions,
+    rawValues,
+    subBlock?.dependsOn,
+  ])
 
   const credentialSourceId =
     subBlock?.type === 'oauth-input' && typeof rawValue === 'string' ? rawValue : undefined
@@ -567,6 +606,7 @@ export const WorkflowBlock = memo(function WorkflowBlock({
 
   const [isDeploying, setIsDeploying] = useState(false)
   const setDeploymentStatus = useWorkflowRegistry((state) => state.setDeploymentStatus)
+  const userPermissions = useUserPermissionsContext()
 
   const deployWorkflow = useCallback(
     async (workflowId: string) => {
@@ -627,6 +667,8 @@ export const WorkflowBlock = memo(function WorkflowBlock({
       [activeWorkflowId, id]
     )
   )
+  const canonicalIndex = useMemo(() => buildCanonicalIndex(config.subBlocks), [config.subBlocks])
+  const canonicalModeOverrides = currentStoreBlock?.data?.canonicalModes
 
   const subBlockRowsData = useMemo(() => {
     const rows: SubBlockConfig[][] = []
@@ -649,16 +691,23 @@ export const WorkflowBlock = memo(function WorkflowBlock({
             {} as Record<string, { value: unknown }>
           )
 
-    const effectiveAdvanced = displayAdvancedMode
+    const rawValues = Object.entries(stateToUse).reduce<Record<string, unknown>>(
+      (acc, [key, entry]) => {
+        acc[key] = entry?.value
+        return acc
+      },
+      {}
+    )
+
+    const effectiveAdvanced = userPermissions.canEdit
+      ? displayAdvancedMode
+      : displayAdvancedMode || hasAdvancedValues(config.subBlocks, rawValues, canonicalIndex)
     const effectiveTrigger = displayTriggerMode
 
     const visibleSubBlocks = config.subBlocks.filter((block) => {
       if (block.hidden) return false
       if (block.hideFromPreview) return false
-
-      if (block.requiresFeature && !isTruthy(getEnv(block.requiresFeature))) {
-        return false
-      }
+      if (!isSubBlockFeatureEnabled(block)) return false
 
       const isPureTriggerBlock = config?.triggers?.enabled && config.category === 'triggers'
 
@@ -676,40 +725,21 @@ export const WorkflowBlock = memo(function WorkflowBlock({
         }
       }
 
-      if (block.mode === 'basic' && effectiveAdvanced) return false
-      if (block.mode === 'advanced' && !effectiveAdvanced) return false
+      if (
+        !isSubBlockVisibleForMode(
+          block,
+          effectiveAdvanced,
+          canonicalIndex,
+          rawValues,
+          canonicalModeOverrides
+        )
+      ) {
+        return false
+      }
 
       if (!block.condition) return true
 
-      const actualCondition =
-        typeof block.condition === 'function' ? block.condition() : block.condition
-
-      const fieldValue = stateToUse[actualCondition.field]?.value
-      const andFieldValue = actualCondition.and
-        ? stateToUse[actualCondition.and.field]?.value
-        : undefined
-
-      const isValueMatch = Array.isArray(actualCondition.value)
-        ? fieldValue != null &&
-          (actualCondition.not
-            ? !actualCondition.value.includes(fieldValue as string | number | boolean)
-            : actualCondition.value.includes(fieldValue as string | number | boolean))
-        : actualCondition.not
-          ? fieldValue !== actualCondition.value
-          : fieldValue === actualCondition.value
-
-      const isAndValueMatch =
-        !actualCondition.and ||
-        (Array.isArray(actualCondition.and.value)
-          ? andFieldValue != null &&
-            (actualCondition.and.not
-              ? !actualCondition.and.value.includes(andFieldValue as string | number | boolean)
-              : actualCondition.and.value.includes(andFieldValue as string | number | boolean))
-          : actualCondition.and.not
-            ? andFieldValue !== actualCondition.and.value
-            : andFieldValue === actualCondition.and.value)
-
-      return isValueMatch && isAndValueMatch
+      return evaluateSubBlockCondition(block.condition, rawValues)
     })
 
     visibleSubBlocks.forEach((block) => {
@@ -741,12 +771,33 @@ export const WorkflowBlock = memo(function WorkflowBlock({
     data.subBlockValues,
     currentWorkflow.isDiffMode,
     currentBlock,
+    canonicalModeOverrides,
+    userPermissions.canEdit,
+    canonicalIndex,
     blockSubBlockValues,
     activeWorkflowId,
   ])
 
   const subBlockRows = subBlockRowsData.rows
   const subBlockState = subBlockRowsData.stateToUse
+  const effectiveAdvanced = useMemo(() => {
+    const rawValues = Object.entries(subBlockState).reduce<Record<string, unknown>>(
+      (acc, [key, entry]) => {
+        acc[key] = entry?.value
+        return acc
+      },
+      {}
+    )
+    return userPermissions.canEdit
+      ? displayAdvancedMode
+      : displayAdvancedMode || hasAdvancedValues(config.subBlocks, rawValues, canonicalIndex)
+  }, [
+    subBlockState,
+    displayAdvancedMode,
+    config.subBlocks,
+    canonicalIndex,
+    userPermissions.canEdit,
+  ])
 
   /**
    * Determine if block has content below the header (subblocks or error row).
@@ -909,7 +960,6 @@ export const WorkflowBlock = memo(function WorkflowBlock({
   const showWebhookIndicator = (isStarterBlock || isWebhookTriggerBlock) && isWebhookConfigured
   const shouldShowScheduleBadge =
     type === 'schedule' && !isLoadingScheduleInfo && scheduleInfo !== null
-  const userPermissions = useUserPermissionsContext()
   const isWorkflowSelector = type === 'workflow' || type === 'workflow_input'
 
   return (
@@ -1121,6 +1171,9 @@ export const WorkflowBlock = memo(function WorkflowBlock({
                       workflowId={currentWorkflowId}
                       blockId={id}
                       allSubBlockValues={subBlockState}
+                      displayAdvancedOptions={effectiveAdvanced}
+                      canonicalIndex={canonicalIndex}
+                      canonicalModeOverrides={canonicalModeOverrides}
                     />
                   )
                 })

apps/sim/app/workspace/[workspaceId]/w/components/preview/components/block-details-sidebar.tsx

@@ -14,6 +14,13 @@ import { ReactFlowProvider } from 'reactflow'
 import { Badge, Button, ChevronDown, Code, Combobox, Input, Label } from '@/components/emcn'
 import { cn } from '@/lib/core/utils/cn'
 import { extractReferencePrefixes } from '@/lib/workflows/sanitization/references'
+import {
+  buildCanonicalIndex,
+  evaluateSubBlockCondition,
+  hasAdvancedValues,
+  isSubBlockFeatureEnabled,
+  isSubBlockVisibleForMode,
+} from '@/lib/workflows/subblocks/visibility'
 import { SnapshotContextMenu } from '@/app/workspace/[workspaceId]/logs/components/log-details/components/execution-snapshot/components'
 import { SubBlock } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components'
 import { useContextMenu } from '@/app/workspace/[workspaceId]/w/components/sidebar/hooks'
@@ -24,56 +31,6 @@ import { navigatePath } from '@/executor/variables/resolvers/reference'
 import { useCodeViewerFeatures } from '@/hooks/use-code-viewer'
 import type { BlockState, Loop, Parallel } from '@/stores/workflows/workflow/types'
 
-/**
- * Evaluate whether a subblock's condition is met based on current values.
- */
-function evaluateCondition(
-  condition: SubBlockConfig['condition'],
-  subBlockValues: Record<string, { value: unknown } | unknown>
-): boolean {
-  if (!condition) return true
-
-  const actualCondition = typeof condition === 'function' ? condition() : condition
-
-  const fieldValueObj = subBlockValues[actualCondition.field]
-  const fieldValue =
-    fieldValueObj && typeof fieldValueObj === 'object' && 'value' in fieldValueObj
-      ? (fieldValueObj as { value: unknown }).value
-      : fieldValueObj
-
-  const conditionValues = Array.isArray(actualCondition.value)
-    ? actualCondition.value
-    : [actualCondition.value]
-
-  let isMatch = conditionValues.some((v) => v === fieldValue)
-
-  if (actualCondition.not) {
-    isMatch = !isMatch
-  }
-
-  if (actualCondition.and && isMatch) {
-    const andFieldValueObj = subBlockValues[actualCondition.and.field]
-    const andFieldValue =
-      andFieldValueObj && typeof andFieldValueObj === 'object' && 'value' in andFieldValueObj
-        ? (andFieldValueObj as { value: unknown }).value
-        : andFieldValueObj
-
-    const andConditionValues = Array.isArray(actualCondition.and.value)
-      ? actualCondition.and.value
-      : [actualCondition.and.value]
-
-    let andMatch = andConditionValues.some((v) => v === andFieldValue)
-
-    if (actualCondition.and.not) {
-      andMatch = !andMatch
-    }
-
-    isMatch = isMatch && andMatch
-  }
-
-  return isMatch
-}
-
 /**
  * Format a value for display as JSON string
  */
@@ -1122,15 +1079,44 @@ function BlockDetailsSidebarContent({
     )
   }
 
+  const rawValues = useMemo(() => {
+    return Object.entries(subBlockValues).reduce<Record<string, unknown>>((acc, [key, entry]) => {
+      if (entry && typeof entry === 'object' && 'value' in entry) {
+        acc[key] = (entry as { value: unknown }).value
+      } else {
+        acc[key] = entry
+      }
+      return acc
+    }, {})
+  }, [subBlockValues])
+
+  const canonicalIndex = useMemo(
+    () => buildCanonicalIndex(blockConfig.subBlocks),
+    [blockConfig.subBlocks]
+  )
+  const canonicalModeOverrides = block.data?.canonicalModes
+  const effectiveAdvanced =
+    (block.advancedMode ?? false) ||
+    hasAdvancedValues(blockConfig.subBlocks, rawValues, canonicalIndex)
+
   const visibleSubBlocks = blockConfig.subBlocks.filter((subBlock) => {
     if (subBlock.hidden || subBlock.hideFromPreview) return false
     // Only filter out trigger-mode subblocks for non-trigger blocks
     // Trigger-only blocks (category 'triggers') should display their trigger subblocks
     if (subBlock.mode === 'trigger' && blockConfig.category !== 'triggers') return false
-    if (subBlock.condition) {
-      return evaluateCondition(subBlock.condition, subBlockValues)
+    if (!isSubBlockFeatureEnabled(subBlock)) return false
+    if (
+      !isSubBlockVisibleForMode(
+        subBlock,
+        effectiveAdvanced,
+        canonicalIndex,
+        rawValues,
+        canonicalModeOverrides
+      )
+    ) {
+      return false
     }
-    return true
+    return evaluateSubBlockCondition(subBlock.condition, rawValues)
   })
 
   const statusVariant =

apps/sim/background/schedule-execution.ts

@@ -5,7 +5,6 @@ import { Cron } from 'croner'
 import { eq } from 'drizzle-orm'
 import { v4 as uuidv4 } from 'uuid'
 import type { ZodRecord, ZodString } from 'zod'
-import { decryptSecret } from '@/lib/core/security/encryption'
 import { getPersonalAndWorkspaceEnv } from '@/lib/environment/utils'
 import { preprocessExecution } from '@/lib/execution/preprocessing'
 import { LoggingSession } from '@/lib/logs/execution/logging-session'
@@ -22,12 +21,9 @@ import {
   getScheduleTimeValues,
   getSubBlockValue,
 } from '@/lib/workflows/schedules/utils'
-import { REFERENCE } from '@/executor/constants'
 import { ExecutionSnapshot } from '@/executor/execution/snapshot'
 import type { ExecutionMetadata } from '@/executor/execution/types'
 import type { ExecutionResult } from '@/executor/types'
-import { createEnvVarPattern } from '@/executor/utils/reference-validation'
-import { mergeSubblockState } from '@/stores/workflows/server-utils'
 import { MAX_CONSECUTIVE_FAILURES } from '@/triggers/constants'
 
 const logger = createLogger('TriggerScheduleExecution')
@@ -119,68 +115,6 @@ async function determineNextRunAfterError(
   return new Date(now.getTime() + 24 * 60 * 60 * 1000)
 }
 
-async function ensureBlockVariablesResolvable(
-  blocks: Record<string, BlockState>,
-  variables: Record<string, string>,
-  requestId: string
-) {
-  await Promise.all(
-    Object.values(blocks).map(async (block) => {
-      const subBlocks = block.subBlocks ?? {}
-      await Promise.all(
-        Object.values(subBlocks).map(async (subBlock) => {
-          const value = subBlock.value
-          if (
-            typeof value !== 'string' ||
-            !value.includes(REFERENCE.ENV_VAR_START) ||
-            !value.includes(REFERENCE.ENV_VAR_END)
-          ) {
-            return
-          }
-
-          const envVarPattern = createEnvVarPattern()
-          const matches = value.match(envVarPattern)
-          if (!matches) {
-            return
-          }
-
-          for (const match of matches) {
-            const varName = match.slice(
-              REFERENCE.ENV_VAR_START.length,
-              -REFERENCE.ENV_VAR_END.length
-            )
-            const encryptedValue = variables[varName]
-            if (!encryptedValue) {
-              throw new Error(`Environment variable "${varName}" was not found`)
-            }
-
-            try {
-              await decryptSecret(encryptedValue)
-            } catch (error) {
-              logger.error(`[${requestId}] Error decrypting value for variable "${varName}"`, error)
-
-              const message = error instanceof Error ? error.message : 'Unknown error'
-              throw new Error(`Failed to decrypt environment variable "${varName}": ${message}`)
-            }
-          }
-        })
-      )
-    })
-  )
-}
-
-async function ensureEnvVarsDecryptable(variables: Record<string, string>, requestId: string) {
-  for (const [key, encryptedValue] of Object.entries(variables)) {
-    try {
-      await decryptSecret(encryptedValue)
-    } catch (error) {
-      logger.error(`[${requestId}] Failed to decrypt environment variable "${key}"`, error)
-      const message = error instanceof Error ? error.message : 'Unknown error'
-      throw new Error(`Failed to decrypt environment variable "${key}": ${message}`)
-    }
-  }
-}
-
 async function runWorkflowExecution({
   payload,
   workflowRecord,
@@ -217,8 +151,6 @@ async function runWorkflowExecution({
       }
     }
 
-    const mergedStates = mergeSubblockState(blocks)
-
     const workspaceId = workflowRecord.workspaceId
     if (!workspaceId) {
       throw new Error(`Workflow ${payload.workflowId} has no associated workspace`)
@@ -236,9 +168,6 @@ async function runWorkflowExecution({
       ...workspaceEncrypted,
     })
 
-    await ensureBlockVariablesResolvable(mergedStates, variables, requestId)
-    await ensureEnvVarsDecryptable(variables, requestId)
-
     const input = {
       _context: {
         workflowId: payload.workflowId,
@@ -348,6 +277,7 @@ export type ScheduleExecutionPayload = {
   failedCount?: number
   now: string
   scheduledFor?: string
+  preflighted?: boolean
 }
 
 function calculateNextRunTime(
@@ -407,6 +337,7 @@ export async function executeScheduleJob(payload: ScheduleExecutionPayload) {
       checkRateLimit: true,
       checkDeployment: true,
       loggingSession,
+      preflightEnvVars: !payload.preflighted,
     })
 
     if (!preprocessResult.success) {

apps/sim/background/webhook-execution.ts

@@ -12,16 +12,11 @@ import { WebhookAttachmentProcessor } from '@/lib/webhooks/attachment-processor'
 import { fetchAndProcessAirtablePayloads, formatWebhookInput } from '@/lib/webhooks/utils.server'
 import { executeWorkflowCore } from '@/lib/workflows/executor/execution-core'
 import { PauseResumeManager } from '@/lib/workflows/executor/human-in-the-loop-manager'
-import {
-  loadDeployedWorkflowState,
-  loadWorkflowFromNormalizedTables,
-} from '@/lib/workflows/persistence/utils'
+import { loadDeployedWorkflowState } from '@/lib/workflows/persistence/utils'
 import { getWorkflowById } from '@/lib/workflows/utils'
 import { ExecutionSnapshot } from '@/executor/execution/snapshot'
 import type { ExecutionMetadata } from '@/executor/execution/types'
 import type { ExecutionResult } from '@/executor/types'
-import { Serializer } from '@/serializer'
-import { mergeSubblockState } from '@/stores/workflows/server-utils'
 import { getTrigger, isTriggerValid } from '@/triggers'
 
 const logger = createLogger('TriggerWebhookExecution')
@@ -92,7 +87,6 @@ export type WebhookExecutionPayload = {
   headers: Record<string, string>
   path: string
   blockId?: string
-  executionTarget?: 'deployed' | 'live'
   credentialId?: string
   credentialAccountUserId?: string
 }
@@ -143,20 +137,16 @@ async function executeWebhookJobInternal(
   let deploymentVersionId: string | undefined
 
   try {
-    const useDraftState = payload.executionTarget === 'live'
-    const workflowData = useDraftState
-      ? await loadWorkflowFromNormalizedTables(payload.workflowId)
-      : await loadDeployedWorkflowState(payload.workflowId)
+    const workflowData = await loadDeployedWorkflowState(payload.workflowId)
     if (!workflowData) {
       throw new Error(
-        `Workflow state not found. The workflow may not be ${useDraftState ? 'saved' : 'deployed'} or the deployment data may be corrupted.`
+        'Workflow state not found. The workflow may not be deployed or the deployment data may be corrupted.'
       )
     }
 
     const { blocks, edges, loops, parallels } = workflowData
-    // Only deployed executions have a deployment version ID
     deploymentVersionId =
-      !useDraftState && 'deploymentVersionId' in workflowData
+      'deploymentVersionId' in workflowData
         ? (workflowData.deploymentVersionId as string)
         : undefined
 
@@ -171,19 +161,6 @@ async function executeWebhookJobInternal(
     }
     const workflowVariables = (wfRows[0]?.variables as Record<string, any>) || {}
 
-    // Merge subblock states (matching workflow-execution pattern)
-    const mergedStates = mergeSubblockState(blocks)
-
-    // Create serialized workflow
-    const serializer = new Serializer()
-    const serializedWorkflow = serializer.serializeWorkflow(
-      mergedStates,
-      edges,
-      loops || {},
-      parallels || {},
-      true // Enable validation during execution
-    )
-
     // Handle special Airtable case
     if (payload.provider === 'airtable') {
       logger.info(`[${requestId}] Processing Airtable webhook via fetchAndProcessAirtablePayloads`)
@@ -318,7 +295,6 @@ async function executeWebhookJobInternal(
         variables: {},
         triggerData: {
           isTest: false,
-          executionTarget: payload.executionTarget || 'deployed',
         },
         deploymentVersionId,
       })
@@ -376,7 +352,6 @@ async function executeWebhookJobInternal(
         variables: {},
         triggerData: {
           isTest: false,
-          executionTarget: payload.executionTarget || 'deployed',
         },
         deploymentVersionId,
       })
@@ -595,7 +570,6 @@ async function executeWebhookJobInternal(
         variables: {},
         triggerData: {
           isTest: false,
-          executionTarget: payload.executionTarget || 'deployed',
         },
         deploymentVersionId,
       })

apps/sim/background/workflow-execution.ts

@@ -20,6 +20,7 @@ export type WorkflowExecutionPayload = {
   input?: any
   triggerType?: CoreTriggerType
   metadata?: Record<string, any>
+  preflighted?: boolean
 }
 
 /**
@@ -51,6 +52,7 @@ export async function executeWorkflowJob(payload: WorkflowExecutionPayload) {
       checkRateLimit: true,
       checkDeployment: true,
       loggingSession: loggingSession,
+      preflightEnvVars: !payload.preflighted,
     })
 
     if (!preprocessResult.success) {

apps/sim/executor/utils/permission-check.ts

@@ -3,6 +3,7 @@ import { member, permissionGroup, permissionGroupMember } from '@sim/db/schema'
 import { createLogger } from '@sim/logger'
 import { and, eq } from 'drizzle-orm'
 import { isOrganizationOnEnterprisePlan } from '@/lib/billing'
+import { isAccessControlEnabled, isHosted } from '@/lib/core/config/feature-flags'
 import {
   type PermissionGroupConfig,
   parsePermissionGroupConfig,
@@ -52,6 +53,10 @@ export class InvitationsNotAllowedError extends Error {
 export async function getUserPermissionConfig(
   userId: string
 ): Promise<PermissionGroupConfig | null> {
+  if (!isHosted && !isAccessControlEnabled) {
+    return null
+  }
+
   const [membership] = await db
     .select({ organizationId: member.organizationId })
     .from(member)

apps/sim/executor/utils/reference-validation.ts

@@ -19,6 +19,85 @@ export function createEnvVarPattern(): RegExp {
   return new RegExp(`\\${REFERENCE.ENV_VAR_START}([^}]+)\\${REFERENCE.ENV_VAR_END}`, 'g')
 }
 
+export interface EnvVarResolveOptions {
+  allowEmbedded?: boolean
+  resolveExactMatch?: boolean
+  trimKeys?: boolean
+  onMissing?: 'keep' | 'throw' | 'empty'
+  deep?: boolean
+  missingKeys?: string[]
+}
+
+/**
+ * Resolve {{ENV_VAR}} references in values using provided env vars.
+ */
+export function resolveEnvVarReferences(
+  value: unknown,
+  envVars: Record<string, string>,
+  options: EnvVarResolveOptions = {}
+): unknown {
+  const {
+    allowEmbedded = true,
+    resolveExactMatch = true,
+    trimKeys = false,
+    onMissing = 'keep',
+    deep = true,
+  } = options
+
+  if (typeof value === 'string') {
+    if (resolveExactMatch) {
+      const exactMatchPattern = new RegExp(
+        `^\\${REFERENCE.ENV_VAR_START}([^}]+)\\${REFERENCE.ENV_VAR_END}$`
+      )
+      const exactMatch = exactMatchPattern.exec(value)
+      if (exactMatch) {
+        const envKey = trimKeys ? exactMatch[1].trim() : exactMatch[1]
+        const envValue = envVars[envKey]
+        if (envValue !== undefined) return envValue
+        if (options.missingKeys) options.missingKeys.push(envKey)
+        if (onMissing === 'throw') {
+          throw new Error(`Environment variable "${envKey}" was not found`)
+        }
+        if (onMissing === 'empty') {
+          return ''
+        }
+        return value
+      }
+    }
+
+    if (!allowEmbedded) return value
+
+    const envVarPattern = createEnvVarPattern()
+    return value.replace(envVarPattern, (match, varName) => {
+      const envKey = trimKeys ? String(varName).trim() : String(varName)
+      const envValue = envVars[envKey]
+      if (envValue !== undefined) return envValue
+      if (options.missingKeys) options.missingKeys.push(envKey)
+      if (onMissing === 'throw') {
+        throw new Error(`Environment variable "${envKey}" was not found`)
+      }
+      if (onMissing === 'empty') {
+        return ''
+      }
+      return match
+    })
+  }
+
+  if (deep && Array.isArray(value)) {
+    return value.map((item) => resolveEnvVarReferences(item, envVars, options))
+  }
+
+  if (deep && value !== null && typeof value === 'object') {
+    const resolved: Record<string, any> = {}
+    for (const [key, val] of Object.entries(value)) {
+      resolved[key] = resolveEnvVarReferences(val, envVars, options)
+    }
+    return resolved
+  }
+
+  return value
+}
+
 /**
  * Creates a regex pattern for matching workflow variables <variable.name>
  * Captures the variable name (after "variable.") in group 1

apps/sim/hooks/use-collaborative-workflow.ts

@@ -203,6 +203,13 @@ export function useCollaborativeWorkflow() {
             case BLOCK_OPERATIONS.UPDATE_ADVANCED_MODE:
               workflowStore.setBlockAdvancedMode(payload.id, payload.advancedMode)
               break
+            case BLOCK_OPERATIONS.UPDATE_CANONICAL_MODE:
+              workflowStore.setBlockCanonicalMode(
+                payload.id,
+                payload.canonicalId,
+                payload.canonicalMode
+              )
+              break
           }
         } else if (target === OPERATION_TARGETS.BLOCKS) {
           switch (operation) {
@@ -918,16 +925,26 @@ export function useCollaborativeWorkflow() {
 
   const collaborativeToggleBlockAdvancedMode = useCallback(
     (id: string) => {
-      const currentBlock = workflowStore.blocks[id]
-      if (!currentBlock) return
-
-      const newAdvancedMode = !currentBlock.advancedMode
-
+      const block = workflowStore.blocks[id]
+      if (!block) return
+      const newAdvancedMode = !block.advancedMode
       executeQueuedOperation(
         BLOCK_OPERATIONS.UPDATE_ADVANCED_MODE,
         OPERATION_TARGETS.BLOCK,
         { id, advancedMode: newAdvancedMode },
-        () => workflowStore.toggleBlockAdvancedMode(id)
+        () => workflowStore.setBlockAdvancedMode(id, newAdvancedMode)
+      )
+    },
+    [executeQueuedOperation, workflowStore]
+  )
+
+  const collaborativeSetBlockCanonicalMode = useCallback(
+    (id: string, canonicalId: string, canonicalMode: 'basic' | 'advanced') => {
+      executeQueuedOperation(
+        BLOCK_OPERATIONS.UPDATE_CANONICAL_MODE,
+        OPERATION_TARGETS.BLOCK,
+        { id, canonicalId, canonicalMode },
+        () => workflowStore.setBlockCanonicalMode(id, canonicalId, canonicalMode)
       )
     },
     [executeQueuedOperation, workflowStore]
@@ -1607,6 +1624,7 @@ export function useCollaborativeWorkflow() {
     collaborativeBatchToggleBlockEnabled,
     collaborativeBatchUpdateParent,
     collaborativeToggleBlockAdvancedMode,
+    collaborativeSetBlockCanonicalMode,
     collaborativeBatchToggleBlockHandles,
     collaborativeBatchAddBlocks,
     collaborativeBatchRemoveBlocks,

apps/sim/hooks/use-permission-config.ts

@@ -1,5 +1,6 @@
 import { useMemo } from 'react'
 import { getEnv, isTruthy } from '@/lib/core/config/env'
+import { isAccessControlEnabled, isHosted } from '@/lib/core/config/feature-flags'
 import {
   DEFAULT_PERMISSION_GROUP_CONFIG,
   type PermissionGroupConfig,
@@ -19,19 +20,23 @@ export interface PermissionConfigResult {
 }
 
 export function usePermissionConfig(): PermissionConfigResult {
+  const accessControlDisabled = !isHosted && !isAccessControlEnabled
   const { data: organizationsData } = useOrganizations()
   const activeOrganization = organizationsData?.activeOrganization
 
   const { data: permissionData, isLoading } = useUserPermissionConfig(activeOrganization?.id)
 
   const config = useMemo(() => {
+    if (accessControlDisabled) {
+      return DEFAULT_PERMISSION_GROUP_CONFIG
+    }
     if (!permissionData?.config) {
       return DEFAULT_PERMISSION_GROUP_CONFIG
     }
     return permissionData.config
-  }, [permissionData])
+  }, [permissionData, accessControlDisabled])
 
-  const isInPermissionGroup = !!permissionData?.permissionGroupId
+  const isInPermissionGroup = !accessControlDisabled && !!permissionData?.permissionGroupId
 
   const isBlockAllowed = useMemo(() => {
     return (blockType: string) => {

apps/sim/lib/core/utils/response-format.ts

@@ -53,14 +53,25 @@ export function extractFieldsFromSchema(schema: any): Field[] {
  * Helper function to safely parse response format
  * Handles both string and object formats
  */
-export function parseResponseFormatSafely(responseFormatValue: any, blockId: string): any {
+export function parseResponseFormatSafely(
+  responseFormatValue: any,
+  blockId: string,
+  options?: { allowReferences?: boolean }
+): any {
   if (!responseFormatValue) {
     return null
   }
 
+  const allowReferences = options?.allowReferences ?? false
+
   try {
     if (typeof responseFormatValue === 'string') {
-      return JSON.parse(responseFormatValue)
+      const trimmedValue = responseFormatValue.trim()
+      if (trimmedValue === '') return null
+      if (allowReferences && trimmedValue.startsWith('<') && trimmedValue.includes('>')) {
+        return trimmedValue
+      }
+      return JSON.parse(trimmedValue)
     }
     return responseFormatValue
   } catch (error) {

apps/sim/lib/environment/utils.ts

@@ -3,6 +3,9 @@ import { environment, workspaceEnvironment } from '@sim/db/schema'
 import { createLogger } from '@sim/logger'
 import { eq } from 'drizzle-orm'
 import { decryptSecret } from '@/lib/core/security/encryption'
+import { REFERENCE } from '@/executor/constants'
+import { createEnvVarPattern } from '@/executor/utils/reference-validation'
+import type { BlockState } from '@/stores/workflows/workflow/types'
 
 const logger = createLogger('EnvironmentUtils')
 
@@ -107,3 +110,86 @@ export async function getEffectiveDecryptedEnv(
   )
   return { ...personalDecrypted, ...workspaceDecrypted }
 }
+
+/**
+ * Ensure all environment variables can be decrypted.
+ */
+export async function ensureEnvVarsDecryptable(
+  variables: Record<string, string>,
+  options: { requestId?: string } = {}
+): Promise<void> {
+  const requestId = options.requestId
+  for (const [key, encryptedValue] of Object.entries(variables)) {
+    try {
+      await decryptSecret(encryptedValue)
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Unknown error'
+      if (requestId) {
+        logger.error(`[${requestId}] Failed to decrypt environment variable "${key}"`, error)
+      } else {
+        logger.error(`Failed to decrypt environment variable "${key}"`, error)
+      }
+      throw new Error(`Failed to decrypt environment variable "${key}": ${message}`)
+    }
+  }
+}
+
+/**
+ * Ensure all {{ENV_VAR}} references in block subblocks resolve to decryptable values.
+ */
+export async function ensureBlockEnvVarsResolvable(
+  blocks: Record<string, BlockState>,
+  variables: Record<string, string>,
+  options: { requestId?: string } = {}
+): Promise<void> {
+  const requestId = options.requestId
+  await Promise.all(
+    Object.values(blocks).map(async (block) => {
+      const subBlocks = block.subBlocks ?? {}
+      await Promise.all(
+        Object.values(subBlocks).map(async (subBlock) => {
+          const value = subBlock.value
+          if (
+            typeof value !== 'string' ||
+            !value.includes(REFERENCE.ENV_VAR_START) ||
+            !value.includes(REFERENCE.ENV_VAR_END)
+          ) {
+            return
+          }
+
+          const envVarPattern = createEnvVarPattern()
+          const matches = value.match(envVarPattern)
+          if (!matches) {
+            return
+          }
+
+          for (const match of matches) {
+            const varName = match.slice(
+              REFERENCE.ENV_VAR_START.length,
+              -REFERENCE.ENV_VAR_END.length
+            )
+            const encryptedValue = variables[varName]
+            if (!encryptedValue) {
+              throw new Error(`Environment variable "${varName}" was not found`)
+            }
+
+            try {
+              await decryptSecret(encryptedValue)
+            } catch (error) {
+              const message = error instanceof Error ? error.message : 'Unknown error'
+              if (requestId) {
+                logger.error(
+                  `[${requestId}] Error decrypting value for variable "${varName}"`,
+                  error
+                )
+              } else {
+                logger.error(`Error decrypting value for variable "${varName}"`, error)
+              }
+              throw new Error(`Failed to decrypt environment variable "${varName}": ${message}`)
+            }
+          }
+        })
+      )
+    })
+  )
+}

apps/sim/lib/execution/preprocessing.ts

@@ -6,6 +6,7 @@ import { checkServerSideUsageLimits } from '@/lib/billing/calculations/usage-mon
 import { getHighestPrioritySubscription } from '@/lib/billing/core/subscription'
 import { RateLimiter } from '@/lib/core/rate-limiter/rate-limiter'
 import { LoggingSession } from '@/lib/logs/execution/logging-session'
+import { preflightWorkflowEnvVars } from '@/lib/workflows/executor/preflight'
 import { getWorkspaceBilledAccountUserId } from '@/lib/workspaces/utils'
 import type { CoreTriggerType } from '@/stores/logs/filters/types'
 
@@ -117,11 +118,15 @@ export interface PreprocessExecutionOptions {
   checkRateLimit?: boolean // Default: false for manual/chat, true for others
   checkDeployment?: boolean // Default: true for non-manual triggers
   skipUsageLimits?: boolean // Default: false (only use for test mode)
+  preflightEnvVars?: boolean // Default: false
 
   // Context information
   workspaceId?: string // If known, used for billing resolution
   loggingSession?: LoggingSession // If provided, will be used for error logging
   isResumeContext?: boolean // If true, allows fallback billing on resolution failure (for paused workflow resumes)
+  /** @deprecated No longer used - preflight always uses deployed state */
+  useDraftState?: boolean
+  envUserId?: string // Optional override for env var resolution user
 }
 
 /**
@@ -159,9 +164,11 @@ export async function preprocessExecution(
     checkRateLimit = triggerType !== 'manual' && triggerType !== 'chat',
     checkDeployment = triggerType !== 'manual',
     skipUsageLimits = false,
+    preflightEnvVars = false,
     workspaceId: providedWorkspaceId,
     loggingSession: providedLoggingSession,
     isResumeContext = false,
+    envUserId,
   } = options
 
   logger.info(`[${requestId}] Starting execution preprocessing`, {
@@ -476,6 +483,44 @@ export async function preprocessExecution(
   }
 
   // ========== SUCCESS: All Checks Passed ==========
+  if (preflightEnvVars) {
+    try {
+      const resolvedEnvUserId = envUserId || workflowRecord.userId || userId
+      await preflightWorkflowEnvVars({
+        workflowId,
+        workspaceId,
+        envUserId: resolvedEnvUserId,
+        requestId,
+      })
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Env var preflight failed'
+      logger.warn(`[${requestId}] Env var preflight failed`, {
+        workflowId,
+        message,
+      })
+
+      await logPreprocessingError({
+        workflowId,
+        executionId,
+        triggerType,
+        requestId,
+        userId: actorUserId,
+        workspaceId,
+        errorMessage: message,
+        loggingSession: providedLoggingSession,
+      })
+
+      return {
+        success: false,
+        error: {
+          message,
+          statusCode: 400,
+          logCreated: true,
+        },
+      }
+    }
+  }
+
   logger.info(`[${requestId}] All preprocessing checks passed`, {
     workflowId,
     actorUserId,

apps/sim/lib/mcp/service.ts

@@ -25,8 +25,7 @@ import type {
   McpTransport,
 } from '@/lib/mcp/types'
 import { MCP_CONSTANTS } from '@/lib/mcp/utils'
-import { REFERENCE } from '@/executor/constants'
-import { createEnvVarPattern } from '@/executor/utils/reference-validation'
+import { resolveEnvVarReferences } from '@/executor/utils/reference-validation'
 
 const logger = createLogger('McpService')
 
@@ -51,31 +50,21 @@ class McpService {
    * Resolve environment variables in strings
    */
   private resolveEnvVars(value: string, envVars: Record<string, string>): string {
-    const envVarPattern = createEnvVarPattern()
-    const envMatches = value.match(envVarPattern)
-    if (!envMatches) return value
-
-    let resolvedValue = value
     const missingVars: string[] = []
-
-    for (const match of envMatches) {
-      const envKey = match
-        .slice(REFERENCE.ENV_VAR_START.length, -REFERENCE.ENV_VAR_END.length)
-        .trim()
-      const envValue = envVars[envKey]
-
-      if (envValue === undefined) {
-        missingVars.push(envKey)
-        continue
-      }
-
-      resolvedValue = resolvedValue.replace(match, envValue)
-    }
+    const resolvedValue = resolveEnvVarReferences(value, envVars, {
+      allowEmbedded: true,
+      resolveExactMatch: true,
+      trimKeys: true,
+      onMissing: 'keep',
+      deep: false,
+      missingKeys: missingVars,
+    }) as string
 
     if (missingVars.length > 0) {
+      const uniqueMissing = Array.from(new Set(missingVars))
       throw new Error(
-        `Missing required environment variable${missingVars.length > 1 ? 's' : ''}: ${missingVars.join(', ')}. ` +
-          `Please set ${missingVars.length > 1 ? 'these variables' : 'this variable'} in your workspace or personal environment settings.`
+        `Missing required environment variable${uniqueMissing.length > 1 ? 's' : ''}: ${uniqueMissing.join(', ')}. ` +
+          `Please set ${uniqueMissing.length > 1 ? 'these variables' : 'this variable'} in your workspace or personal environment settings.`
       )
     }
 

apps/sim/lib/webhooks/processor.ts

@@ -16,8 +16,7 @@ import {
   verifyProviderWebhook,
 } from '@/lib/webhooks/utils.server'
 import { executeWebhookJob } from '@/background/webhook-execution'
-import { REFERENCE } from '@/executor/constants'
-import { createEnvVarPattern } from '@/executor/utils/reference-validation'
+import { resolveEnvVarReferences } from '@/executor/utils/reference-validation'
 
 const logger = createLogger('WebhookProcessor')
 
@@ -25,7 +24,6 @@ export interface WebhookProcessorOptions {
   requestId: string
   path?: string
   webhookId?: string
-  executionTarget?: 'deployed' | 'live'
 }
 
 function getExternalUrl(request: NextRequest): string {
@@ -353,19 +351,13 @@ export async function findAllWebhooksForPath(
  * @returns String with all {{VARIABLE}} references replaced
  */
 function resolveEnvVars(value: string, envVars: Record<string, string>): string {
-  const envVarPattern = createEnvVarPattern()
-  const envMatches = value.match(envVarPattern)
-  if (!envMatches) return value
-
-  let resolvedValue = value
-  for (const match of envMatches) {
-    const envKey = match.slice(REFERENCE.ENV_VAR_START.length, -REFERENCE.ENV_VAR_END.length).trim()
-    const envValue = envVars[envKey]
-    if (envValue !== undefined) {
-      resolvedValue = resolvedValue.replaceAll(match, envValue)
-    }
-  }
-  return resolvedValue
+  return resolveEnvVarReferences(value, envVars, {
+    allowEmbedded: true,
+    resolveExactMatch: true,
+    trimKeys: true,
+    onMissing: 'keep',
+    deep: false,
+  }) as string
 }
 
 /**
@@ -750,6 +742,7 @@ export async function checkWebhookPreprocessing(
       checkRateLimit: true,
       checkDeployment: true,
       workspaceId: foundWorkflow.workspaceId,
+      preflightEnvVars: isTriggerDevEnabled,
     })
 
     if (!preprocessResult.success) {
@@ -948,7 +941,6 @@ export async function queueWebhookExecution(
       headers,
       path: options.path || foundWebhook.path,
       blockId: foundWebhook.blockId,
-      executionTarget: options.executionTarget,
       ...(credentialId ? { credentialId } : {}),
     }
 

apps/sim/lib/workflows/credentials/credential-extractor.ts

@@ -1,16 +1,17 @@
+import {
+  buildCanonicalIndex,
+  buildSubBlockValues,
+  evaluateSubBlockCondition,
+  hasAdvancedValues,
+  isSubBlockFeatureEnabled,
+  isSubBlockVisibleForMode,
+  type SubBlockCondition,
+} from '@/lib/workflows/subblocks/visibility'
 import { getBlock } from '@/blocks/registry'
 import type { SubBlockConfig } from '@/blocks/types'
 import { AuthMode } from '@/blocks/types'
 import type { BlockState, SubBlockState, WorkflowState } from '@/stores/workflows/workflow/types'
 
-/** Condition type for SubBlock visibility - mirrors the inline type from blocks/types.ts */
-interface SubBlockCondition {
-  field: string
-  value: string | number | boolean | Array<string | number | boolean> | undefined
-  not?: boolean
-  and?: SubBlockCondition
-}
-
 // Credential types based on actual patterns in the codebase
 export enum CredentialType {
   OAUTH = 'oauth',
@@ -117,36 +118,32 @@ export function extractRequiredCredentials(
 
   /** Helper to check visibility, respecting mode and conditions */
   function isSubBlockVisible(block: BlockState, subBlockConfig: SubBlockConfig): boolean {
-    const mode = subBlockConfig.mode ?? 'both'
-    if (mode === 'trigger' && !block?.triggerMode) return false
-    if (mode === 'basic' && block?.advancedMode) return false
-    if (mode === 'advanced' && !block?.advancedMode) return false
+    if (!isSubBlockFeatureEnabled(subBlockConfig)) return false
 
-    if (!subBlockConfig.condition) return true
+    const values = buildSubBlockValues(block?.subBlocks || {})
+    const blockConfig = getBlock(block.type)
+    const blockSubBlocks = blockConfig?.subBlocks || []
+    const canonicalIndex = buildCanonicalIndex(blockSubBlocks)
+    const effectiveAdvanced =
+      (block?.advancedMode ?? false) || hasAdvancedValues(blockSubBlocks, values, canonicalIndex)
+    const canonicalModeOverrides = block.data?.canonicalModes
 
-    const condition =
-      typeof subBlockConfig.condition === 'function'
-        ? subBlockConfig.condition()
-        : subBlockConfig.condition
+    if (subBlockConfig.mode === 'trigger' && !block?.triggerMode) return false
+    if (block?.triggerMode && subBlockConfig.mode && subBlockConfig.mode !== 'trigger') return false
 
-    const evaluate = (cond: SubBlockCondition): boolean => {
-      const currentValue = block?.subBlocks?.[cond.field]?.value
-      const expected = cond.value
-
-      let match =
-        expected === undefined
-          ? true
-          : Array.isArray(expected)
-            ? expected.includes(currentValue as string)
-            : currentValue === expected
-
-      if (cond.not) match = !match
-      if (cond.and) match = match && evaluate(cond.and)
-
-      return match
+    if (
+      !isSubBlockVisibleForMode(
+        subBlockConfig,
+        effectiveAdvanced,
+        canonicalIndex,
+        values,
+        canonicalModeOverrides
+      )
+    ) {
+      return false
     }
 
-    return evaluate(condition)
+    return evaluateSubBlockCondition(subBlockConfig.condition as SubBlockCondition, values)
   }
 
   // Sort: OAuth first, then secrets, alphabetically within each type

apps/sim/lib/workflows/executor/execution-core.ts

@@ -6,6 +6,7 @@
 import { createLogger } from '@sim/logger'
 import type { Edge } from 'reactflow'
 import { z } from 'zod'
+import { parseResponseFormatSafely } from '@/lib/core/utils/response-format'
 import { getPersonalAndWorkspaceEnv } from '@/lib/environment/utils'
 import { clearExecutionCancellation } from '@/lib/execution/cancellation'
 import type { LoggingSession } from '@/lib/logs/execution/logging-session'
@@ -17,7 +18,6 @@ import {
 import { TriggerUtils } from '@/lib/workflows/triggers/triggers'
 import { updateWorkflowRunCounts } from '@/lib/workflows/utils'
 import { Executor } from '@/executor'
-import { REFERENCE } from '@/executor/constants'
 import type { ExecutionSnapshot } from '@/executor/execution/snapshot'
 import type {
   ContextExtensions,
@@ -25,7 +25,7 @@ import type {
   IterationContext,
 } from '@/executor/execution/types'
 import type { ExecutionResult, NormalizedBlockOutput } from '@/executor/types'
-import { createEnvVarPattern } from '@/executor/utils/reference-validation'
+import { resolveEnvVarReferences } from '@/executor/utils/reference-validation'
 import { Serializer } from '@/serializer'
 import { mergeSubblockState } from '@/stores/workflows/server-utils'
 
@@ -203,25 +203,13 @@ export async function executeWorkflowCore(
           (subAcc, [key, subBlock]) => {
             let value = subBlock.value
 
-            if (
-              typeof value === 'string' &&
-              value.includes(REFERENCE.ENV_VAR_START) &&
-              value.includes(REFERENCE.ENV_VAR_END)
-            ) {
-              const envVarPattern = createEnvVarPattern()
-              const matches = value.match(envVarPattern)
-              if (matches) {
-                for (const match of matches) {
-                  const varName = match.slice(
-                    REFERENCE.ENV_VAR_START.length,
-                    -REFERENCE.ENV_VAR_END.length
-                  )
-                  const decryptedValue = decryptedEnvVars[varName]
-                  if (decryptedValue !== undefined) {
-                    value = (value as string).replace(match, decryptedValue)
-                  }
-                }
-              }
+            if (typeof value === 'string') {
+              value = resolveEnvVarReferences(value, decryptedEnvVars, {
+                resolveExactMatch: false,
+                trimKeys: false,
+                onMissing: 'keep',
+                deep: false,
+              }) as string
             }
 
             subAcc[key] = value
@@ -237,26 +225,16 @@ export async function executeWorkflowCore(
     // Process response format
     const processedBlockStates = Object.entries(currentBlockStates).reduce(
       (acc, [blockId, blockState]) => {
-        if (blockState.responseFormat && typeof blockState.responseFormat === 'string') {
-          const responseFormatValue = blockState.responseFormat.trim()
-          if (responseFormatValue && !responseFormatValue.startsWith(REFERENCE.START)) {
-            try {
-              acc[blockId] = {
-                ...blockState,
-                responseFormat: JSON.parse(responseFormatValue),
-              }
-            } catch {
-              acc[blockId] = {
-                ...blockState,
-                responseFormat: undefined,
-              }
-            }
-          } else {
-            acc[blockId] = blockState
-          }
-        } else {
+        const responseFormatValue = blockState.responseFormat
+        if (responseFormatValue === undefined || responseFormatValue === null) {
           acc[blockId] = blockState
+          return acc
         }
+
+        const responseFormat = parseResponseFormatSafely(responseFormatValue, blockId, {
+          allowReferences: true,
+        })
+        acc[blockId] = { ...blockState, responseFormat: responseFormat ?? undefined }
         return acc
       },
       {} as Record<string, Record<string, any>>

apps/sim/lib/workflows/executor/preflight.ts

@@ -0,0 +1,51 @@
+import { createLogger } from '@sim/logger'
+import {
+  ensureBlockEnvVarsResolvable,
+  ensureEnvVarsDecryptable,
+  getPersonalAndWorkspaceEnv,
+} from '@/lib/environment/utils'
+import { loadDeployedWorkflowState } from '@/lib/workflows/persistence/utils'
+import { mergeSubblockState } from '@/stores/workflows/server-utils'
+
+const logger = createLogger('ExecutionPreflight')
+
+export interface EnvVarPreflightOptions {
+  workflowId: string
+  workspaceId: string
+  envUserId: string
+  requestId?: string
+}
+
+/**
+ * Preflight env var checks to avoid scheduling executions that will fail.
+ * Always uses deployed workflow state since preflight is only done for async
+ * executions which always run on deployed state.
+ */
+export async function preflightWorkflowEnvVars({
+  workflowId,
+  workspaceId,
+  envUserId,
+  requestId,
+}: EnvVarPreflightOptions): Promise<void> {
+  const workflowData = await loadDeployedWorkflowState(workflowId)
+
+  if (!workflowData) {
+    throw new Error('Workflow state not found')
+  }
+
+  const mergedStates = mergeSubblockState(workflowData.blocks)
+  const { personalEncrypted, workspaceEncrypted } = await getPersonalAndWorkspaceEnv(
+    envUserId,
+    workspaceId
+  )
+  const variables = { ...personalEncrypted, ...workspaceEncrypted }
+
+  await ensureBlockEnvVarsResolvable(mergedStates, variables, { requestId })
+  await ensureEnvVarsDecryptable(variables, { requestId })
+
+  if (requestId) {
+    logger.debug(`[${requestId}] Env var preflight passed`, { workflowId })
+  } else {
+    logger.debug('Env var preflight passed', { workflowId })
+  }
+}

apps/sim/lib/workflows/subblocks/visibility.ts

@@ -0,0 +1,269 @@
+import { getEnv, isTruthy } from '@/lib/core/config/env'
+import type { SubBlockConfig } from '@/blocks/types'
+
+export type CanonicalMode = 'basic' | 'advanced'
+
+export interface CanonicalGroup {
+  canonicalId: string
+  basicId?: string
+  advancedIds: string[]
+}
+
+export interface CanonicalIndex {
+  groupsById: Record<string, CanonicalGroup>
+  canonicalIdBySubBlockId: Record<string, string>
+}
+
+export interface SubBlockCondition {
+  field: string
+  value: string | number | boolean | Array<string | number | boolean> | undefined
+  not?: boolean
+  and?: SubBlockCondition
+}
+
+export interface CanonicalModeOverrides {
+  [canonicalId: string]: CanonicalMode | undefined
+}
+
+export interface CanonicalValueSelection {
+  basicValue: unknown
+  advancedValue: unknown
+  advancedSourceId?: string
+}
+
+/**
+ * Build a flat map of subblock values keyed by subblock id.
+ */
+export function buildSubBlockValues(
+  subBlocks: Record<string, { value?: unknown } | null | undefined>
+): Record<string, unknown> {
+  return Object.entries(subBlocks).reduce<Record<string, unknown>>((acc, [key, subBlock]) => {
+    acc[key] = subBlock?.value
+    return acc
+  }, {})
+}
+
+/**
+ * Build canonical group indices for a block's subblocks.
+ */
+export function buildCanonicalIndex(subBlocks: SubBlockConfig[]): CanonicalIndex {
+  const groupsById: Record<string, CanonicalGroup> = {}
+  const canonicalIdBySubBlockId: Record<string, string> = {}
+
+  subBlocks.forEach((subBlock) => {
+    if (!subBlock.canonicalParamId) return
+    const canonicalId = subBlock.canonicalParamId
+    if (!groupsById[canonicalId]) {
+      groupsById[canonicalId] = { canonicalId, advancedIds: [] }
+    }
+    const group = groupsById[canonicalId]
+    if (subBlock.mode === 'advanced') {
+      group.advancedIds.push(subBlock.id)
+    } else {
+      group.basicId = subBlock.id
+    }
+    canonicalIdBySubBlockId[subBlock.id] = canonicalId
+  })
+
+  return { groupsById, canonicalIdBySubBlockId }
+}
+
+/**
+ * Resolve if a canonical group is a swap pair (basic + advanced).
+ */
+export function isCanonicalPair(group?: CanonicalGroup): boolean {
+  return Boolean(group?.basicId && group?.advancedIds?.length)
+}
+
+/**
+ * Determine the active mode for a canonical group.
+ */
+export function resolveCanonicalMode(
+  group: CanonicalGroup,
+  values: Record<string, unknown>,
+  overrides?: CanonicalModeOverrides
+): CanonicalMode {
+  const override = overrides?.[group.canonicalId]
+  if (override === 'advanced' && group.advancedIds.length > 0) return 'advanced'
+  if (override === 'basic' && group.basicId) return 'basic'
+
+  const { basicValue, advancedValue } = getCanonicalValues(group, values)
+  const hasBasic = isNonEmptyValue(basicValue)
+  const hasAdvanced = isNonEmptyValue(advancedValue)
+
+  if (!group.basicId) return 'advanced'
+  if (!hasBasic && hasAdvanced) return 'advanced'
+  return 'basic'
+}
+
+/**
+ * Evaluate a subblock condition against a map of raw values.
+ */
+export function evaluateSubBlockCondition(
+  condition: SubBlockCondition | (() => SubBlockCondition) | undefined,
+  values: Record<string, unknown>
+): boolean {
+  if (!condition) return true
+  const actual = typeof condition === 'function' ? condition() : condition
+  const fieldValue = values[actual.field]
+  const valueMatch = Array.isArray(actual.value)
+    ? fieldValue != null &&
+      (actual.not
+        ? !actual.value.includes(fieldValue as any)
+        : actual.value.includes(fieldValue as any))
+    : actual.not
+      ? fieldValue !== actual.value
+      : fieldValue === actual.value
+  const andMatch = !actual.and
+    ? true
+    : (() => {
+        const andFieldValue = values[actual.and!.field]
+        const andValueMatch = Array.isArray(actual.and!.value)
+          ? andFieldValue != null &&
+            (actual.and!.not
+              ? !actual.and!.value.includes(andFieldValue as any)
+              : actual.and!.value.includes(andFieldValue as any))
+          : actual.and!.not
+            ? andFieldValue !== actual.and!.value
+            : andFieldValue === actual.and!.value
+        return andValueMatch
+      })()
+
+  return valueMatch && andMatch
+}
+
+/**
+ * Check if a value is considered set for advanced visibility/selection.
+ */
+export function isNonEmptyValue(value: unknown): boolean {
+  if (value === null || value === undefined) return false
+  if (typeof value === 'string') return value.trim().length > 0
+  if (Array.isArray(value)) return value.length > 0
+  return true
+}
+
+/**
+ * Resolve basic and advanced values for a canonical group.
+ */
+export function getCanonicalValues(
+  group: CanonicalGroup,
+  values: Record<string, unknown>
+): CanonicalValueSelection {
+  const basicValue = group.basicId ? values[group.basicId] : undefined
+  let advancedValue: unknown
+  let advancedSourceId: string | undefined
+
+  group.advancedIds.forEach((advancedId) => {
+    if (advancedValue !== undefined) return
+    const candidate = values[advancedId]
+    if (isNonEmptyValue(candidate)) {
+      advancedValue = candidate
+      advancedSourceId = advancedId
+    }
+  })
+
+  return { basicValue, advancedValue, advancedSourceId }
+}
+
+/**
+ * Check if a block has any standalone advanced-only fields (not part of canonical pairs).
+ * These require the block-level advanced mode toggle to be visible.
+ */
+export function hasStandaloneAdvancedFields(
+  subBlocks: SubBlockConfig[],
+  canonicalIndex: CanonicalIndex
+): boolean {
+  for (const subBlock of subBlocks) {
+    if (subBlock.mode !== 'advanced') continue
+    if (!canonicalIndex.canonicalIdBySubBlockId[subBlock.id]) return true
+  }
+  return false
+}
+
+/**
+ * Check if any advanced-only or canonical advanced values are present.
+ */
+export function hasAdvancedValues(
+  subBlocks: SubBlockConfig[],
+  values: Record<string, unknown>,
+  canonicalIndex: CanonicalIndex
+): boolean {
+  const checkedCanonical = new Set<string>()
+
+  for (const subBlock of subBlocks) {
+    const canonicalId = canonicalIndex.canonicalIdBySubBlockId[subBlock.id]
+    if (canonicalId) {
+      const group = canonicalIndex.groupsById[canonicalId]
+      if (group && isCanonicalPair(group) && !checkedCanonical.has(canonicalId)) {
+        checkedCanonical.add(canonicalId)
+        const { advancedValue } = getCanonicalValues(group, values)
+        if (isNonEmptyValue(advancedValue)) return true
+      }
+      continue
+    }
+
+    if (subBlock.mode === 'advanced' && isNonEmptyValue(values[subBlock.id])) {
+      return true
+    }
+  }
+
+  return false
+}
+
+/**
+ * Determine whether a subblock is visible based on mode and canonical swaps.
+ */
+export function isSubBlockVisibleForMode(
+  subBlock: SubBlockConfig,
+  displayAdvancedOptions: boolean,
+  canonicalIndex: CanonicalIndex,
+  values: Record<string, unknown>,
+  overrides?: CanonicalModeOverrides
+): boolean {
+  const canonicalId = canonicalIndex.canonicalIdBySubBlockId[subBlock.id]
+  const group = canonicalId ? canonicalIndex.groupsById[canonicalId] : undefined
+
+  if (group && isCanonicalPair(group)) {
+    const mode = resolveCanonicalMode(group, values, overrides)
+    if (mode === 'advanced') return group.advancedIds.includes(subBlock.id)
+    return group.basicId === subBlock.id
+  }
+
+  if (subBlock.mode === 'basic' && displayAdvancedOptions) return false
+  if (subBlock.mode === 'advanced' && !displayAdvancedOptions) return false
+  return true
+}
+
+/**
+ * Resolve the dependency value for a dependsOn key, honoring canonical swaps.
+ */
+export function resolveDependencyValue(
+  dependencyKey: string,
+  values: Record<string, unknown>,
+  canonicalIndex: CanonicalIndex,
+  overrides?: CanonicalModeOverrides
+): unknown {
+  const canonicalId =
+    canonicalIndex.groupsById[dependencyKey]?.canonicalId ||
+    canonicalIndex.canonicalIdBySubBlockId[dependencyKey]
+
+  if (!canonicalId) {
+    return values[dependencyKey]
+  }
+
+  const group = canonicalIndex.groupsById[canonicalId]
+  if (!group) return values[dependencyKey]
+
+  const { basicValue, advancedValue } = getCanonicalValues(group, values)
+  const mode = resolveCanonicalMode(group, values, overrides)
+  if (mode === 'advanced') return advancedValue ?? basicValue
+  return basicValue ?? advancedValue
+}
+
+/**
+ * Check if a subblock is gated by a feature flag.
+ */
+export function isSubBlockFeatureEnabled(subBlock: SubBlockConfig): boolean {
+  if (!subBlock.requiresFeature) return true
+  return isTruthy(getEnv(subBlock.requiresFeature))
+}

apps/sim/serializer/index.test.ts

@@ -515,103 +515,131 @@ describe('Serializer', () => {
     })
   })
 
-  /**
-   * Advanced mode field filtering tests
-   */
-  describe('advanced mode field filtering', () => {
-    it.concurrent('should include all fields when block is in advanced mode', () => {
+  describe('canonical mode field selection', () => {
+    it.concurrent('should use advanced value when canonicalModes specifies advanced', () => {
       const serializer = new Serializer()
 
-      const advancedModeBlock: any = {
+      const block: any = {
         id: 'slack-1',
         type: 'slack',
         name: 'Test Slack Block',
         position: { x: 0, y: 0 },
-        advancedMode: true, // Advanced mode enabled
+        data: {
+          canonicalModes: { channel: 'advanced' },
+        },
         subBlocks: {
-          channel: { value: 'general' }, // basic mode field
-          manualChannel: { value: 'C1234567890' }, // advanced mode field
-          text: { value: 'Hello world' }, // both mode field
-          username: { value: 'bot' }, // both mode field
+          operation: { value: 'send' },
+          destinationType: { value: 'channel' },
+          channel: { value: 'general' },
+          manualChannel: { value: 'C1234567890' },
+          text: { value: 'Hello world' },
+          username: { value: 'bot' },
         },
         outputs: {},
         enabled: true,
       }
 
-      const serialized = serializer.serializeWorkflow({ 'slack-1': advancedModeBlock }, [], {})
-
+      const serialized = serializer.serializeWorkflow({ 'slack-1': block }, [], {})
       const slackBlock = serialized.blocks.find((b) => b.id === 'slack-1')
-      expect(slackBlock).toBeDefined()
 
-      expect(slackBlock?.config.params.channel).toBe('general')
-      expect(slackBlock?.config.params.manualChannel).toBe('C1234567890')
+      expect(slackBlock).toBeDefined()
+      expect(slackBlock?.config.params.channel).toBe('C1234567890')
+      expect(slackBlock?.config.params.manualChannel).toBeUndefined()
       expect(slackBlock?.config.params.text).toBe('Hello world')
       expect(slackBlock?.config.params.username).toBe('bot')
     })
 
-    it.concurrent('should exclude advanced-only fields when block is in basic mode', () => {
+    it.concurrent('should use basic value when canonicalModes specifies basic', () => {
       const serializer = new Serializer()
 
-      const basicModeBlock: any = {
+      const block: any = {
         id: 'slack-1',
         type: 'slack',
         name: 'Test Slack Block',
         position: { x: 0, y: 0 },
-        advancedMode: false, // Basic mode enabled
+        data: {
+          canonicalModes: { channel: 'basic' },
+        },
         subBlocks: {
-          channel: { value: 'general' }, // basic mode field
-          manualChannel: { value: 'C1234567890' }, // advanced mode field
-          text: { value: 'Hello world' }, // both mode field
-          username: { value: 'bot' }, // both mode field
+          operation: { value: 'send' },
+          destinationType: { value: 'channel' },
+          channel: { value: 'general' },
+          manualChannel: { value: 'C1234567890' },
+          text: { value: 'Hello world' },
+          username: { value: 'bot' },
         },
         outputs: {},
         enabled: true,
       }
 
-      const serialized = serializer.serializeWorkflow({ 'slack-1': basicModeBlock }, [], {})
-
+      const serialized = serializer.serializeWorkflow({ 'slack-1': block }, [], {})
       const slackBlock = serialized.blocks.find((b) => b.id === 'slack-1')
-      expect(slackBlock).toBeDefined()
 
+      expect(slackBlock).toBeDefined()
       expect(slackBlock?.config.params.channel).toBe('general')
       expect(slackBlock?.config.params.manualChannel).toBeUndefined()
       expect(slackBlock?.config.params.text).toBe('Hello world')
       expect(slackBlock?.config.params.username).toBe('bot')
     })
 
-    it.concurrent(
-      'should exclude advanced-only fields when advancedMode is undefined (defaults to basic mode)',
-      () => {
-        const serializer = new Serializer()
+    it.concurrent('should fall back to legacy advancedMode when canonicalModes not set', () => {
+      const serializer = new Serializer()
 
-        const defaultModeBlock: any = {
-          id: 'slack-1',
-          type: 'slack',
-          name: 'Test Slack Block',
-          position: { x: 0, y: 0 },
-          subBlocks: {
-            channel: { value: 'general' },
-            manualChannel: { value: 'C1234567890' },
-            text: { value: 'Hello world' },
-            username: { value: 'bot' },
-          },
-          outputs: {},
-          enabled: true,
-        }
-
-        const serialized = serializer.serializeWorkflow({ 'slack-1': defaultModeBlock }, [], {})
-
-        const slackBlock = serialized.blocks.find((b) => b.id === 'slack-1')
-        expect(slackBlock).toBeDefined()
-
-        expect(slackBlock?.config.params.channel).toBe('general')
-        expect(slackBlock?.config.params.manualChannel).toBeUndefined()
-        expect(slackBlock?.config.params.text).toBe('Hello world')
-        expect(slackBlock?.config.params.username).toBe('bot')
+      const block: any = {
+        id: 'slack-1',
+        type: 'slack',
+        name: 'Test Slack Block',
+        position: { x: 0, y: 0 },
+        advancedMode: true,
+        subBlocks: {
+          operation: { value: 'send' },
+          destinationType: { value: 'channel' },
+          channel: { value: 'general' },
+          manualChannel: { value: 'C1234567890' },
+          text: { value: 'Hello world' },
+          username: { value: 'bot' },
+        },
+        outputs: {},
+        enabled: true,
       }
-    )
 
-    it.concurrent('should filter memories field correctly in agent blocks', () => {
+      const serialized = serializer.serializeWorkflow({ 'slack-1': block }, [], {})
+      const slackBlock = serialized.blocks.find((b) => b.id === 'slack-1')
+
+      expect(slackBlock).toBeDefined()
+      expect(slackBlock?.config.params.channel).toBe('C1234567890')
+      expect(slackBlock?.config.params.manualChannel).toBeUndefined()
+    })
+
+    it.concurrent('should use basic value by default when no mode specified', () => {
+      const serializer = new Serializer()
+
+      const block: any = {
+        id: 'slack-1',
+        type: 'slack',
+        name: 'Test Slack Block',
+        position: { x: 0, y: 0 },
+        subBlocks: {
+          operation: { value: 'send' },
+          destinationType: { value: 'channel' },
+          channel: { value: 'general' },
+          manualChannel: { value: 'C1234567890' },
+          text: { value: 'Hello world' },
+          username: { value: 'bot' },
+        },
+        outputs: {},
+        enabled: true,
+      }
+
+      const serialized = serializer.serializeWorkflow({ 'slack-1': block }, [], {})
+      const slackBlock = serialized.blocks.find((b) => b.id === 'slack-1')
+
+      expect(slackBlock).toBeDefined()
+      expect(slackBlock?.config.params.channel).toBe('general')
+      expect(slackBlock?.config.params.manualChannel).toBeUndefined()
+    })
+
+    it.concurrent('should preserve advanced-only values when present in basic mode', () => {
       const serializer = new Serializer()
 
       const agentInBasicMode: any = {
@@ -637,7 +665,9 @@ describe('Serializer', () => {
 
       expect(agentBlock?.config.params.systemPrompt).toBe('You are helpful')
       expect(agentBlock?.config.params.userPrompt).toBe('Hello')
-      expect(agentBlock?.config.params.memories).toBeUndefined()
+      expect(agentBlock?.config.params.memories).toEqual([
+        { role: 'user', content: 'My name is John' },
+      ])
       expect(agentBlock?.config.params.model).toBe('claude-3-sonnet')
     })
 

apps/sim/serializer/index.ts

@@ -1,9 +1,17 @@
 import { createLogger } from '@sim/logger'
 import type { Edge } from 'reactflow'
+import { parseResponseFormatSafely } from '@/lib/core/utils/response-format'
 import { BlockPathCalculator } from '@/lib/workflows/blocks/block-path-calculator'
+import {
+  buildCanonicalIndex,
+  buildSubBlockValues,
+  evaluateSubBlockCondition,
+  getCanonicalValues,
+  isNonEmptyValue,
+  isSubBlockFeatureEnabled,
+} from '@/lib/workflows/subblocks/visibility'
 import { getBlock } from '@/blocks'
 import type { SubBlockConfig } from '@/blocks/types'
-import { REFERENCE } from '@/executor/constants'
 import type { SerializedBlock, SerializedWorkflow } from '@/serializer/types'
 import type { BlockState, Loop, Parallel } from '@/stores/workflows/workflow/types'
 import { generateLoopBlocks, generateParallelBlocks } from '@/stores/workflows/workflow/utils'
@@ -27,67 +35,37 @@ export class WorkflowValidationError extends Error {
 }
 
 /**
- * Helper function to check if a subblock should be included in serialization based on current mode
+ * Helper function to check if a subblock should be serialized.
  */
-function shouldIncludeField(subBlockConfig: SubBlockConfig, isAdvancedMode: boolean): boolean {
-  const fieldMode = subBlockConfig.mode
+function shouldSerializeSubBlock(
+  subBlockConfig: SubBlockConfig,
+  values: Record<string, unknown>,
+  displayAdvancedOptions: boolean,
+  isTriggerContext: boolean,
+  isTriggerCategory: boolean,
+  canonicalIndex: ReturnType<typeof buildCanonicalIndex>
+): boolean {
+  if (!isSubBlockFeatureEnabled(subBlockConfig)) return false
 
-  if (fieldMode === 'advanced' && !isAdvancedMode) {
-    return false // Skip advanced-only fields when in basic mode
+  if (subBlockConfig.mode === 'trigger') {
+    if (!isTriggerContext && !isTriggerCategory) return false
+  } else if (isTriggerContext && !isTriggerCategory) {
+    return false
   }
 
-  return true
-}
+  const isCanonicalMember = Boolean(canonicalIndex.canonicalIdBySubBlockId[subBlockConfig.id])
+  if (isCanonicalMember) {
+    return evaluateSubBlockCondition(subBlockConfig.condition, values)
+  }
 
-/**
- * Evaluates a condition object against current field values.
- * Used to determine if a conditionally-visible field should be included in params.
- */
-function evaluateCondition(
-  condition:
-    | {
-        field: string
-        value: any
-        not?: boolean
-        and?: { field: string; value: any; not?: boolean }
-      }
-    | (() => {
-        field: string
-        value: any
-        not?: boolean
-        and?: { field: string; value: any; not?: boolean }
-      })
-    | undefined,
-  values: Record<string, any>
-): boolean {
-  if (!condition) return true
+  if (subBlockConfig.mode === 'advanced' && !displayAdvancedOptions) {
+    return isNonEmptyValue(values[subBlockConfig.id])
+  }
+  if (subBlockConfig.mode === 'basic' && displayAdvancedOptions) {
+    return false
+  }
 
-  const actual = typeof condition === 'function' ? condition() : condition
-  const fieldValue = values[actual.field]
-
-  const valueMatch = Array.isArray(actual.value)
-    ? fieldValue != null &&
-      (actual.not ? !actual.value.includes(fieldValue) : actual.value.includes(fieldValue))
-    : actual.not
-      ? fieldValue !== actual.value
-      : fieldValue === actual.value
-
-  const andMatch = !actual.and
-    ? true
-    : (() => {
-        const andFieldValue = values[actual.and!.field]
-        const andValueMatch = Array.isArray(actual.and!.value)
-          ? andFieldValue != null &&
-            (actual.and!.not
-              ? !actual.and!.value.includes(andFieldValue)
-              : actual.and!.value.includes(andFieldValue))
-          : actual.and!.not
-            ? andFieldValue !== actual.and!.value
-            : andFieldValue === actual.and!.value
-        return andValueMatch
-      })()
-
-  return valueMatch && andMatch
+  return evaluateSubBlockCondition(subBlockConfig.condition, values)
 }
 
 /**
@@ -241,16 +219,12 @@ export class Serializer {
     // Extract parameters from UI state
     const params = this.extractParams(block)
 
-    try {
-      const isTriggerCategory = blockConfig.category === 'triggers'
-      if (block.triggerMode === true || isTriggerCategory) {
-        params.triggerMode = true
-      }
-      if (block.advancedMode === true) {
-        params.advancedMode = true
-      }
-    } catch (_) {
-      // no-op: conservative, avoid blocking serialization if blockConfig is unexpected
+    const isTriggerCategory = blockConfig.category === 'triggers'
+    if (block.triggerMode === true || isTriggerCategory) {
+      params.triggerMode = true
+    }
+    if (block.advancedMode === true) {
+      params.advancedMode = true
     }
 
     // Validate required fields that only users can provide (before execution starts)
@@ -271,16 +245,7 @@ export class Serializer {
         // For non-custom tools, we determine the tool ID
         const nonCustomTools = tools.filter((tool: any) => tool.type !== 'custom-tool')
         if (nonCustomTools.length > 0) {
-          try {
-            toolId = blockConfig.tools.config?.tool
-              ? blockConfig.tools.config.tool(params)
-              : blockConfig.tools.access[0]
-          } catch (error) {
-            logger.warn('Tool selection failed during serialization, using default:', {
-              error: error instanceof Error ? error.message : String(error),
-            })
-            toolId = blockConfig.tools.access[0]
-          }
+          toolId = this.selectToolId(blockConfig, params)
         }
       } catch (error) {
         logger.error('Error processing tools in agent block:', { error })
@@ -289,16 +254,7 @@ export class Serializer {
       }
     } else {
       // For non-agent blocks, get tool ID from block config as usual
-      try {
-        toolId = blockConfig.tools.config?.tool
-          ? blockConfig.tools.config.tool(params)
-          : blockConfig.tools.access[0]
-      } catch (error) {
-        logger.warn('Tool selection failed during serialization, using default:', {
-          error: error instanceof Error ? error.message : String(error),
-        })
-        toolId = blockConfig.tools.access[0]
-      }
+      toolId = this.selectToolId(blockConfig, params)
     }
 
     // Get inputs from block config
@@ -322,7 +278,10 @@ export class Serializer {
         // Include response format fields if available
         ...(params.responseFormat
           ? {
-              responseFormat: this.parseResponseFormatSafely(params.responseFormat),
+              responseFormat:
+                parseResponseFormatSafely(params.responseFormat, block.id, {
+                  allowReferences: true,
+                }) ?? undefined,
             }
           : {}),
       },
@@ -337,52 +296,9 @@ export class Serializer {
     }
   }
 
-  private parseResponseFormatSafely(responseFormat: any): any {
-    if (!responseFormat) {
-      return undefined
-    }
-
-    // If already an object, return as-is
-    if (typeof responseFormat === 'object' && responseFormat !== null) {
-      return responseFormat
-    }
-
-    // Handle string values
-    if (typeof responseFormat === 'string') {
-      const trimmedValue = responseFormat.trim()
-
-      // Check for variable references like <start.input>
-      if (trimmedValue.startsWith(REFERENCE.START) && trimmedValue.includes(REFERENCE.END)) {
-        // Keep variable references as-is
-        return trimmedValue
-      }
-
-      if (trimmedValue === '') {
-        return undefined
-      }
-
-      // Try to parse as JSON
-      try {
-        return JSON.parse(trimmedValue)
-      } catch (error) {
-        // If parsing fails, return undefined to avoid crashes
-        // This allows the workflow to continue without structured response format
-        logger.warn('Failed to parse response format as JSON in serializer, using undefined:', {
-          value: trimmedValue,
-          error: error instanceof Error ? error.message : String(error),
-        })
-        return undefined
-      }
-    }
-
-    // For any other type, return undefined
-    return undefined
-  }
-
   private extractParams(block: BlockState): Record<string, any> {
-    // Special handling for subflow blocks (loops, parallels, etc.)
     if (block.type === 'loop' || block.type === 'parallel') {
-      return {} // Loop and parallel blocks don't have traditional params
+      return {}
     }
 
     const blockConfig = getBlock(block.type)
@@ -391,43 +307,42 @@ export class Serializer {
     }
 
     const params: Record<string, any> = {}
-    const isAdvancedMode = block.advancedMode ?? false
+    const legacyAdvancedMode = block.advancedMode ?? false
+    const canonicalModeOverrides = block.data?.canonicalModes
     const isStarterBlock = block.type === 'starter'
     const isAgentBlock = block.type === 'agent'
+    const isTriggerContext = block.triggerMode ?? false
+    const isTriggerCategory = blockConfig.category === 'triggers'
+    const canonicalIndex = buildCanonicalIndex(blockConfig.subBlocks)
+    const allValues = buildSubBlockValues(block.subBlocks)
 
-    // First pass: collect ALL raw values for condition evaluation
-    const allValues: Record<string, any> = {}
-    Object.entries(block.subBlocks).forEach(([id, subBlock]) => {
-      allValues[id] = subBlock.value
-    })
-
-    // Second pass: filter by mode and conditions
     Object.entries(block.subBlocks).forEach(([id, subBlock]) => {
       const matchingConfigs = blockConfig.subBlocks.filter((config) => config.id === id)
 
-      // Include field if it matches current mode OR if it's the starter inputFormat with values
       const hasStarterInputFormatValues =
         isStarterBlock &&
         id === 'inputFormat' &&
         Array.isArray(subBlock.value) &&
         subBlock.value.length > 0
 
-      // Include legacy agent block fields (systemPrompt, userPrompt, memories) even if not in current config
-      // This ensures backward compatibility with old workflows that were exported before the messages array migration
       const isLegacyAgentField =
         isAgentBlock && ['systemPrompt', 'userPrompt', 'memories'].includes(id)
 
-      const anyConditionMet =
-        matchingConfigs.length === 0
-          ? true
-          : matchingConfigs.some(
-              (config) =>
-                shouldIncludeField(config, isAdvancedMode) &&
-                evaluateCondition(config.condition, allValues)
-            )
+      const shouldInclude =
+        matchingConfigs.length === 0 ||
+        matchingConfigs.some((config) =>
+          shouldSerializeSubBlock(
+            config,
+            allValues,
+            legacyAdvancedMode,
+            isTriggerContext,
+            isTriggerCategory,
+            canonicalIndex
+          )
+        )
 
       if (
-        (matchingConfigs.length > 0 && anyConditionMet) ||
+        (matchingConfigs.length > 0 && shouldInclude) ||
         hasStarterInputFormatValues ||
         isLegacyAgentField
       ) {
@@ -435,56 +350,38 @@ export class Serializer {
       }
     })
 
-    // Then check for any subBlocks with default values
     blockConfig.subBlocks.forEach((subBlockConfig) => {
       const id = subBlockConfig.id
       if (
-        (params[id] === null || params[id] === undefined) &&
+        params[id] == null &&
         subBlockConfig.value &&
-        shouldIncludeField(subBlockConfig, isAdvancedMode)
+        shouldSerializeSubBlock(
+          subBlockConfig,
+          allValues,
+          legacyAdvancedMode,
+          isTriggerContext,
+          isTriggerCategory,
+          canonicalIndex
+        )
       ) {
-        // If the value is absent and there's a default value function, use it
         params[id] = subBlockConfig.value(params)
       }
     })
 
-    // Finally, consolidate canonical parameters (e.g., selector and manual ID into a single param)
-    const canonicalGroups: Record<string, { basic?: string; advanced: string[] }> = {}
-    blockConfig.subBlocks.forEach((sb) => {
-      if (!sb.canonicalParamId) return
-      const key = sb.canonicalParamId
-      if (!canonicalGroups[key]) canonicalGroups[key] = { basic: undefined, advanced: [] }
-      if (sb.mode === 'advanced') canonicalGroups[key].advanced.push(sb.id)
-      else canonicalGroups[key].basic = sb.id
-    })
+    Object.values(canonicalIndex.groupsById).forEach((group) => {
+      const { basicValue, advancedValue } = getCanonicalValues(group, params)
+      const pairMode =
+        canonicalModeOverrides?.[group.canonicalId] ?? (legacyAdvancedMode ? 'advanced' : 'basic')
+      const chosen = pairMode === 'advanced' ? advancedValue : basicValue
 
-    Object.entries(canonicalGroups).forEach(([canonicalKey, group]) => {
-      const basicId = group.basic
-      const advancedIds = group.advanced
-      const basicVal = basicId ? params[basicId] : undefined
-      const advancedVal = advancedIds
-        .map((id) => params[id])
-        .find(
-          (v) => v !== undefined && v !== null && (typeof v !== 'string' || v.trim().length > 0)
-        )
-
-      let chosen: any
-      if (advancedVal !== undefined && basicVal !== undefined) {
-        chosen = isAdvancedMode ? advancedVal : basicVal
-      } else if (advancedVal !== undefined) {
-        chosen = advancedVal
-      } else if (basicVal !== undefined) {
-        chosen = isAdvancedMode ? undefined : basicVal
-      } else {
-        chosen = undefined
-      }
-
-      const sourceIds = [basicId, ...advancedIds].filter(Boolean) as string[]
+      const sourceIds = [group.basicId, ...group.advancedIds].filter(Boolean) as string[]
       sourceIds.forEach((id) => {
-        if (id !== canonicalKey) delete params[id]
+        if (id !== group.canonicalId) delete params[id]
       })
-      if (chosen !== undefined) params[canonicalKey] = chosen
-      else delete params[canonicalKey]
+
+      if (chosen !== undefined) {
+        params[group.canonicalId] = chosen
+      }
     })
 
     return params
@@ -520,17 +417,7 @@ export class Serializer {
     }
 
     // Determine the current tool ID using the same logic as the serializer
-    let currentToolId = ''
-    try {
-      currentToolId = blockConfig.tools.config?.tool
-        ? blockConfig.tools.config.tool(params)
-        : blockConfig.tools.access[0]
-    } catch (error) {
-      logger.warn('Tool selection failed during validation, using default:', {
-        error: error instanceof Error ? error.message : String(error),
-      })
-      currentToolId = blockConfig.tools.access[0]
-    }
+    const currentToolId = this.selectToolId(blockConfig, params)
 
     // Get the specific tool to validate against
     const currentTool = getTool(currentToolId)
@@ -538,8 +425,11 @@ export class Serializer {
       return // Tool not found, skip validation
     }
 
-    // Check required user-only parameters for the current tool
     const missingFields: string[] = []
+    const displayAdvancedOptions = block.advancedMode ?? false
+    const isTriggerContext = block.triggerMode ?? false
+    const isTriggerCategory = blockConfig.category === 'triggers'
+    const canonicalIndex = buildCanonicalIndex(blockConfig.subBlocks || [])
 
     // Iterate through the tool's parameters, not the block's subBlocks
     Object.entries(currentTool.params || {}).forEach(([paramId, paramConfig]) => {
@@ -549,20 +439,23 @@ export class Serializer {
         let shouldValidateParam = true
 
         if (matchingConfigs.length > 0) {
-          const isAdvancedMode = block.advancedMode ?? false
-
           shouldValidateParam = matchingConfigs.some((subBlockConfig: any) => {
-            const includedByMode = shouldIncludeField(subBlockConfig, isAdvancedMode)
-
-            const includedByCondition = evaluateCondition(subBlockConfig.condition, params)
+            const includedByMode = shouldSerializeSubBlock(
+              subBlockConfig,
+              params,
+              displayAdvancedOptions,
+              isTriggerContext,
+              isTriggerCategory,
+              canonicalIndex
+            )
 
             const isRequired = (() => {
               if (!subBlockConfig.required) return false
               if (typeof subBlockConfig.required === 'boolean') return subBlockConfig.required
-              return evaluateCondition(subBlockConfig.required, params)
+              return evaluateSubBlockCondition(subBlockConfig.required, params)
             })()
 
-            return includedByMode && includedByCondition && isRequired
+            return includedByMode && isRequired
           })
         }
 
@@ -572,10 +465,15 @@ export class Serializer {
 
         const fieldValue = params[paramId]
         if (fieldValue === undefined || fieldValue === null || fieldValue === '') {
-          const activeConfig = matchingConfigs.find(
-            (config: any) =>
-              shouldIncludeField(config, block.advancedMode ?? false) &&
-              evaluateCondition(config.condition, params)
+          const activeConfig = matchingConfigs.find((config: any) =>
+            shouldSerializeSubBlock(
+              config,
+              params,
+              displayAdvancedOptions,
+              isTriggerContext,
+              isTriggerCategory,
+              canonicalIndex
+            )
           )
           const displayName = activeConfig?.title || paramId
           missingFields.push(displayName)
@@ -629,6 +527,19 @@ export class Serializer {
     return accessibleMap
   }
 
+  private selectToolId(blockConfig: any, params: Record<string, any>): string {
+    try {
+      return blockConfig.tools.config?.tool
+        ? blockConfig.tools.config.tool(params)
+        : blockConfig.tools.access[0]
+    } catch (error) {
+      logger.warn('Tool selection failed during serialization, using default:', {
+        error: error instanceof Error ? error.message : String(error),
+      })
+      return blockConfig.tools.access[0]
+    }
+  }
+
   deserializeWorkflow(workflow: SerializedWorkflow): {
     blocks: Record<string, BlockState>
     edges: Edge[]

apps/sim/serializer/tests/serializer.extended.test.ts

@@ -147,20 +147,19 @@ const { mockBlockConfigs, createMockGetBlock, slackWithCanonicalParam } = vi.hoi
         config: { tool: () => 'slack_send_message' },
       },
       subBlocks: [
-        { id: 'channel', type: 'dropdown', label: 'Channel', mode: 'basic' },
+        {
+          id: 'channel',
+          type: 'dropdown',
+          label: 'Channel',
+          mode: 'basic',
+          canonicalParamId: 'channel',
+        },
         {
           id: 'manualChannel',
           type: 'short-input',
           label: 'Channel ID',
           mode: 'advanced',
-          canonicalParamId: 'targetChannel',
-        },
-        {
-          id: 'channelSelector',
-          type: 'dropdown',
-          label: 'Channel Selector',
-          mode: 'basic',
-          canonicalParamId: 'targetChannel',
+          canonicalParamId: 'channel',
         },
         { id: 'text', type: 'long-input', label: 'Message' },
         { id: 'username', type: 'short-input', label: 'Username', mode: 'both' },
@@ -656,16 +655,18 @@ describe('Serializer Extended Tests', () => {
   })
 
   describe('canonical parameter handling', () => {
-    it('should consolidate basic/advanced mode fields into canonical param in advanced mode', () => {
+    it('should use advanced value when canonicalModes specifies advanced', () => {
       const serializer = new Serializer()
       const block: BlockState = {
         id: 'slack-1',
         type: 'slack',
         name: 'Slack',
         position: { x: 0, y: 0 },
-        advancedMode: true,
+        data: {
+          canonicalModes: { channel: 'advanced' },
+        },
         subBlocks: {
-          channelSelector: { id: 'channelSelector', type: 'dropdown', value: 'general' },
+          channel: { id: 'channel', type: 'channel-selector', value: 'general' },
           manualChannel: { id: 'manualChannel', type: 'short-input', value: 'C12345' },
           text: { id: 'text', type: 'long-input', value: 'Hello' },
         },
@@ -676,22 +677,23 @@ describe('Serializer Extended Tests', () => {
       const serialized = serializer.serializeWorkflow({ 'slack-1': block }, [], {})
       const slackBlock = serialized.blocks.find((b) => b.id === 'slack-1')
 
-      expect(slackBlock?.config.params.targetChannel).toBe('C12345')
-      expect(slackBlock?.config.params.channelSelector).toBeUndefined()
+      expect(slackBlock?.config.params.channel).toBe('C12345')
       expect(slackBlock?.config.params.manualChannel).toBeUndefined()
     })
 
-    it('should consolidate to basic value when in basic mode', () => {
+    it('should use basic value when canonicalModes specifies basic', () => {
       const serializer = new Serializer()
       const block: BlockState = {
         id: 'slack-1',
         type: 'slack',
         name: 'Slack',
         position: { x: 0, y: 0 },
-        advancedMode: false,
+        data: {
+          canonicalModes: { channel: 'basic' },
+        },
         subBlocks: {
-          channelSelector: { id: 'channelSelector', type: 'dropdown', value: 'general' },
-          manualChannel: { id: 'manualChannel', type: 'short-input', value: '' },
+          channel: { id: 'channel', type: 'channel-selector', value: 'general' },
+          manualChannel: { id: 'manualChannel', type: 'short-input', value: 'C12345' },
           text: { id: 'text', type: 'long-input', value: 'Hello' },
         },
         outputs: {},
@@ -701,7 +703,7 @@ describe('Serializer Extended Tests', () => {
       const serialized = serializer.serializeWorkflow({ 'slack-1': block }, [], {})
       const slackBlock = serialized.blocks.find((b) => b.id === 'slack-1')
 
-      expect(slackBlock?.config.params.targetChannel).toBe('general')
+      expect(slackBlock?.config.params.channel).toBe('general')
     })
 
     it('should handle missing canonical param values', () => {
@@ -711,9 +713,8 @@ describe('Serializer Extended Tests', () => {
         type: 'slack',
         name: 'Slack',
         position: { x: 0, y: 0 },
-        advancedMode: false,
         subBlocks: {
-          channelSelector: { id: 'channelSelector', type: 'dropdown', value: null },
+          channel: { id: 'channel', type: 'channel-selector', value: null },
           manualChannel: { id: 'manualChannel', type: 'short-input', value: null },
           text: { id: 'text', type: 'long-input', value: 'Hello' },
         },
@@ -724,8 +725,7 @@ describe('Serializer Extended Tests', () => {
       const serialized = serializer.serializeWorkflow({ 'slack-1': block }, [], {})
       const slackBlock = serialized.blocks.find((b) => b.id === 'slack-1')
 
-      // When both values are null, the canonical param is set to null (preserving the null value)
-      expect(slackBlock?.config.params.targetChannel).toBeNull()
+      expect(slackBlock?.config.params.channel).toBeNull()
     })
   })
 

apps/sim/socket/constants.ts

@@ -4,6 +4,7 @@ export const BLOCK_OPERATIONS = {
   TOGGLE_ENABLED: 'toggle-enabled',
   UPDATE_PARENT: 'update-parent',
   UPDATE_ADVANCED_MODE: 'update-advanced-mode',
+  UPDATE_CANONICAL_MODE: 'update-canonical-mode',
   TOGGLE_HANDLES: 'toggle-handles',
 } as const
 

apps/sim/socket/database/operations.ts

@@ -398,6 +398,46 @@ async function handleBlockOperationTx(
       break
     }
 
+    case BLOCK_OPERATIONS.UPDATE_CANONICAL_MODE: {
+      if (!payload.id || !payload.canonicalId || !payload.canonicalMode) {
+        throw new Error('Missing required fields for update canonical mode operation')
+      }
+
+      const existingBlock = await tx
+        .select({ data: workflowBlocks.data })
+        .from(workflowBlocks)
+        .where(and(eq(workflowBlocks.id, payload.id), eq(workflowBlocks.workflowId, workflowId)))
+        .limit(1)
+
+      const currentData = (existingBlock?.[0]?.data as Record<string, unknown>) || {}
+      const currentCanonicalModes = (currentData.canonicalModes as Record<string, unknown>) || {}
+      const canonicalModes = {
+        ...currentCanonicalModes,
+        [payload.canonicalId]: payload.canonicalMode,
+      }
+
+      const updateResult = await tx
+        .update(workflowBlocks)
+        .set({
+          data: {
+            ...currentData,
+            canonicalModes,
+          },
+          updatedAt: new Date(),
+        })
+        .where(and(eq(workflowBlocks.id, payload.id), eq(workflowBlocks.workflowId, workflowId)))
+        .returning({ id: workflowBlocks.id })
+
+      if (updateResult.length === 0) {
+        throw new Error(`Block ${payload.id} not found in workflow ${workflowId}`)
+      }
+
+      logger.debug(
+        `Updated block canonical mode: ${payload.id} -> ${payload.canonicalId}: ${payload.canonicalMode}`
+      )
+      break
+    }
+
     case BLOCK_OPERATIONS.TOGGLE_HANDLES: {
       if (!payload.id || payload.horizontalHandles === undefined) {
         throw new Error('Missing required fields for toggle handles operation')

apps/sim/socket/middleware/permissions.test.ts

@@ -208,7 +208,7 @@ describe('checkRolePermission', () => {
       { operation: 'toggle-enabled', adminAllowed: true, writeAllowed: true, readAllowed: false },
       { operation: 'update-parent', adminAllowed: true, writeAllowed: true, readAllowed: false },
       {
-        operation: 'update-advanced-mode',
+        operation: 'update-canonical-mode',
         adminAllowed: true,
         writeAllowed: true,
         readAllowed: false,

apps/sim/socket/middleware/permissions.ts

@@ -22,6 +22,7 @@ const WRITE_OPERATIONS: string[] = [
   BLOCK_OPERATIONS.TOGGLE_ENABLED,
   BLOCK_OPERATIONS.UPDATE_PARENT,
   BLOCK_OPERATIONS.UPDATE_ADVANCED_MODE,
+  BLOCK_OPERATIONS.UPDATE_CANONICAL_MODE,
   BLOCK_OPERATIONS.TOGGLE_HANDLES,
   // Batch block operations
   BLOCKS_OPERATIONS.BATCH_UPDATE_POSITIONS,

apps/sim/socket/validation/schemas.ts

@@ -31,6 +31,7 @@ export const BlockOperationSchema = z.object({
     BLOCK_OPERATIONS.TOGGLE_ENABLED,
     BLOCK_OPERATIONS.UPDATE_PARENT,
     BLOCK_OPERATIONS.UPDATE_ADVANCED_MODE,
+    BLOCK_OPERATIONS.UPDATE_CANONICAL_MODE,
     BLOCK_OPERATIONS.TOGGLE_HANDLES,
   ]),
   target: z.literal(OPERATION_TARGETS.BLOCK),
@@ -46,8 +47,10 @@ export const BlockOperationSchema = z.object({
     parentId: z.string().nullable().optional(),
     extent: z.enum(['parent']).nullable().optional(),
     enabled: z.boolean().optional(),
-    horizontalHandles: z.boolean().optional(),
     advancedMode: z.boolean().optional(),
+    horizontalHandles: z.boolean().optional(),
+    canonicalId: z.string().optional(),
+    canonicalMode: z.enum(['basic', 'advanced']).optional(),
     triggerMode: z.boolean().optional(),
     height: z.number().optional(),
   }),

apps/sim/stores/workflows/workflow/store.ts

@@ -848,6 +848,35 @@ export const useWorkflowStore = create<WorkflowStore>()(
         // Note: Socket.IO handles real-time sync automatically
       },
 
+      setBlockCanonicalMode: (id: string, canonicalId: string, mode: 'basic' | 'advanced') => {
+        set((state) => {
+          const block = state.blocks[id]
+          if (!block) {
+            return state
+          }
+
+          const currentData = block.data || {}
+          const currentCanonicalModes = currentData.canonicalModes || {}
+          const canonicalModes = { ...currentCanonicalModes, [canonicalId]: mode }
+
+          return {
+            blocks: {
+              ...state.blocks,
+              [id]: {
+                ...block,
+                data: {
+                  ...currentData,
+                  canonicalModes,
+                },
+              },
+            },
+            edges: [...state.edges],
+            loops: { ...state.loops },
+          }
+        })
+        get().updateLastSaved()
+      },
+
       setBlockTriggerMode: (id: string, triggerMode: boolean) => {
         set((state) => ({
           blocks: {

apps/sim/stores/workflows/workflow/types.ts

@@ -63,6 +63,9 @@ export interface BlockData {
 
   // Container node type (for ReactFlow node type determination)
   type?: string
+
+  /** Canonical swap overrides keyed by canonicalParamId */
+  canonicalModes?: Record<string, 'basic' | 'advanced'>
 }
 
 export interface BlockLayoutState {
@@ -218,6 +221,7 @@ export interface WorkflowActions {
     changedSubblocks: Array<{ blockId: string; subBlockId: string; newValue: any }>
   }
   setBlockAdvancedMode: (id: string, advancedMode: boolean) => void
+  setBlockCanonicalMode: (id: string, canonicalId: string, mode: 'basic' | 'advanced') => void
   setBlockTriggerMode: (id: string, triggerMode: boolean) => void
   updateBlockLayoutMetrics: (id: string, dimensions: { width: number; height: number }) => void
   triggerUpdate: () => void

packages/testing/src/factories/permission.factory.ts

@@ -260,6 +260,7 @@ const BLOCK_OPERATIONS = {
   TOGGLE_ENABLED: 'toggle-enabled',
   UPDATE_PARENT: 'update-parent',
   UPDATE_ADVANCED_MODE: 'update-advanced-mode',
+  UPDATE_CANONICAL_MODE: 'update-canonical-mode',
   TOGGLE_HANDLES: 'toggle-handles',
 } as const
 

packages/testing/src/mocks/blocks.mock.ts

@@ -169,8 +169,20 @@ export const mockBlockConfigs: Record<string, any> = {
       config: { tool: () => 'slack_send_message' },
     },
     subBlocks: [
-      { id: 'channel', type: 'dropdown', title: 'Channel', mode: 'basic' },
-      { id: 'manualChannel', type: 'short-input', title: 'Channel ID', mode: 'advanced' },
+      {
+        id: 'channel',
+        type: 'dropdown',
+        title: 'Channel',
+        mode: 'basic',
+        canonicalParamId: 'channel',
+      },
+      {
+        id: 'manualChannel',
+        type: 'short-input',
+        title: 'Channel ID',
+        mode: 'advanced',
+        canonicalParamId: 'channel',
+      },
       { id: 'text', type: 'long-input', title: 'Message' },
       { id: 'username', type: 'short-input', title: 'Username', mode: 'both' },
     ],