@@ -1752,17 +1752,39 @@ def check_callable_call(
             freeze_all_type_vars(fresh_ret_type)
             callee = callee.copy_modified(ret_type=fresh_ret_type)
 
+        formal_to_actual: list[list[int]] | None = None
         if callee.is_generic():
             callee = freshen_function_type_vars(callee)
+            callee_before_context = callee
             callee = self.infer_function_type_arguments_using_context(callee, context)
+            if callee != callee_before_context:
+                formal_to_actual = map_actuals_to_formals(
+                    arg_kinds,
+                    arg_names,
+                    callee.arg_kinds,
+                    callee.arg_names,
+                    lambda i: self.accept(args[i]),
+                )
+                if self.should_infer_args_without_context(
+                    callee_before_context,
+                    callee,
+                    args,
+                    arg_kinds,
+                    arg_names,
+                    formal_to_actual,
+                    context,
+                ):
+                    callee = callee_before_context
+                    formal_to_actual = None
 
-        formal_to_actual = map_actuals_to_formals(
-            arg_kinds,
-            arg_names,
-            callee.arg_kinds,
-            callee.arg_names,
-            lambda i: self.accept(args[i]),
-        )
+        if formal_to_actual is None:
+            formal_to_actual = map_actuals_to_formals(
+                arg_kinds,
+                arg_names,
+                callee.arg_kinds,
+                callee.arg_names,
+                lambda i: self.accept(args[i]),
+            )
 
         if callee.special_sig == "tuple" and len(args) == 1:
             with self.msg.filter_errors():
@@ -2061,6 +2083,112 @@ def infer_arg_types_in_context(
                 res.append(self.accept(arg))
         return res
 
+    def should_infer_args_without_context(
+        self,
+        callee: CallableType,
+        contextual_callee: CallableType,
+        args: list[Expression],
+        arg_kinds: list[ArgKind],
+        arg_names: Sequence[str | None] | None,
+        formal_to_actual: list[list[int]],
+        context: Context,
+    ) -> bool:
+        """Should we abandon contextual type argument inference for this call?
+
+        Context can infer a wider type argument than the actual argument supports when
+        the type variable also appears in an invariant or callback argument position.
+        In that case we can use regular argument inference instead, but only if it
+        produces a valid call whose return type still satisfies the outer context.
+        """
+        if contextual_callee.special_sig is not None or contextual_callee.is_type_obj():
+            # Keep the previous behavior for special synthetic signatures and type object
+            # calls, where context is often intentionally used to produce better errors.
+            return False
+
+        valid = True
+
+        def check_arg(
+            caller_type: Type,
+            original_caller_type: Type,
+            caller_kind: ArgKind,
+            callee_type: Type,
+            n: int,
+            m: int,
+            callee: CallableType,
+            object_type: Type | None,
+            context: Context,
+            outer_context: Context,
+        ) -> None:
+            nonlocal valid
+            if not is_subtype(
+                get_proper_type(caller_type),
+                get_proper_type(callee_type),
+                options=self.chk.options,
+            ):
+                valid = False
+
+        validation_callee = contextual_callee
+        validation_formal_to_actual = formal_to_actual
+        with self.msg.filter_errors(), self.chk.local_type_map:
+            if validation_callee.is_generic():
+                need_refresh = any(
+                    isinstance(v, (ParamSpecType, TypeVarTupleType))
+                    for v in validation_callee.variables
+                )
+                validation_callee = self.infer_function_type_arguments(
+                    validation_callee,
+                    args,
+                    arg_kinds,
+                    arg_names,
+                    validation_formal_to_actual,
+                    need_refresh,
+                    context,
+                )
+                if need_refresh:
+                    validation_formal_to_actual = map_actuals_to_formals(
+                        arg_kinds,
+                        arg_names,
+                        validation_callee.arg_kinds,
+                        validation_callee.arg_names,
+                        lambda i: self.accept(args[i]),
+                    )
+            arg_types = self.infer_arg_types_in_context(
+                validation_callee, args, arg_kinds, validation_formal_to_actual
+            )
+            self.check_argument_types(
+                arg_types,
+                arg_kinds,
+                args,
+                validation_callee,
+                validation_formal_to_actual,
+                context,
+                check_arg=check_arg,
+            )
+        if valid:
+            return False
+
+        ctx = self.type_context[-1]
+        if not ctx:
+            return False
+
+        with self.msg.filter_errors() as local_errors, self.chk.local_type_map:
+            formal_to_actual = map_actuals_to_formals(
+                arg_kinds,
+                arg_names,
+                callee.arg_kinds,
+                callee.arg_names,
+                lambda i: self.accept(args[i]),
+            )
+            need_refresh = any(
+                isinstance(v, (ParamSpecType, TypeVarTupleType)) for v in callee.variables
+            )
+            inferred_callee = self.infer_function_type_arguments(
+                callee, args, arg_kinds, arg_names, formal_to_actual, need_refresh, context
+            )
+        return not local_errors.has_new_errors() and is_subtype(
+            inferred_callee.ret_type, ctx, options=self.chk.options
+        )
+
     def infer_function_type_arguments_using_context(
         self, callable: CallableType, error_context: Context
     ) -> CallableType:
 
@@ -1542,6 +1542,41 @@ def check(paths: Iterable[str], key: Callable[[str], int]) -> Union[str, None]:
     return mymin(paths, key=key, default=None)
 [builtins fixtures/tuple.pyi]
 
+[case testContextInferenceDoesNotWidenInvariantArgument]
+from typing import Generic, Iterable, Iterator, TypeVar, Union
+
+T = TypeVar("T")
+S = TypeVar("S")
+
+class Vec(Generic[T]):
+    def getitem(self, i: int) -> T: pass
+    def setitem(self, i: int, v: T) -> None: pass
+    def __init__(self, iterable: Iterable[T]) -> None: pass
+    def __iter__(self) -> Iterator[T]: pass
+    def __add__(self, value: "Vec[S]") -> "Vec[Union[S, T]]": pass
+
+def fmt(arg: Iterable[Union[int, str]]) -> None: pass
+
+l1: Vec[int] = Vec([1])
+l2: Vec[int] = Vec([1])
+fmt(l1 + l2)
+
+dummy = l1 + l2
+fmt(dummy)
+
+[case testContextInferenceDoesNotWidenKeyedMinItem]
+from typing import Callable, Iterable, List, Tuple, TypeVar
+
+T = TypeVar("T")
+
+def my_min(values: Iterable[T], *, key: Callable[[T], int]) -> T: pass
+def tuple_len(x: Tuple[str, ...]) -> int: pass
+def dot_join(parts: Iterable[str]) -> str: pass
+
+def smallest_prefix(x: List[Tuple[str, ...]]) -> str:
+    return dot_join(my_min(x, key=tuple_len))
+[builtins fixtures/tuple.pyi]
+
 [case testBinaryOpInferenceContext]
 from typing import Literal, TypeVar
 
@@ -1617,6 +1652,34 @@ async def outer(c: Cls[T]) -> Optional[T]:
 [builtins fixtures/async_await.pyi]
 [typing fixtures/typing-async.pyi]
 
+[case testContextInferenceDoesNotWidenAwaitedInferredAttribute]
+from typing import Mapping, Optional, TypeVar
+
+K = TypeVar("K")
+
+async def select_one(options: Mapping[K, str]) -> Optional[K]:
+    return None
+
+class ViaInferredAttr:
+    async def m(self) -> None:
+        cases = {"a": "x"}
+        self._done = await select_one(cases)
+
+async def via_local() -> None:
+    cases = {"a": "x"}
+    done = await select_one(cases)
+    done = await select_one(cases)
+    done2: Optional[str] = await select_one(cases)
+
+class ViaAnnotatedAttr:
+    _done: Optional[str]
+
+    async def m(self) -> None:
+        cases = {"a": "x"}
+        self._done = await select_one(cases)
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-async.pyi]
+
 [case testContextFallbackNarrowingTernaryRValue]
 from typing import Iterable, Union