fix(slack): resolve file metadata via files.info when event payload is partial

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/chat/components/output-select/output-select.tsx

@@ -4,7 +4,11 @@ import type React from 'react'
 import { useMemo } from 'react'
 import { RepeatIcon, SplitIcon } from 'lucide-react'
 import { Combobox, type ComboboxOptionGroup } from '@/components/emcn'
-import { getEffectiveBlockOutputs } from '@/lib/workflows/blocks/block-outputs'
+import {
+  extractFieldsFromSchema,
+  parseResponseFormatSafely,
+} from '@/lib/core/utils/response-format'
+import { getToolOutputs } from '@/lib/workflows/blocks/block-outputs'
 import { getBlock } from '@/blocks'
 import { useWorkflowDiffStore } from '@/stores/workflow-diff/store'
 import { useSubBlockStore } from '@/stores/workflows/subblock/store'
@@ -120,24 +124,41 @@ export function OutputSelect({
           : `block-${block.id}`
 
       const blockConfig = getBlock(block.type)
+      const responseFormatValue =
+        shouldUseBaseline && baselineWorkflow
+          ? baselineWorkflow.blocks?.[block.id]?.subBlocks?.responseFormat?.value
+          : subBlockValues?.[block.id]?.responseFormat
+      const responseFormat = parseResponseFormatSafely(responseFormatValue, block.id)
 
       let outputsToProcess: Record<string, unknown> = {}
-      const rawSubBlockValues =
-        shouldUseBaseline && baselineWorkflow
-          ? baselineWorkflow.blocks?.[block.id]?.subBlocks
-          : subBlockValues?.[block.id]
-      const subBlocks: Record<string, { value: unknown }> = {}
-      if (rawSubBlockValues && typeof rawSubBlockValues === 'object') {
-        for (const [key, val] of Object.entries(rawSubBlockValues)) {
-          // Handle both { value: ... } and raw value formats
-          subBlocks[key] = val && typeof val === 'object' && 'value' in val ? val : { value: val }
-        }
-      }
 
-      outputsToProcess = getEffectiveBlockOutputs(block.type, subBlocks, {
-        triggerMode: Boolean(block.triggerMode),
-        preferToolOutputs: !block.triggerMode,
-      }) as Record<string, unknown>
+      if (responseFormat) {
+        const schemaFields = extractFieldsFromSchema(responseFormat)
+        if (schemaFields.length > 0) {
+          schemaFields.forEach((field) => {
+            outputsToProcess[field.name] = { type: field.type }
+          })
+        } else {
+          outputsToProcess = blockConfig?.outputs || {}
+        }
+      } else {
+        // Build subBlocks object for tool selector
+        const rawSubBlockValues =
+          shouldUseBaseline && baselineWorkflow
+            ? baselineWorkflow.blocks?.[block.id]?.subBlocks
+            : subBlockValues?.[block.id]
+        const subBlocks: Record<string, { value: unknown }> = {}
+        if (rawSubBlockValues && typeof rawSubBlockValues === 'object') {
+          for (const [key, val] of Object.entries(rawSubBlockValues)) {
+            // Handle both { value: ... } and raw value formats
+            subBlocks[key] = val && typeof val === 'object' && 'value' in val ? val : { value: val }
+          }
+        }
+
+        const toolOutputs = blockConfig ? getToolOutputs(blockConfig, subBlocks) : {}
+        outputsToProcess =
+          Object.keys(toolOutputs).length > 0 ? toolOutputs : blockConfig?.outputs || {}
+      }
 
       if (Object.keys(outputsToProcess).length === 0) return
 

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

@@ -61,6 +61,8 @@ function ConnectionItem({
     blockId: connection.id,
     blockType: connection.type,
     mergedSubBlocks,
+    responseFormat: connection.responseFormat,
+    operation: connection.operation,
     triggerMode: sourceBlock?.triggerMode,
   })
   const hasFields = fields.length > 0

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

@@ -14,9 +14,15 @@ import {
 } from '@/components/emcn'
 import { cn } from '@/lib/core/utils/cn'
 import {
-  getEffectiveBlockOutputPaths,
-  getEffectiveBlockOutputType,
+  extractFieldsFromSchema,
+  parseResponseFormatSafely,
+} from '@/lib/core/utils/response-format'
+import {
+  getBlockOutputPaths,
+  getBlockOutputType,
   getOutputPathsFromSchema,
+  getToolOutputPaths,
+  getToolOutputType,
 } from '@/lib/workflows/blocks/block-outputs'
 import { TRIGGER_TYPES } from '@/lib/workflows/triggers/triggers'
 import { KeyboardNavigationHandler } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/tag-dropdown/components/keyboard-navigation-handler'
@@ -208,18 +214,43 @@ const getOutputTypeForPath = (
   outputPath: string,
   mergedSubBlocksOverride?: Record<string, any>
 ): string => {
-  if (block?.type === 'variables') {
-    return 'any'
+  if (block?.triggerMode && blockConfig?.triggers?.enabled) {
+    return getBlockOutputType(block.type, outputPath, mergedSubBlocksOverride, true)
+  }
+  if (block?.type === 'starter') {
+    const startWorkflowValue =
+      mergedSubBlocksOverride?.startWorkflow?.value ?? getSubBlockValue(blockId, 'startWorkflow')
+
+    if (startWorkflowValue === 'chat') {
+      const chatModeTypes: Record<string, string> = {
+        input: 'string',
+        conversationId: 'string',
+        files: 'file[]',
+      }
+      return chatModeTypes[outputPath] || 'any'
+    }
+    const inputFormatValue =
+      mergedSubBlocksOverride?.inputFormat?.value ?? getSubBlockValue(blockId, 'inputFormat')
+    if (inputFormatValue && Array.isArray(inputFormatValue)) {
+      const field = inputFormatValue.find(
+        (f: { name?: string; type?: string }) => f.name === outputPath
+      )
+      if (field?.type) return field.type
+    }
+  } else if (blockConfig?.category === 'triggers') {
+    const blockState = useWorkflowStore.getState().blocks[blockId]
+    const subBlocks = mergedSubBlocksOverride ?? (blockState?.subBlocks || {})
+    return getBlockOutputType(block.type, outputPath, subBlocks)
+  } else if (blockConfig?.tools?.config?.tool) {
+    const blockState = useWorkflowStore.getState().blocks[blockId]
+    const subBlocks = mergedSubBlocksOverride ?? (blockState?.subBlocks || {})
+    return getToolOutputType(blockConfig, subBlocks, outputPath)
   }
 
   const subBlocks =
     mergedSubBlocksOverride ?? useWorkflowStore.getState().blocks[blockId]?.subBlocks
-  const triggerMode = Boolean(block?.triggerMode && blockConfig?.triggers?.enabled)
-
-  return getEffectiveBlockOutputType(block?.type ?? '', outputPath, subBlocks, {
-    triggerMode,
-    preferToolOutputs: !triggerMode,
-  })
+  const triggerMode = block?.triggerMode && blockConfig?.triggers?.enabled
+  return getBlockOutputType(block?.type ?? '', outputPath, subBlocks, triggerMode)
 }
 
 /**
@@ -1057,9 +1088,24 @@ export const TagDropdown: React.FC<TagDropdownProps> = ({
       const normalizedBlockName = normalizeName(blockName)
 
       const mergedSubBlocks = getMergedSubBlocks(activeSourceBlockId)
+      const responseFormatValue = mergedSubBlocks?.responseFormat?.value
+      const responseFormat = parseResponseFormatSafely(responseFormatValue, activeSourceBlockId)
+
       let blockTags: string[]
 
-      if (sourceBlock.type === 'variables') {
+      if (sourceBlock.type === 'evaluator') {
+        const metricsValue = getSubBlockValue(activeSourceBlockId, 'metrics')
+
+        if (metricsValue && Array.isArray(metricsValue) && metricsValue.length > 0) {
+          const validMetrics = metricsValue.filter((metric: { name?: string }) => metric?.name)
+          blockTags = validMetrics.map(
+            (metric: { name: string }) => `${normalizedBlockName}.${metric.name.toLowerCase()}`
+          )
+        } else {
+          const outputPaths = getBlockOutputPaths(sourceBlock.type, mergedSubBlocks)
+          blockTags = outputPaths.map((path) => `${normalizedBlockName}.${path}`)
+        }
+      } else if (sourceBlock.type === 'variables') {
         const variablesValue = getSubBlockValue(activeSourceBlockId, 'variables')
 
         if (variablesValue && Array.isArray(variablesValue) && variablesValue.length > 0) {
@@ -1073,21 +1119,106 @@ export const TagDropdown: React.FC<TagDropdownProps> = ({
         } else {
           blockTags = [normalizedBlockName]
         }
-      } else {
-        const outputPaths = getEffectiveBlockOutputPaths(sourceBlock.type, mergedSubBlocks, {
-          triggerMode: Boolean(sourceBlock.triggerMode),
-          preferToolOutputs: !sourceBlock.triggerMode,
-        })
-        const allTags = outputPaths.map((path) => `${normalizedBlockName}.${path}`)
-
-        if (sourceBlock.type === 'human_in_the_loop' && activeSourceBlockId === blockId) {
-          blockTags = allTags.filter(
-            (tag) => tag.endsWith('.url') || tag.endsWith('.resumeEndpoint')
-          )
-        } else if (allTags.length === 0) {
-          blockTags = [normalizedBlockName]
+      } else if (responseFormat) {
+        const schemaFields = extractFieldsFromSchema(responseFormat)
+        if (schemaFields.length > 0) {
+          blockTags = schemaFields.map((field) => `${normalizedBlockName}.${field.name}`)
         } else {
-          blockTags = allTags
+          const outputPaths = getBlockOutputPaths(
+            sourceBlock.type,
+            mergedSubBlocks,
+            sourceBlock.triggerMode
+          )
+          blockTags = outputPaths.map((path) => `${normalizedBlockName}.${path}`)
+        }
+      } else if (!blockConfig.outputs || Object.keys(blockConfig.outputs).length === 0) {
+        if (sourceBlock.type === 'starter') {
+          const startWorkflowValue = mergedSubBlocks?.startWorkflow?.value
+
+          if (startWorkflowValue === 'chat') {
+            blockTags = [
+              `${normalizedBlockName}.input`,
+              `${normalizedBlockName}.conversationId`,
+              `${normalizedBlockName}.files`,
+            ]
+          } else {
+            const inputFormatValue = mergedSubBlocks?.inputFormat?.value
+
+            if (
+              inputFormatValue &&
+              Array.isArray(inputFormatValue) &&
+              inputFormatValue.length > 0
+            ) {
+              blockTags = inputFormatValue
+                .filter((field: { name?: string }) => field.name && field.name.trim() !== '')
+                .map((field: { name: string }) => `${normalizedBlockName}.${field.name}`)
+            } else {
+              blockTags = [normalizedBlockName]
+            }
+          }
+        } else if (sourceBlock.type === 'api_trigger' || sourceBlock.type === 'input_trigger') {
+          const inputFormatValue = mergedSubBlocks?.inputFormat?.value
+
+          if (inputFormatValue && Array.isArray(inputFormatValue) && inputFormatValue.length > 0) {
+            blockTags = inputFormatValue
+              .filter((field: { name?: string }) => field.name && field.name.trim() !== '')
+              .map((field: { name: string }) => `${normalizedBlockName}.${field.name}`)
+          } else {
+            blockTags = []
+          }
+        } else {
+          blockTags = [normalizedBlockName]
+        }
+      } else {
+        if (blockConfig.category === 'triggers' || sourceBlock.type === 'starter') {
+          const dynamicOutputs = getBlockOutputPaths(sourceBlock.type, mergedSubBlocks)
+          if (dynamicOutputs.length > 0) {
+            blockTags = dynamicOutputs.map((path) => `${normalizedBlockName}.${path}`)
+          } else if (sourceBlock.type === 'starter') {
+            blockTags = [normalizedBlockName]
+          } else if (sourceBlock.type === TRIGGER_TYPES.GENERIC_WEBHOOK) {
+            blockTags = [normalizedBlockName]
+          } else {
+            blockTags = []
+          }
+        } else if (sourceBlock?.triggerMode && blockConfig.triggers?.enabled) {
+          const dynamicOutputs = getBlockOutputPaths(sourceBlock.type, mergedSubBlocks, true)
+          if (dynamicOutputs.length > 0) {
+            blockTags = dynamicOutputs.map((path) => `${normalizedBlockName}.${path}`)
+          } else {
+            const outputPaths = getBlockOutputPaths(sourceBlock.type, mergedSubBlocks, true)
+            blockTags = outputPaths.map((path) => `${normalizedBlockName}.${path}`)
+          }
+        } else if (sourceBlock.type === 'human_in_the_loop') {
+          const dynamicOutputs = getBlockOutputPaths(sourceBlock.type, mergedSubBlocks)
+
+          const isSelfReference = activeSourceBlockId === blockId
+
+          if (dynamicOutputs.length > 0) {
+            const allTags = dynamicOutputs.map((path) => `${normalizedBlockName}.${path}`)
+            blockTags = isSelfReference
+              ? allTags.filter((tag) => tag.endsWith('.url') || tag.endsWith('.resumeEndpoint'))
+              : allTags
+          } else {
+            const outputPaths = getBlockOutputPaths(sourceBlock.type, mergedSubBlocks)
+            const allTags = outputPaths.map((path) => `${normalizedBlockName}.${path}`)
+            blockTags = isSelfReference
+              ? allTags.filter((tag) => tag.endsWith('.url') || tag.endsWith('.resumeEndpoint'))
+              : allTags
+          }
+        } else {
+          const toolOutputPaths = getToolOutputPaths(blockConfig, mergedSubBlocks)
+
+          if (toolOutputPaths.length > 0) {
+            blockTags = toolOutputPaths.map((path) => `${normalizedBlockName}.${path}`)
+          } else {
+            const outputPaths = getBlockOutputPaths(
+              sourceBlock.type,
+              mergedSubBlocks,
+              sourceBlock.triggerMode
+            )
+            blockTags = outputPaths.map((path) => `${normalizedBlockName}.${path}`)
+          }
         }
       }
 
@@ -1301,10 +1432,45 @@ export const TagDropdown: React.FC<TagDropdownProps> = ({
       const normalizedBlockName = normalizeName(blockName)
 
       const mergedSubBlocks = getMergedSubBlocks(accessibleBlockId)
+      const responseFormatValue = mergedSubBlocks?.responseFormat?.value
+      const responseFormat = parseResponseFormatSafely(responseFormatValue, accessibleBlockId)
 
       let blockTags: string[]
 
-      if (accessibleBlock.type === 'variables') {
+      if (blockConfig.category === 'triggers' || accessibleBlock.type === 'starter') {
+        const dynamicOutputs = getBlockOutputPaths(accessibleBlock.type, mergedSubBlocks)
+
+        if (dynamicOutputs.length > 0) {
+          blockTags = dynamicOutputs.map((path) => `${normalizedBlockName}.${path}`)
+        } else if (accessibleBlock.type === 'starter') {
+          const startWorkflowValue = mergedSubBlocks?.startWorkflow?.value
+          if (startWorkflowValue === 'chat') {
+            blockTags = [
+              `${normalizedBlockName}.input`,
+              `${normalizedBlockName}.conversationId`,
+              `${normalizedBlockName}.files`,
+            ]
+          } else {
+            blockTags = [normalizedBlockName]
+          }
+        } else if (accessibleBlock.type === TRIGGER_TYPES.GENERIC_WEBHOOK) {
+          blockTags = [normalizedBlockName]
+        } else {
+          blockTags = []
+        }
+      } else if (accessibleBlock.type === 'evaluator') {
+        const metricsValue = getSubBlockValue(accessibleBlockId, 'metrics')
+
+        if (metricsValue && Array.isArray(metricsValue) && metricsValue.length > 0) {
+          const validMetrics = metricsValue.filter((metric: { name?: string }) => metric?.name)
+          blockTags = validMetrics.map(
+            (metric: { name: string }) => `${normalizedBlockName}.${metric.name.toLowerCase()}`
+          )
+        } else {
+          const outputPaths = getBlockOutputPaths(accessibleBlock.type, mergedSubBlocks)
+          blockTags = outputPaths.map((path) => `${normalizedBlockName}.${path}`)
+        }
+      } else if (accessibleBlock.type === 'variables') {
         const variablesValue = getSubBlockValue(accessibleBlockId, 'variables')
 
         if (variablesValue && Array.isArray(variablesValue) && variablesValue.length > 0) {
@@ -1318,21 +1484,57 @@ export const TagDropdown: React.FC<TagDropdownProps> = ({
         } else {
           blockTags = [normalizedBlockName]
         }
-      } else {
-        const outputPaths = getEffectiveBlockOutputPaths(accessibleBlock.type, mergedSubBlocks, {
-          triggerMode: Boolean(accessibleBlock.triggerMode),
-          preferToolOutputs: !accessibleBlock.triggerMode,
-        })
-        const allTags = outputPaths.map((path) => `${normalizedBlockName}.${path}`)
-
-        if (accessibleBlock.type === 'human_in_the_loop' && accessibleBlockId === blockId) {
-          blockTags = allTags.filter(
-            (tag) => tag.endsWith('.url') || tag.endsWith('.resumeEndpoint')
-          )
-        } else if (allTags.length === 0) {
-          blockTags = [normalizedBlockName]
+      } else if (responseFormat) {
+        const schemaFields = extractFieldsFromSchema(responseFormat)
+        if (schemaFields.length > 0) {
+          blockTags = schemaFields.map((field) => `${normalizedBlockName}.${field.name}`)
         } else {
-          blockTags = allTags
+          const outputPaths = getBlockOutputPaths(
+            accessibleBlock.type,
+            mergedSubBlocks,
+            accessibleBlock.triggerMode
+          )
+          blockTags = outputPaths.map((path) => `${normalizedBlockName}.${path}`)
+        }
+      } else if (!blockConfig.outputs || Object.keys(blockConfig.outputs).length === 0) {
+        blockTags = [normalizedBlockName]
+      } else {
+        const blockState = blocks[accessibleBlockId]
+        if (blockState?.triggerMode && blockConfig.triggers?.enabled) {
+          const dynamicOutputs = getBlockOutputPaths(accessibleBlock.type, mergedSubBlocks, true)
+          if (dynamicOutputs.length > 0) {
+            blockTags = dynamicOutputs.map((path) => `${normalizedBlockName}.${path}`)
+          } else {
+            const outputPaths = getBlockOutputPaths(accessibleBlock.type, mergedSubBlocks, true)
+            blockTags = outputPaths.map((path) => `${normalizedBlockName}.${path}`)
+          }
+        } else if (accessibleBlock.type === 'human_in_the_loop') {
+          const dynamicOutputs = getBlockOutputPaths(accessibleBlock.type, mergedSubBlocks)
+
+          const isSelfReference = accessibleBlockId === blockId
+
+          if (dynamicOutputs.length > 0) {
+            const allTags = dynamicOutputs.map((path) => `${normalizedBlockName}.${path}`)
+            blockTags = isSelfReference
+              ? allTags.filter((tag) => tag.endsWith('.url') || tag.endsWith('.resumeEndpoint'))
+              : allTags
+          } else {
+            blockTags = [`${normalizedBlockName}.url`, `${normalizedBlockName}.resumeEndpoint`]
+          }
+        } else {
+          const toolOutputPaths = getToolOutputPaths(blockConfig, mergedSubBlocks)
+
+          if (toolOutputPaths.length > 0) {
+            blockTags = toolOutputPaths.map((path) => `${normalizedBlockName}.${path}`)
+          } else {
+            const outputPaths = getBlockOutputPaths(
+              accessibleBlock.type,
+              mergedSubBlocks,
+              accessibleBlock.triggerMode
+            )
+
+            blockTags = outputPaths.map((path) => `${normalizedBlockName}.${path}`)
+          }
         }
       }
 

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

@@ -1,5 +1,9 @@
 import { useShallow } from 'zustand/react/shallow'
-import { getEffectiveBlockOutputs } from '@/lib/workflows/blocks/block-outputs'
+import {
+  extractFieldsFromSchema,
+  parseResponseFormatSafely,
+} from '@/lib/core/utils/response-format'
+import { getBlockOutputs } from '@/lib/workflows/blocks/block-outputs'
 import { BlockPathCalculator } from '@/lib/workflows/blocks/block-path-calculator'
 import { useWorkflowRegistry } from '@/stores/workflows/registry/store'
 import { useSubBlockStore } from '@/stores/workflows/subblock/store'
@@ -16,7 +20,18 @@ export interface ConnectedBlock {
   type: string
   outputType: string | string[]
   name: string
+  responseFormat?: {
+    // Support both formats
+    fields?: Field[]
+    name?: string
+    schema?: {
+      type: string
+      properties: Record<string, any>
+      required?: string[]
+    }
+  }
   outputs?: Record<string, any>
+  operation?: string
 }
 
 export function useBlockConnections(blockId: string) {
@@ -88,28 +103,46 @@ export function useBlockConnections(blockId: string) {
       // Get merged subblocks for this source block
       const mergedSubBlocks = getMergedSubBlocks(sourceId)
 
-      const blockOutputs = getEffectiveBlockOutputs(sourceBlock.type, mergedSubBlocks, {
-        triggerMode: Boolean(sourceBlock.triggerMode),
-        preferToolOutputs: !sourceBlock.triggerMode,
-      })
+      // Get the response format from the subblock store
+      const responseFormatValue = useSubBlockStore.getState().getValue(sourceId, 'responseFormat')
 
-      const outputFields: Field[] = Object.entries(blockOutputs).map(
-        ([key, value]: [string, any]) => ({
+      // Safely parse response format with proper error handling
+      const responseFormat = parseResponseFormatSafely(responseFormatValue, sourceId)
+
+      // Get operation value for tool-based blocks
+      const operationValue = useSubBlockStore.getState().getValue(sourceId, 'operation')
+
+      // Use getBlockOutputs to properly handle dynamic outputs from inputFormat
+      const blockOutputs = getBlockOutputs(
+        sourceBlock.type,
+        mergedSubBlocks,
+        sourceBlock.triggerMode
+      )
+
+      // Extract fields from the response format if available, otherwise use block outputs
+      let outputFields: Field[]
+      if (responseFormat) {
+        outputFields = extractFieldsFromSchema(responseFormat)
+      } else {
+        // Convert block outputs to field format
+        outputFields = Object.entries(blockOutputs).map(([key, value]: [string, any]) => ({
           name: key,
           type: value && typeof value === 'object' && 'type' in value ? value.type : 'string',
           description:
             value && typeof value === 'object' && 'description' in value
               ? value.description
               : undefined,
-        })
-      )
+        }))
+      }
 
       return {
         id: sourceBlock.id,
         type: sourceBlock.type,
         outputType: outputFields.map((field: Field) => field.name),
         name: sourceBlock.name,
+        responseFormat,
         outputs: blockOutputs,
+        operation: operationValue,
         distance: nodeDistances.get(sourceId) || Number.POSITIVE_INFINITY,
       }
     })

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/hooks/use-block-output-fields.ts

@@ -1,7 +1,13 @@
 'use client'
 
 import { useMemo } from 'react'
-import { getEffectiveBlockOutputs } from '@/lib/workflows/blocks/block-outputs'
+import { extractFieldsFromSchema } from '@/lib/core/utils/response-format'
+import {
+  getBlockOutputPaths,
+  getBlockOutputs,
+  getToolOutputs,
+} from '@/lib/workflows/blocks/block-outputs'
+import { TRIGGER_TYPES } from '@/lib/workflows/triggers/triggers'
 import type { SchemaField } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/connection-blocks/components/field-item/field-item'
 import { getBlock } from '@/blocks'
 import { useSubBlockStore } from '@/stores/workflows/subblock/store'
@@ -70,7 +76,11 @@ const extractNestedFields = (properties: Record<string, any>): SchemaField[] =>
 /**
  * Creates a schema field from an output definition
  */
-const createFieldFromOutput = (name: string, output: any): SchemaField => {
+const createFieldFromOutput = (
+  name: string,
+  output: any,
+  responseFormatFields?: SchemaField[]
+): SchemaField => {
   const hasExplicitType = isObject(output) && typeof output.type === 'string'
   const type = hasExplicitType ? output.type : isObject(output) ? 'object' : 'string'
 
@@ -80,7 +90,11 @@ const createFieldFromOutput = (name: string, output: any): SchemaField => {
     description: isObject(output) && 'description' in output ? output.description : undefined,
   }
 
-  field.children = extractChildFields(output)
+  if (name === 'data' && responseFormatFields && responseFormatFields.length > 0) {
+    field.children = responseFormatFields
+  } else {
+    field.children = extractChildFields(output)
+  }
 
   return field
 }
@@ -89,6 +103,8 @@ interface UseBlockOutputFieldsParams {
   blockId: string
   blockType: string
   mergedSubBlocks?: Record<string, any>
+  responseFormat?: any
+  operation?: string
   triggerMode?: boolean
 }
 
@@ -100,6 +116,8 @@ export function useBlockOutputFields({
   blockId,
   blockType,
   mergedSubBlocks,
+  responseFormat,
+  operation,
   triggerMode,
 }: UseBlockOutputFieldsParams): SchemaField[] {
   return useMemo(() => {
@@ -120,6 +138,21 @@ export function useBlockOutputFields({
       return []
     }
 
+    // Handle evaluator blocks - use metrics if available
+    if (blockType === 'evaluator') {
+      const metricsValue = mergedSubBlocks?.metrics?.value ?? getSubBlockValue(blockId, 'metrics')
+
+      if (metricsValue && Array.isArray(metricsValue) && metricsValue.length > 0) {
+        const validMetrics = metricsValue.filter((metric: { name?: string }) => metric?.name)
+        return validMetrics.map((metric: { name: string }) => ({
+          name: metric.name.toLowerCase(),
+          type: 'number',
+          description: `Metric: ${metric.name}`,
+        }))
+      }
+      // Fall through to use blockConfig.outputs
+    }
+
     // Handle variables blocks - use variable assignments if available
     if (blockType === 'variables') {
       const variablesValue =
@@ -139,14 +172,123 @@ export function useBlockOutputFields({
       return []
     }
 
-    const baseOutputs = getEffectiveBlockOutputs(blockType, mergedSubBlocks, {
-      triggerMode: Boolean(triggerMode),
-      preferToolOutputs: !triggerMode,
-    }) as Record<string, any>
+    // Get base outputs using getBlockOutputs (handles triggers, starter, approval, etc.)
+    let baseOutputs: Record<string, any> = {}
+
+    if (blockConfig.category === 'triggers' || blockType === 'starter') {
+      // Use getBlockOutputPaths to get dynamic outputs, then reconstruct the structure
+      const outputPaths = getBlockOutputPaths(blockType, mergedSubBlocks, triggerMode)
+      if (outputPaths.length > 0) {
+        // Reconstruct outputs structure from paths
+        // This is a simplified approach - we'll use the paths to build the structure
+        baseOutputs = getBlockOutputs(blockType, mergedSubBlocks, triggerMode)
+      } else if (blockType === 'starter') {
+        const startWorkflowValue = mergedSubBlocks?.startWorkflow?.value
+        if (startWorkflowValue === 'chat') {
+          baseOutputs = {
+            input: { type: 'string', description: 'User message' },
+            conversationId: { type: 'string', description: 'Conversation ID' },
+            files: { type: 'file[]', description: 'Uploaded files' },
+          }
+        } else {
+          const inputFormatValue = mergedSubBlocks?.inputFormat?.value
+          if (inputFormatValue && Array.isArray(inputFormatValue) && inputFormatValue.length > 0) {
+            baseOutputs = {}
+            inputFormatValue.forEach((field: { name?: string; type?: string }) => {
+              if (field.name && field.name.trim() !== '') {
+                baseOutputs[field.name] = {
+                  type: field.type || 'string',
+                  description: `Field from input format`,
+                }
+              }
+            })
+          }
+        }
+      } else if (blockType === TRIGGER_TYPES.GENERIC_WEBHOOK) {
+        // Generic webhook returns the whole payload
+        baseOutputs = {}
+      } else {
+        baseOutputs = {}
+      }
+    } else if (triggerMode && blockConfig.triggers?.enabled) {
+      // Trigger mode enabled
+      const dynamicOutputs = getBlockOutputPaths(blockType, mergedSubBlocks, true)
+      if (dynamicOutputs.length > 0) {
+        baseOutputs = getBlockOutputs(blockType, mergedSubBlocks, true)
+      } else {
+        baseOutputs = blockConfig.outputs || {}
+      }
+    } else if (blockType === 'approval') {
+      // Approval block uses dynamic outputs from inputFormat
+      baseOutputs = getBlockOutputs(blockType, mergedSubBlocks)
+    } else {
+      // For tool-based blocks, try to get tool outputs first
+      const toolOutputs = blockConfig ? getToolOutputs(blockConfig, mergedSubBlocks) : {}
+
+      if (Object.keys(toolOutputs).length > 0) {
+        baseOutputs = toolOutputs
+      } else {
+        baseOutputs = getBlockOutputs(blockType, mergedSubBlocks, triggerMode)
+      }
+    }
+
+    // Handle responseFormat
+    const responseFormatFields = responseFormat ? extractFieldsFromSchema(responseFormat) : []
+
+    // If responseFormat exists and has fields, merge with base outputs
+    if (responseFormatFields.length > 0) {
+      // If base outputs is empty, use responseFormat fields directly
+      if (Object.keys(baseOutputs).length === 0) {
+        return responseFormatFields.map((field) => ({
+          name: field.name,
+          type: field.type,
+          description: field.description,
+          children: undefined, // ResponseFormat fields are flat
+        }))
+      }
+
+      // Otherwise, merge: responseFormat takes precedence for 'data' field
+      const fields: SchemaField[] = []
+      const responseFormatFieldNames = new Set(responseFormatFields.map((f) => f.name))
+
+      // Add base outputs, replacing 'data' with responseFormat fields if present
+      for (const [name, output] of Object.entries(baseOutputs)) {
+        if (name === 'data' && responseFormatFields.length > 0) {
+          fields.push(
+            createFieldFromOutput(
+              name,
+              output,
+              responseFormatFields.map((f) => ({
+                name: f.name,
+                type: f.type,
+                description: f.description,
+              }))
+            )
+          )
+        } else if (!responseFormatFieldNames.has(name)) {
+          fields.push(createFieldFromOutput(name, output))
+        }
+      }
+
+      // Add responseFormat fields that aren't in base outputs
+      for (const field of responseFormatFields) {
+        if (!baseOutputs[field.name]) {
+          fields.push({
+            name: field.name,
+            type: field.type,
+            description: field.description,
+          })
+        }
+      }
+
+      return fields
+    }
+
+    // No responseFormat, just use base outputs
     if (Object.keys(baseOutputs).length === 0) {
       return []
     }
 
     return Object.entries(baseOutputs).map(([name, output]) => createFieldFromOutput(name, output))
-  }, [blockId, blockType, mergedSubBlocks, triggerMode])
+  }, [blockId, blockType, mergedSubBlocks, responseFormat, operation, triggerMode])
 }

apps/sim/executor/utils/block-data.ts

@@ -1,4 +1,8 @@
-import { getEffectiveBlockOutputs } from '@/lib/workflows/blocks/block-outputs'
+import {
+  extractFieldsFromSchema,
+  parseResponseFormatSafely,
+} from '@/lib/core/utils/response-format'
+import { normalizeInputFormatValue } from '@/lib/workflows/input-format'
 import { isTriggerBehavior, normalizeName } from '@/executor/constants'
 import type { ExecutionContext } from '@/executor/types'
 import type { OutputSchema } from '@/executor/utils/block-reference'
@@ -8,6 +12,8 @@ import {
   isBranchNodeId,
 } from '@/executor/utils/subflow-utils'
 import type { SerializedBlock } from '@/serializer/types'
+import type { ToolConfig } from '@/tools/types'
+import { getTool } from '@/tools/utils'
 
 export interface BlockDataCollection {
   blockData: Record<string, unknown>
@@ -15,42 +21,118 @@ export interface BlockDataCollection {
   blockOutputSchemas: Record<string, OutputSchema>
 }
 
-interface SubBlockWithValue {
-  value?: unknown
-}
+/**
+ * Block types where inputFormat fields should be merged into outputs schema.
+ * These are blocks where users define custom fields via inputFormat that become
+ * valid output paths (e.g., <start.myField>, <webhook1.customField>, <hitl1.resumeField>).
+ *
+ * Note: This includes non-trigger blocks like 'starter' and 'human_in_the_loop' which
+ * have category 'blocks' but still need their inputFormat exposed as outputs.
+ */
+const BLOCKS_WITH_INPUT_FORMAT_OUTPUTS = [
+  'start_trigger',
+  'starter',
+  'api_trigger',
+  'input_trigger',
+  'generic_webhook',
+  'human_in_the_loop',
+] as const
 
-function paramsToSubBlocks(
-  params: Record<string, unknown> | undefined
-): Record<string, SubBlockWithValue> {
-  if (!params) return {}
-
-  const subBlocks: Record<string, SubBlockWithValue> = {}
-  for (const [key, value] of Object.entries(params)) {
-    subBlocks[key] = { value }
+function getInputFormatFields(block: SerializedBlock): OutputSchema {
+  const inputFormat = normalizeInputFormatValue(block.config?.params?.inputFormat)
+  if (inputFormat.length === 0) {
+    return {}
   }
-  return subBlocks
+
+  const schema: OutputSchema = {}
+  for (const field of inputFormat) {
+    if (!field.name) continue
+    schema[field.name] = { type: field.type || 'any' }
+  }
+
+  return schema
 }
 
-function getRegistrySchema(block: SerializedBlock): OutputSchema | undefined {
+function getEvaluatorMetricsSchema(block: SerializedBlock): OutputSchema | undefined {
+  if (block.metadata?.id !== 'evaluator') return undefined
+
+  const metrics = block.config?.params?.metrics
+  if (!Array.isArray(metrics) || metrics.length === 0) return undefined
+
+  const validMetrics = metrics.filter(
+    (m: { name?: string }) => m?.name && typeof m.name === 'string'
+  )
+  if (validMetrics.length === 0) return undefined
+
+  const schema: OutputSchema = { ...(block.outputs as OutputSchema) }
+  for (const metric of validMetrics) {
+    schema[metric.name.toLowerCase()] = { type: 'number' }
+  }
+  return schema
+}
+
+function getResponseFormatSchema(block: SerializedBlock): OutputSchema | undefined {
+  const responseFormatValue = block.config?.params?.responseFormat
+  if (!responseFormatValue) return undefined
+
+  const parsed = parseResponseFormatSafely(responseFormatValue, block.id)
+  if (!parsed) return undefined
+
+  const fields = extractFieldsFromSchema(parsed)
+  if (fields.length === 0) return undefined
+
+  const schema: OutputSchema = {}
+  for (const field of fields) {
+    schema[field.name] = { type: field.type || 'any' }
+  }
+  return schema
+}
+
+export function getBlockSchema(
+  block: SerializedBlock,
+  toolConfig?: ToolConfig
+): OutputSchema | undefined {
   const blockType = block.metadata?.id
-  if (!blockType) return undefined
 
-  const subBlocks = paramsToSubBlocks(block.config?.params)
-  const triggerMode = isTriggerBehavior(block)
-  const outputs = getEffectiveBlockOutputs(blockType, subBlocks, {
-    triggerMode,
-    preferToolOutputs: !triggerMode,
-    includeHidden: true,
-  }) as OutputSchema
-
-  if (!outputs || Object.keys(outputs).length === 0) {
-    return undefined
+  if (
+    blockType &&
+    BLOCKS_WITH_INPUT_FORMAT_OUTPUTS.includes(
+      blockType as (typeof BLOCKS_WITH_INPUT_FORMAT_OUTPUTS)[number]
+    )
+  ) {
+    const baseOutputs = (block.outputs as OutputSchema) || {}
+    const inputFormatFields = getInputFormatFields(block)
+    const merged = { ...baseOutputs, ...inputFormatFields }
+    if (Object.keys(merged).length > 0) {
+      return merged
+    }
   }
-  return outputs
-}
 
-export function getBlockSchema(block: SerializedBlock): OutputSchema | undefined {
-  return getRegistrySchema(block)
+  const evaluatorSchema = getEvaluatorMetricsSchema(block)
+  if (evaluatorSchema) {
+    return evaluatorSchema
+  }
+
+  const responseFormatSchema = getResponseFormatSchema(block)
+  if (responseFormatSchema) {
+    return responseFormatSchema
+  }
+
+  const isTrigger = isTriggerBehavior(block)
+
+  if (isTrigger && block.outputs && Object.keys(block.outputs).length > 0) {
+    return block.outputs as OutputSchema
+  }
+
+  if (toolConfig?.outputs && Object.keys(toolConfig.outputs).length > 0) {
+    return toolConfig.outputs as OutputSchema
+  }
+
+  if (block.outputs && Object.keys(block.outputs).length > 0) {
+    return block.outputs as OutputSchema
+  }
+
+  return undefined
 }
 
 export function collectBlockData(
@@ -88,7 +170,9 @@ export function collectBlockData(
       blockNameMapping[normalizeName(block.metadata.name)] = id
     }
 
-    const schema = getBlockSchema(block)
+    const toolId = block.config?.tool
+    const toolConfig = toolId ? getTool(toolId) : undefined
+    const schema = getBlockSchema(block, toolConfig)
     if (schema && Object.keys(schema).length > 0) {
       blockOutputSchemas[id] = schema
     }

apps/sim/executor/variables/resolvers/block.test.ts

@@ -6,6 +6,10 @@ import type { ResolutionContext } from './reference'
 
 vi.mock('@sim/logger', () => loggerMock)
 
+vi.mock('@/lib/workflows/blocks/block-outputs', () => ({
+  getBlockOutputs: vi.fn(() => ({})),
+}))
+
 function createTestWorkflow(
   blocks: Array<{
     id: string
@@ -140,22 +144,34 @@ describe('BlockResolver', () => {
       expect(resolver.resolve('<source.nonexistent>', ctx)).toBeUndefined()
     })
 
-    it.concurrent('should throw error for path not in output schema', () => {
+    it.concurrent('should throw error for path not in output schema', async () => {
+      const { getBlockOutputs } = await import('@/lib/workflows/blocks/block-outputs')
+      const mockGetBlockOutputs = vi.mocked(getBlockOutputs)
+      const customOutputs = {
+        validField: { type: 'string', description: 'A valid field' },
+        nested: {
+          child: { type: 'number', description: 'Nested child' },
+        },
+      }
+      mockGetBlockOutputs.mockReturnValue(customOutputs as any)
+
       const workflow = createTestWorkflow([
         {
           id: 'source',
-          type: 'start_trigger',
+          outputs: customOutputs,
         },
       ])
       const resolver = new BlockResolver(workflow)
       const ctx = createTestContext('current', {
-        source: { input: 'value' },
+        source: { validField: 'value', nested: { child: 42 } },
       })
 
       expect(() => resolver.resolve('<source.invalidField>', ctx)).toThrow(
         /"invalidField" doesn't exist on block "source"/
       )
       expect(() => resolver.resolve('<source.invalidField>', ctx)).toThrow(/Available fields:/)
+
+      mockGetBlockOutputs.mockReturnValue({})
     })
 
     it.concurrent('should return undefined for path in schema but missing in data', () => {
@@ -177,59 +193,6 @@ describe('BlockResolver', () => {
       expect(resolver.resolve('<source.optionalField>', ctx)).toBeUndefined()
     })
 
-    it.concurrent(
-      'should allow hiddenFromDisplay fields for pre-execution schema validation',
-      () => {
-        const workflow = createTestWorkflow([
-          {
-            id: 'workflow-block',
-            name: 'Workflow',
-            type: 'workflow',
-          },
-        ])
-        const resolver = new BlockResolver(workflow)
-        const ctx = createTestContext('current', {})
-
-        expect(resolver.resolve('<workflow.childTraceSpans>', ctx)).toBeUndefined()
-      }
-    )
-
-    it.concurrent(
-      'should allow hiddenFromDisplay fields for workflow_input pre-execution schema validation',
-      () => {
-        const workflow = createTestWorkflow([
-          {
-            id: 'workflow-input-block',
-            name: 'Workflow Input',
-            type: 'workflow_input',
-          },
-        ])
-        const resolver = new BlockResolver(workflow)
-        const ctx = createTestContext('current', {})
-
-        expect(resolver.resolve('<workflowinput.childTraceSpans>', ctx)).toBeUndefined()
-      }
-    )
-
-    it.concurrent(
-      'should allow hiddenFromDisplay fields for HITL pre-execution schema validation',
-      () => {
-        const workflow = createTestWorkflow([
-          {
-            id: 'hitl-block',
-            name: 'HITL',
-            type: 'human_in_the_loop',
-          },
-        ])
-        const resolver = new BlockResolver(workflow)
-        const ctx = createTestContext('current', {})
-
-        expect(resolver.resolve('<hitl.response>', ctx)).toBeUndefined()
-        expect(resolver.resolve('<hitl.submission>', ctx)).toBeUndefined()
-        expect(resolver.resolve('<hitl.resumeInput>', ctx)).toBeUndefined()
-      }
-    )
-
     it.concurrent('should return undefined for non-existent block', () => {
       const workflow = createTestWorkflow([{ id: 'existing' }])
       const resolver = new BlockResolver(workflow)

apps/sim/executor/variables/resolvers/block.ts

@@ -17,6 +17,7 @@ import {
   type Resolver,
 } from '@/executor/variables/resolvers/reference'
 import type { SerializedBlock, SerializedWorkflow } from '@/serializer/types'
+import { getTool } from '@/tools/utils'
 
 export class BlockResolver implements Resolver {
   private nameToBlockId: Map<string, string>
@@ -67,7 +68,9 @@ export class BlockResolver implements Resolver {
       blockData[blockId] = output
     }
 
-    const outputSchema = getBlockSchema(block)
+    const toolId = block.config?.tool
+    const toolConfig = toolId ? getTool(toolId) : undefined
+    const outputSchema = getBlockSchema(block, toolConfig)
 
     if (outputSchema && Object.keys(outputSchema).length > 0) {
       blockOutputSchemas[blockId] = outputSchema

apps/sim/lib/copilot/tools/client/workflow/block-output-utils.ts

@@ -1,4 +1,9 @@
-import { getEffectiveBlockOutputPaths } from '@/lib/workflows/blocks/block-outputs'
+import {
+  extractFieldsFromSchema,
+  parseResponseFormatSafely,
+} from '@/lib/core/utils/response-format'
+import { getBlockOutputPaths } from '@/lib/workflows/blocks/block-outputs'
+import { getBlock } from '@/blocks'
 import { normalizeName } from '@/executor/constants'
 import { useVariablesStore } from '@/stores/panel/variables/store'
 import type { Variable } from '@/stores/panel/variables/types'
@@ -87,6 +92,7 @@ export function getSubflowInsidePaths(
 
 export function computeBlockOutputPaths(block: BlockState, ctx: WorkflowContext): string[] {
   const { blocks, loops, parallels, subBlockValues } = ctx
+  const blockConfig = getBlock(block.type)
   const mergedSubBlocks = getMergedSubBlocks(blocks, subBlockValues, block.id)
 
   if (block.type === 'loop' || block.type === 'parallel') {
@@ -94,6 +100,15 @@ export function computeBlockOutputPaths(block: BlockState, ctx: WorkflowContext)
     return ['results', ...insidePaths]
   }
 
+  if (block.type === 'evaluator') {
+    const metricsValue = getSubBlockValue(blocks, subBlockValues, block.id, 'metrics')
+    if (metricsValue && Array.isArray(metricsValue) && metricsValue.length > 0) {
+      const validMetrics = metricsValue.filter((metric: { name?: string }) => metric?.name)
+      return validMetrics.map((metric: { name: string }) => metric.name.toLowerCase())
+    }
+    return getBlockOutputPaths(block.type, mergedSubBlocks)
+  }
+
   if (block.type === 'variables') {
     const variablesValue = getSubBlockValue(blocks, subBlockValues, block.id, 'variables')
     if (variablesValue && Array.isArray(variablesValue) && variablesValue.length > 0) {
@@ -107,10 +122,18 @@ export function computeBlockOutputPaths(block: BlockState, ctx: WorkflowContext)
     return []
   }
 
-  return getEffectiveBlockOutputPaths(block.type, mergedSubBlocks, {
-    triggerMode: Boolean(block.triggerMode),
-    preferToolOutputs: !block.triggerMode,
-  })
+  if (blockConfig) {
+    const responseFormatValue = mergedSubBlocks?.responseFormat?.value
+    const responseFormat = parseResponseFormatSafely(responseFormatValue, block.id)
+    if (responseFormat) {
+      const schemaFields = extractFieldsFromSchema(responseFormat)
+      if (schemaFields.length > 0) {
+        return schemaFields.map((field) => field.name)
+      }
+    }
+  }
+
+  return getBlockOutputPaths(block.type, mergedSubBlocks, block.triggerMode)
 }
 
 export function formatOutputsWithPrefix(paths: string[], blockName: string): string[] {

apps/sim/lib/copilot/tools/server/blocks/get-blocks-metadata-tool.ts

@@ -233,11 +233,7 @@ export const getBlocksMetadataServerTool: BaseServerTool<
           const resolvedToolId = resolveToolIdForOperation(blockConfig, opId)
           const toolCfg = resolvedToolId ? toolsRegistry[resolvedToolId] : undefined
           const toolParams: Record<string, any> = toolCfg?.params || {}
-          const toolOutputs: Record<string, any> = toolCfg?.outputs
-            ? Object.fromEntries(
-                Object.entries(toolCfg.outputs).filter(([_, def]) => !isHiddenFromDisplay(def))
-              )
-            : {}
+          const toolOutputs: Record<string, any> = toolCfg?.outputs || {}
           const filteredToolParams: Record<string, any> = {}
           for (const [k, v] of Object.entries(toolParams)) {
             if (!(k in blockInputs)) filteredToolParams[k] = v

apps/sim/lib/webhooks/utils.server.ts

@@ -527,17 +527,61 @@ export async function validateTwilioSignature(
   }
 }
 
-const SLACK_FILE_HOSTS = new Set(['files.slack.com', 'files-pri.slack.com'])
 const SLACK_MAX_FILE_SIZE = 50 * 1024 * 1024 // 50 MB
-const SLACK_MAX_FILES = 10
+const SLACK_MAX_FILES = 15
+
+/**
+ * Resolves the full file object from the Slack API when the event payload
+ * only contains a partial file (e.g. missing url_private due to file_access restrictions).
+ * @see https://docs.slack.dev/reference/methods/files.info
+ */
+async function resolveSlackFileInfo(
+  fileId: string,
+  botToken: string
+): Promise<{ url_private?: string; name?: string; mimetype?: string; size?: number } | null> {
+  try {
+    const response = await fetch(
+      `https://slack.com/api/files.info?file=${encodeURIComponent(fileId)}`,
+      {
+        headers: { Authorization: `Bearer ${botToken}` },
+      }
+    )
+
+    const data = (await response.json()) as {
+      ok: boolean
+      error?: string
+      file?: Record<string, any>
+    }
+
+    if (!data.ok || !data.file) {
+      logger.warn('Slack files.info failed', { fileId, error: data.error })
+      return null
+    }
+
+    return {
+      url_private: data.file.url_private,
+      name: data.file.name,
+      mimetype: data.file.mimetype,
+      size: data.file.size,
+    }
+  } catch (error) {
+    logger.error('Error calling Slack files.info', {
+      fileId,
+      error: error instanceof Error ? error.message : String(error),
+    })
+    return null
+  }
+}
 
 /**
  * Downloads file attachments from Slack using the bot token.
  * Returns files in the format expected by WebhookAttachmentProcessor:
  * { name, data (base64 string), mimeType, size }
  *
+ * When the event payload contains partial file objects (missing url_private),
+ * falls back to the Slack files.info API to resolve the full file metadata.
+ *
  * Security:
- * - Validates each url_private against allowlisted Slack file hosts
  * - Uses validateUrlWithDNS + secureFetchWithPinnedIP to prevent SSRF
  * - Enforces per-file size limit and max file count
  */
@@ -549,30 +593,31 @@ async function downloadSlackFiles(
   const downloaded: Array<{ name: string; data: string; mimeType: string; size: number }> = []
 
   for (const file of filesToProcess) {
-    const urlPrivate = file.url_private as string | undefined
+    let urlPrivate = file.url_private as string | undefined
+    let fileName = file.name as string | undefined
+    let fileMimeType = file.mimetype as string | undefined
+    let fileSize = file.size as number | undefined
+
+    // If url_private is missing, resolve via files.info API
+    if (!urlPrivate && file.id) {
+      const resolved = await resolveSlackFileInfo(file.id, botToken)
+      if (resolved?.url_private) {
+        urlPrivate = resolved.url_private
+        fileName = fileName || resolved.name
+        fileMimeType = fileMimeType || resolved.mimetype
+        fileSize = fileSize ?? resolved.size
+      }
+    }
+
     if (!urlPrivate) {
-      continue
-    }
-
-    // Validate the URL points to a known Slack file host
-    let parsedUrl: URL
-    try {
-      parsedUrl = new URL(urlPrivate)
-    } catch {
-      logger.warn('Slack file has invalid url_private, skipping', { fileId: file.id })
-      continue
-    }
-
-    if (!SLACK_FILE_HOSTS.has(parsedUrl.hostname)) {
-      logger.warn('Slack file url_private points to unexpected host, skipping', {
+      logger.warn('Slack file has no url_private and could not be resolved, skipping', {
         fileId: file.id,
-        hostname: sanitizeUrlForLog(urlPrivate),
       })
       continue
     }
 
     // Skip files that exceed the size limit
-    const reportedSize = Number(file.size) || 0
+    const reportedSize = Number(fileSize) || 0
     if (reportedSize > SLACK_MAX_FILE_SIZE) {
       logger.warn('Slack file exceeds size limit, skipping', {
         fileId: file.id,
@@ -618,9 +663,9 @@ async function downloadSlackFiles(
       }
 
       downloaded.push({
-        name: file.name || 'download',
+        name: fileName || 'download',
         data: buffer.toString('base64'),
-        mimeType: file.mimetype || 'application/octet-stream',
+        mimeType: fileMimeType || 'application/octet-stream',
         size: buffer.length,
       })
     } catch (error) {

apps/sim/lib/workflows/blocks/block-outputs.test.ts

@@ -1,73 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import {
-  getEffectiveBlockOutputPaths,
-  getEffectiveBlockOutputs,
-  getEffectiveBlockOutputType,
-} from '@/lib/workflows/blocks/block-outputs'
-
-type SubBlocks = Record<string, { value: unknown }>
-
-function rootPaths(paths: string[]): string[] {
-  return [...new Set(paths.map((path) => path.split('.')[0]).filter(Boolean))].sort()
-}
-
-describe('block outputs parity', () => {
-  it.concurrent('keeps evaluator tag paths and types aligned', () => {
-    const subBlocks: SubBlocks = {
-      metrics: {
-        value: [
-          {
-            name: 'Accuracy',
-            description: 'How accurate the answer is',
-            range: { min: 0, max: 1 },
-          },
-          {
-            name: 'Relevance',
-            description: 'How relevant the answer is',
-            range: { min: 0, max: 1 },
-          },
-        ],
-      },
-    }
-
-    const options = { triggerMode: false, preferToolOutputs: true }
-    const outputs = getEffectiveBlockOutputs('evaluator', subBlocks, options)
-    const paths = getEffectiveBlockOutputPaths('evaluator', subBlocks, options)
-
-    expect(rootPaths(paths)).toEqual(Object.keys(outputs).sort())
-    expect(paths).toContain('accuracy')
-    expect(paths).toContain('relevance')
-    expect(getEffectiveBlockOutputType('evaluator', 'accuracy', subBlocks, options)).toBe('number')
-    expect(getEffectiveBlockOutputType('evaluator', 'relevance', subBlocks, options)).toBe('number')
-  })
-
-  it.concurrent('keeps agent responseFormat tag paths and types aligned', () => {
-    const subBlocks: SubBlocks = {
-      responseFormat: {
-        value: {
-          name: 'calculator_output',
-          schema: {
-            type: 'object',
-            properties: {
-              min: { type: 'number' },
-              max: { type: 'number' },
-            },
-            required: ['min', 'max'],
-            additionalProperties: false,
-          },
-          strict: true,
-        },
-      },
-    }
-
-    const options = { triggerMode: false, preferToolOutputs: true }
-    const outputs = getEffectiveBlockOutputs('agent', subBlocks, options)
-    const paths = getEffectiveBlockOutputPaths('agent', subBlocks, options)
-
-    expect(rootPaths(paths)).toEqual(Object.keys(outputs).sort())
-    expect(paths).toContain('min')
-    expect(paths).toContain('max')
-    expect(getEffectiveBlockOutputType('agent', 'min', subBlocks, options)).toBe('number')
-    expect(getEffectiveBlockOutputType('agent', 'max', subBlocks, options)).toBe('number')
-  })
-})

apps/sim/lib/workflows/blocks/block-outputs.ts

@@ -33,12 +33,6 @@ interface SubBlockWithValue {
   value?: unknown
 }
 
-interface EffectiveOutputOptions {
-  triggerMode?: boolean
-  preferToolOutputs?: boolean
-  includeHidden?: boolean
-}
-
 type ConditionValue = string | number | boolean
 
 /**
@@ -102,13 +96,12 @@ function evaluateOutputCondition(
  */
 function filterOutputsByCondition(
   outputs: OutputDefinition,
-  subBlocks: Record<string, SubBlockWithValue> | undefined,
-  includeHidden = false
+  subBlocks: Record<string, SubBlockWithValue> | undefined
 ): OutputDefinition {
   const filtered: OutputDefinition = {}
 
   for (const [key, value] of Object.entries(outputs)) {
-    if (!includeHidden && isHiddenFromDisplay(value)) continue
+    if (isHiddenFromDisplay(value)) continue
 
     if (!value || typeof value !== 'object' || !('condition' in value)) {
       filtered[key] = value
@@ -119,13 +112,8 @@ function filterOutputsByCondition(
     const passes = !condition || evaluateOutputCondition(condition, subBlocks)
 
     if (passes) {
-      if (includeHidden) {
-        const { condition: _, ...rest } = value
-        filtered[key] = rest
-      } else {
-        const { condition: _, hiddenFromDisplay: __, ...rest } = value
-        filtered[key] = rest
-      }
+      const { condition: _, hiddenFromDisplay: __, ...rest } = value
+      filtered[key] = rest
     }
   }
 
@@ -255,10 +243,8 @@ function applyInputFormatToOutputs(
 export function getBlockOutputs(
   blockType: string,
   subBlocks?: Record<string, SubBlockWithValue>,
-  triggerMode?: boolean,
-  options?: { includeHidden?: boolean }
+  triggerMode?: boolean
 ): OutputDefinition {
-  const includeHidden = options?.includeHidden ?? false
   const blockConfig = getBlock(blockType)
   if (!blockConfig) return {}
 
@@ -283,8 +269,7 @@ export function getBlockOutputs(
     // Start with block config outputs (respects hiddenFromDisplay via filterOutputsByCondition)
     const baseOutputs = filterOutputsByCondition(
       { ...(blockConfig.outputs || {}) } as OutputDefinition,
-      subBlocks,
-      includeHidden
+      subBlocks
     )
 
     // Add inputFormat fields (resume form fields)
@@ -307,111 +292,29 @@ export function getBlockOutputs(
     return getLegacyStarterOutputs(subBlocks)
   }
 
-  const baseOutputs = { ...(blockConfig.outputs || {}) }
-  const filteredOutputs = filterOutputsByCondition(baseOutputs, subBlocks, includeHidden)
-  return applyInputFormatToOutputs(blockType, blockConfig, subBlocks, filteredOutputs)
-}
-
-export function getResponseFormatOutputs(
-  subBlocks?: Record<string, SubBlockWithValue>,
-  blockId = 'block'
-): OutputDefinition | undefined {
-  const responseFormatValue = subBlocks?.responseFormat?.value
-  if (!responseFormatValue) return undefined
-
-  const parsed = parseResponseFormatSafely(responseFormatValue, blockId)
-  if (!parsed) return undefined
-
-  const fields = extractFieldsFromSchema(parsed)
-  if (fields.length === 0) return undefined
-
-  const outputs: OutputDefinition = {}
-  for (const field of fields) {
-    outputs[field.name] = {
-      type: (field.type || 'any') as any,
-      description: field.description || `Field from Agent: ${field.name}`,
-    }
-  }
-
-  return outputs
-}
-
-export function getEvaluatorMetricOutputs(
-  subBlocks?: Record<string, SubBlockWithValue>
-): OutputDefinition | undefined {
-  const metricsValue = subBlocks?.metrics?.value
-  if (!metricsValue || !Array.isArray(metricsValue) || metricsValue.length === 0) return undefined
-
-  const validMetrics = metricsValue.filter((metric: { name?: string }) => metric?.name)
-  if (validMetrics.length === 0) return undefined
-
-  const outputs: OutputDefinition = {}
-  for (const metric of validMetrics as Array<{ name: string }>) {
-    outputs[metric.name.toLowerCase()] = {
-      type: 'number',
-      description: `Metric score: ${metric.name}`,
-    }
-  }
-
-  return outputs
-}
-
-export function getEffectiveBlockOutputs(
-  blockType: string,
-  subBlocks?: Record<string, SubBlockWithValue>,
-  options?: EffectiveOutputOptions
-): OutputDefinition {
-  const triggerMode = options?.triggerMode ?? false
-  const preferToolOutputs = options?.preferToolOutputs ?? !triggerMode
-  const includeHidden = options?.includeHidden ?? false
-
   if (blockType === 'agent') {
-    const responseFormatOutputs = getResponseFormatOutputs(subBlocks, 'agent')
-    if (responseFormatOutputs) return responseFormatOutputs
-  }
-
-  let baseOutputs: OutputDefinition
-  if (triggerMode) {
-    baseOutputs = getBlockOutputs(blockType, subBlocks, true, { includeHidden })
-  } else if (preferToolOutputs) {
-    const blockConfig = getBlock(blockType)
-    const toolOutputs = blockConfig
-      ? (getToolOutputs(blockConfig, subBlocks, { includeHidden }) as OutputDefinition)
-      : {}
-    baseOutputs =
-      toolOutputs && Object.keys(toolOutputs).length > 0
-        ? toolOutputs
-        : getBlockOutputs(blockType, subBlocks, false, { includeHidden })
-  } else {
-    baseOutputs = getBlockOutputs(blockType, subBlocks, false, { includeHidden })
-  }
-
-  if (blockType === 'evaluator') {
-    const metricOutputs = getEvaluatorMetricOutputs(subBlocks)
-    if (metricOutputs) {
-      return { ...baseOutputs, ...metricOutputs }
+    const responseFormatValue = subBlocks?.responseFormat?.value
+    if (responseFormatValue) {
+      const parsed = parseResponseFormatSafely(responseFormatValue, 'agent')
+      if (parsed) {
+        const fields = extractFieldsFromSchema(parsed)
+        if (fields.length > 0) {
+          const outputs: OutputDefinition = {}
+          for (const field of fields) {
+            outputs[field.name] = {
+              type: (field.type || 'any') as any,
+              description: field.description || `Field from Agent: ${field.name}`,
+            }
+          }
+          return outputs
+        }
+      }
     }
   }
 
-  return baseOutputs
-}
-
-export function getEffectiveBlockOutputPaths(
-  blockType: string,
-  subBlocks?: Record<string, SubBlockWithValue>,
-  options?: EffectiveOutputOptions
-): string[] {
-  const outputs = getEffectiveBlockOutputs(blockType, subBlocks, options)
-  const paths = generateOutputPaths(outputs)
-
-  if (blockType === TRIGGER_TYPES.START) {
-    return paths.filter((path) => {
-      const key = path.split('.')[0]
-      return !shouldFilterReservedField(blockType, key, '', subBlocks)
-    })
-  }
-
-  return paths
+  const baseOutputs = { ...(blockConfig.outputs || {}) }
+  const filteredOutputs = filterOutputsByCondition(baseOutputs, subBlocks)
+  return applyInputFormatToOutputs(blockType, blockConfig, subBlocks, filteredOutputs)
 }
 
 function shouldFilterReservedField(
@@ -449,6 +352,24 @@ function isFileOutputDefinition(value: unknown): value is { type: FileOutputType
   return type === 'file' || type === 'file[]'
 }
 
+export function getBlockOutputPaths(
+  blockType: string,
+  subBlocks?: Record<string, SubBlockWithValue>,
+  triggerMode?: boolean
+): string[] {
+  const outputs = getBlockOutputs(blockType, subBlocks, triggerMode)
+  const paths = generateOutputPaths(outputs)
+
+  if (blockType === TRIGGER_TYPES.START) {
+    return paths.filter((path) => {
+      const key = path.split('.')[0]
+      return !shouldFilterReservedField(blockType, key, '', subBlocks)
+    })
+  }
+
+  return paths
+}
+
 function getFilePropertyType(outputs: OutputDefinition, pathParts: string[]): string | null {
   const lastPart = pathParts[pathParts.length - 1]
   if (!lastPart || !USER_FILE_PROPERTY_TYPES[lastPart as keyof typeof USER_FILE_PROPERTY_TYPES]) {
@@ -532,13 +453,13 @@ function extractType(value: unknown): string {
   return typeof value === 'string' ? value : 'any'
 }
 
-export function getEffectiveBlockOutputType(
+export function getBlockOutputType(
   blockType: string,
   outputPath: string,
   subBlocks?: Record<string, SubBlockWithValue>,
-  options?: EffectiveOutputOptions
+  triggerMode?: boolean
 ): string {
-  const outputs = getEffectiveBlockOutputs(blockType, subBlocks, options)
+  const outputs = getBlockOutputs(blockType, subBlocks, triggerMode)
 
   const cleanPath = outputPath.replace(/\[(\d+)\]/g, '')
   const pathParts = cleanPath.split('.').filter(Boolean)
@@ -610,6 +531,60 @@ function generateOutputPaths(outputs: Record<string, any>, prefix = ''): string[
   return paths
 }
 
+/**
+ * Recursively generates all output paths with their types from an outputs schema.
+ *
+ * @param outputs - The outputs schema object
+ * @param prefix - Current path prefix for recursion
+ * @returns Array of objects containing path and type for each output field
+ */
+function generateOutputPathsWithTypes(
+  outputs: Record<string, any>,
+  prefix = ''
+): Array<{ path: string; type: string }> {
+  const paths: Array<{ path: string; type: string }> = []
+
+  for (const [key, value] of Object.entries(outputs)) {
+    const currentPath = prefix ? `${prefix}.${key}` : key
+
+    if (typeof value === 'string') {
+      paths.push({ path: currentPath, type: value })
+    } else if (typeof value === 'object' && value !== null) {
+      if ('type' in value && typeof value.type === 'string') {
+        if (isFileOutputDefinition(value)) {
+          paths.push({ path: currentPath, type: value.type })
+          for (const prop of USER_FILE_ACCESSIBLE_PROPERTIES) {
+            paths.push({
+              path: `${currentPath}.${prop}`,
+              type: USER_FILE_PROPERTY_TYPES[prop as keyof typeof USER_FILE_PROPERTY_TYPES],
+            })
+          }
+          continue
+        }
+
+        if (value.type === 'array' && value.items?.properties) {
+          paths.push({ path: currentPath, type: 'array' })
+          const subPaths = generateOutputPathsWithTypes(value.items.properties, currentPath)
+          paths.push(...subPaths)
+        } else if ((value.type === 'object' || value.type === 'json') && value.properties) {
+          paths.push({ path: currentPath, type: value.type })
+          const subPaths = generateOutputPathsWithTypes(value.properties, currentPath)
+          paths.push(...subPaths)
+        } else {
+          paths.push({ path: currentPath, type: value.type })
+        }
+      } else {
+        const subPaths = generateOutputPathsWithTypes(value, currentPath)
+        paths.push(...subPaths)
+      }
+    } else {
+      paths.push({ path: currentPath, type: 'any' })
+    }
+  }
+
+  return paths
+}
+
 /**
  * Gets the tool outputs for a block operation.
  *
@@ -619,10 +594,8 @@ function generateOutputPaths(outputs: Record<string, any>, prefix = ''): string[
  */
 export function getToolOutputs(
   blockConfig: BlockConfig,
-  subBlocks?: Record<string, SubBlockWithValue>,
-  options?: { includeHidden?: boolean }
+  subBlocks?: Record<string, SubBlockWithValue>
 ): Record<string, any> {
-  const includeHidden = options?.includeHidden ?? false
   if (!blockConfig?.tools?.config?.tool) return {}
 
   try {
@@ -640,18 +613,49 @@ export function getToolOutputs(
 
     const toolConfig = getTool(toolId)
     if (!toolConfig?.outputs) return {}
-    if (includeHidden) {
-      return toolConfig.outputs
-    }
-    return Object.fromEntries(
-      Object.entries(toolConfig.outputs).filter(([_, def]) => !isHiddenFromDisplay(def))
-    )
+
+    return toolConfig.outputs
   } catch (error) {
     logger.warn('Failed to get tool outputs', { error })
     return {}
   }
 }
 
+export function getToolOutputPaths(
+  blockConfig: BlockConfig,
+  subBlocks?: Record<string, SubBlockWithValue>
+): string[] {
+  const outputs = getToolOutputs(blockConfig, subBlocks)
+
+  if (!outputs || Object.keys(outputs).length === 0) return []
+
+  if (subBlocks && blockConfig.outputs) {
+    const filteredOutputs: Record<string, any> = {}
+
+    for (const [key, value] of Object.entries(outputs)) {
+      const blockOutput = blockConfig.outputs[key]
+
+      if (!blockOutput || typeof blockOutput !== 'object') {
+        filteredOutputs[key] = value
+        continue
+      }
+
+      const condition = 'condition' in blockOutput ? blockOutput.condition : undefined
+      if (condition) {
+        if (evaluateOutputCondition(condition, subBlocks)) {
+          filteredOutputs[key] = value
+        }
+      } else {
+        filteredOutputs[key] = value
+      }
+    }
+
+    return generateOutputPaths(filteredOutputs)
+  }
+
+  return generateOutputPaths(outputs)
+}
+
 /**
  * Generates output paths from a schema definition.
  *
@@ -661,3 +665,24 @@ export function getToolOutputs(
 export function getOutputPathsFromSchema(outputs: Record<string, any>): string[] {
   return generateOutputPaths(outputs)
 }
+
+/**
+ * Gets the output type for a specific path in a tool's outputs.
+ *
+ * @param blockConfig - The block configuration containing tools config
+ * @param subBlocks - SubBlock values for tool selection
+ * @param path - The dot-separated path to the output field
+ * @returns The type of the output field, or 'any' if not found
+ */
+export function getToolOutputType(
+  blockConfig: BlockConfig,
+  subBlocks: Record<string, SubBlockWithValue> | undefined,
+  path: string
+): string {
+  const outputs = getToolOutputs(blockConfig, subBlocks)
+  if (!outputs || Object.keys(outputs).length === 0) return 'any'
+
+  const pathsWithTypes = generateOutputPathsWithTypes(outputs)
+  const matchingPath = pathsWithTypes.find((p) => p.path === path)
+  return matchingPath?.type || 'any'
+}