How to give hint in Java that two type parameters are actually the same type?

<!-- language-all: lang-java -->

I'm working with AOSP's CaptureRequest and its associated CaptureRequest.Builder classes, and have (albeit very unusual case of) a need to copy settings key-values from an existing instance of CaptureRequest to a new instance of CaptureRequest.Builder¹.

The basic code here that I want to run is the following:

        for(CaptureRequest.Key<?> key : request.getKeys()) {
builder.set(key, request.get(key));
}

... where CaptureRequest.Builder.set() function is defined as <T> void set(Key<T> key, T value), and CaptureRequest.get() is defined as <T> T get(Key<T> key).
But that makes compiler barf with the following error:

Source.java:2: error: method set in class Builder cannot be applied to given types;
builder.set(key, request.get(key));
^
required: Key<T>,T
found: Key<CAP#1>,CAP#2
reason: inferred type does not conform to lower bound(s)
inferred: CAP#1
lower bound(s): Object
where T is a type-variable:
T extends Object declared in method <T>set(Key<T>,T)
where CAP#1,CAP#2 are fresh type-variables:
CAP#1 extends Object from capture of ?
CAP#2 extends Object from capture of ?

If I'm interpreting the error correctly, it's trying to say that it cannot relate <T>s of two functions as being the same one T. So to give it a hint that it's the same T, I created some helper functions that should make it obvious that it's the same T, and so I have this:

private static <T> T getKeyValue(CaptureRequest request, CaptureRequest.Key<T> key) {
return (T)request.<T>get(key);
}
private static <T> void setKeyValue(CaptureRequest.Builder builder, CaptureRequest.Key<T> key) {
builder.<T>set(key, (T)MyClass.<T>getKeyValue(key));
}
.....
for(CaptureRequest.Key<?> key : request.getKeys()) {
setKeyValue(builder, key);
}

This fails to pacify the Java compiler and it spits out very similar error to the previous one:

  Source.java:6: error: method getKeyValue in class MyClass cannot be applied to given types;
builder.<T>set(key, (T)MyClass.<T>getKeyValue(key));
^
required: CaptureRequest,Key<T#1>
found: Key<T#2>
reason: actual and formal argument lists differ in length
where T#1,T#2 are type-variables:
T#1 extends Object declared in method <T#1>getKeyValue(CaptureRequest,Key<T#1>)
T#2 extends Object declared in method <T#2>setKeyValue(Builder,Key<T#2>)

How can I perform this [what should be simple] copy of key-values in a sane way?

¹ Yes, I know that's weird and a bit backwards from typical use of API, hence "unusual". Context is that already built request (beyond library's scope) is percolating through a library that needs to shadow request with its own, mostly mimicking the original, but slightly amended, and said library doesn't have access to original builder to build the shadow sibling request. Yes, it's weird and is beyond the scope of this question. This question is really about Java's template methods and apparent compilation error.

Why not just:

builder.set((CaptureRequest.Key<Object>)key, request.get(key));

Pretty sure it should work.