I'm actually a grad student on the team at Stanford that's been developing Stanford Dependencies (on which Universal Dependencies is based), so I think I can clarify things for you.
You're assuming that SD and UD are theories, which they are not. They're frameworks for annotating strings of words, and they never claim to be predictive in any way. The goal of generative syntactic theory is to define formally the set of acceptable sentences in a language; that is, you feed the grammar a string, and if it can come up with an acceptable constituency structure for it then the grammar returns "true", and if not, it returns "false". That's it--it makes no claims about psychological plausibility or computational feasibility. SD (and UD) has a different goal--it doesn't try to make claims about psychological plausibility or about grammaticality, but it does try to be useful for computational research. Comparing SD to something like Minimalism is like comparing pens to pencils--it may look like they do the same thing, but there are fundamental differences between them that often render one totally unsuitable to the task at hand.
Our framework actually does draw very heavily from theoretical linguistics, just not from Chomskyan linguistics, looking to LFG for answers instead. In LFG, constituent structure involves relations between tree nodes, like "specifier", "head", and "complement". But these trees don't get mapped directly to semantics--they first get mapped to functional structure, an intermediate level that involves grammatical function relations like "subject", "object", and "clausal complement" (compare these to the UD relations "nsubj", "dobj", and "ccomp"). This bipartite system of syntax makes tons of things easier from a theoretical perspective (Warlpiri is the go-to example). You're mistakenly assuming our framework is a representation of c-structure--where you're certainly right that empirically, functional material tends to be heads--when in fact it aims to be closer to f-structure--where LFG prefers to analyze lexical material as heads.
I should also mention that we at Stanford have a parser that automatically produces UD-style dependency trees, and the way it does this is by first parsing the sentences into tree structures, and then running lots of complicated tregex expressions over those trees to pull out grammatical functions; this is highly reminiscent of how LFG operates. So it actually does make a lot of sense from a theoretical perspective, as long as you see it through the right theory.
SD and UD have really been designed for NLP. NLP people don't care about whether the tools they're using are theoretically well-motivated--they care about whether their model does better than everyone else's, and our dependency representations help them do that. Relation extraction is one example of a computational task that's easy with SD and difficult with a traditional tree grammar. At first glance it seems simple--all you have to do is pull out triples of "predicate(agent,patient)" from a collection of sentences. But, in a tree structure, this gets very messy, because the agent can occur in a wide variety of different tree structure positions. In SD, we abstract away from a lot of this extra noise, which makes the job more manageable for our users (and we even have special relations for passive sentences to make this task even easier).
So, to summarize: SD/USD doesn't make any claims about the existence of phrase structure categories (such as nonfinite VPs or PPs) because a) it's not meant to be theoretically predictive and b) it's meant to represent functional structure, not constituent structure. SD/USD is taken seriously in computational circles because it is easier to apply to practical applications, such as relation extraction, than theoretically motivated constituency structure trees. The USD approach to function words is not a matter of theoretical debate in computational circles, but it is sometimes noted when the choice of hierarchical vs flat structure affects performance. Our SD/USD parser actually does have the option to produce hierarchical structure if the user so desires, where copulas, auxiliaries, and prepositions are heads. But I don't know of any schemes where hierarchical structure is hard-coded in.
I hope that answers the questions you had.