Merge n sorted iterators
There are no docstrings. What do these functions do? What arguments do they take? What do they return?
Decorators are normally named after the effect they have on the decorated function. For example @functools.lru_cache adds an LRU cache to a function; @unittest.skip causes a test case to be skipped, and so on.

The effect of @from_iterable is that it converts the arguments into a tuple and passes that tuple as a single argument to the original function. I would not have guessed this functionality from the name; in fact I would have guessed the reverse (that it would convert a single iterable argument to individual arguments).
It was established in comments that the intention of this decorator is to transform a function into a pair of functions like chain and chain.from_iterable (where the original function becomes available under the latter name, and the new function under the former name).

The trouble with this is that chain was a mistake. If we only had chain.from_iterable, then we would not need chain, because we could just make a tuple: we'd write chain.from_iterable((arg1, arg2, ...)) instead of chain(arg1, arg2, ...). This is a trivial change to calling convention (just two parentheses) that does not need another function to support it. (For example, it would be ridiculous to have sorted and sorted.from_iterable.)

The Python developers were constrained by backwards compatibility to leave chain alone, and so the only thing they could do was add another function. I don't think they intended it to be a pattern to be followed (it's certainly not used anywhere else in the standard library). To this day, Python programmers looking for a "flatten" function are surprised to find that it already exists in the standard library under an obscure name.

Note that the code in the post does not actually use merge, it only uses merge.from_iterable. So the obvious thing to do would be to write merge so that it takes an iterable, and avoid the need for the @from_iterable decorator and its associated confusion.
Since headA and headB are not used independently of each other, you could change the calling convention for MergeLists so that it took an arbitrary number of linked lists, like this:

def merge_linked_lists(*lists):
    "Merge multiple sorted linked lists."
    return merge(map(iter_nodes, lists))

The expression:

str(i) for i in vals


can be written:

map(str, vals)


Or if you prefer the comprehension, then consider improving the name of the loop variable. The name i is conventionally used for an index, but here we are not iterating over indexes, but over values, so v or value would be clearer.
The code in merge does not use the built-in function id, so there is no need to respell the variable as id_ in order to avoid shadowing the built-in.
The function merge maintains two data structures. The dictionary source maps a source id to an iterator over the corresponding source, and the dictionary values maps a source id to the value at the front of the corresponding source. The code would be simplified if the two data structures were combined into one, like this:

def merge(iterables):
    "Merge sorted iterables."
    entries = {} # Map from id to [front value, id, iterator].
    for id, it in enumerate(map(iter, iterables)):
        try:
            entries[id] = [next(it), id, it]
        except StopIteration:
            pass
    by_value = operator.itemgetter(1)
    while entries:
        id, entry = min(entries.items(), key=by_value)
        value, _, it = entry
        yield value
        try:
            entry[0] = next(it)
        except StopIteration:
            del entries[id]

The runtime bottleneck is the call to min to find the entry with the smallest value. This takes time proportional to the number of remaining iterables, that is, \$O(l)\$.

We can improve this to \$O(\log l)\$ if we keep the entries in a heap, using the heapq module:

from heapq import heapify, heappop, heapreplace

def merge(iterables):
    "Merge sorted iterables."
    entries = []          # Heap of [front value, id, iterator].
    for id, it in enumerate(map(iter, iterables)):
        try:
            entries.append([next(it), id, it])
        except StopIteration:
            pass
    heapify(entries)
    while entries:
        value, _, it = entry = entries[0]
        yield value
        try:
            entry[0] = next(it)
            heapreplace(entries, entry)
        except StopIteration:
            heappop(entries)


This improves the overall runtime to \$O((n + l)\log l)\$.
This is already built into Python as heapq.merge. It's worth taking a look at the source code — the code in §8 above is a simplified version of this.