Method resolveInputs

apps/sim/executor/variables/resolver.ts:229–291

(
    ctx: ExecutionContext,
    currentNodeId: string,
    params: Record<string, any>,
    block?: SerializedBlock
  )

  }

  async resolveInputs(
    ctx: ExecutionContext,
    currentNodeId: string,
    params: Record<string, any>,
    block?: SerializedBlock
  ): Promise<Record<string, any>> {
    if (!params) {
      return {}
    }
    const resolved: Record<string, any> = {}

    const isConditionBlock = block?.metadata?.id === BlockType.CONDITION
    if (isConditionBlock && typeof params.conditions === 'string') {
      try {
        const parsed = JSON.parse(params.conditions)
        if (Array.isArray(parsed)) {
          resolved.conditions = await Promise.all(
            parsed.map(async (cond: any) => ({
              ...cond,
              value:
                typeof cond.value === 'string'
                  ? await this.resolveTemplateWithoutConditionFormatting(
                      ctx,
                      currentNodeId,
                      cond.value
                    )
                  : cond.value,
            }))
          )
        } else {
          resolved.conditions = await this.resolveValue(
            ctx,
            currentNodeId,
            params.conditions,
            undefined,
            block
          )
        }
      } catch (parseError) {
        logger.warn('Failed to parse conditions JSON, falling back to normal resolution', {
          error: parseError,
          conditions: params.conditions,
        })
        resolved.conditions = await this.resolveValue(
          ctx,
          currentNodeId,
          params.conditions,
          undefined,
          block
        )
      }
    }

    for (const [key, value] of Object.entries(params)) {
      if (isConditionBlock && key === 'conditions') {
        continue
      }
      resolved[key] = await this.resolveValue(ctx, currentNodeId, value, undefined, block, {