Sequence of types

The following works in pyright, but not in pyrefly, ty, or (which is why I'm here!) mypy:

from __future__ import annotations

from dataclasses import dataclass

from typing_extensions import (
    Generic,
    Sequence,
    TypeVar,
    assert_type,
)

T = TypeVar("T")


@dataclass
class Agent(Generic[T]):
    output_type: Sequence[type[T]]


class Foo:
    pass


class Bar:
    pass


# pyright - works
# mypy - error: Expression is of type "Agent[object]", not "Agent[Foo | Bar]"  [assert-type]
# pyrefly - assert_type(Agent[Foo], Agent[Bar | Foo]) failed + Argument `list[type[Bar] | type[Foo]]` is not assignable to parameter `output_type` with type `Sequence[type[Foo]]` in function `Agent.__init__`
# ty - `Agent[Foo | Bar]` and `Agent[Unknown]` are not equivalent types
assert_type(Agent([Foo, Bar]), Agent[Foo | Bar])

# pyright - works
# mypy - error: Expression is of type "Agent[Never]", not "Agent[int | str]"  [assert-type]
# pyrefly - assert_type(Agent[int], Agent[str | int]) failed + Argument `list[type[str] | type[int]]` is not assignable to parameter `output_type` with type `Sequence[type[int]]` in function `Agent.__init__`
# ty - `Agent[int | str]` and `Agent[Unknown]` are not equivalent types
assert_type(Agent([int, str]), Agent[int | str])

# works
assert_type(Agent[Foo | Bar]([Foo, Bar]), Agent[Foo | Bar])

# works
assert_type(Agent[int | str]([int, str]), Agent[int | str])

It would be great to see this work in mypy, but if there's a good reason the other 2 out of 3 typecheckers also don't support this I'd love to understand why!

• This is related to a new PydanticAI feature, if you're curious check out https://github.com/pydantic/pydantic-ai/pull/1785#issuecomment-2905774110
• Issues for other type checkers:
  • https://github.com/facebook/pyrefly/issues/345
  • https://github.com/astral-sh/ty/issues/501

Commencez par exécuter la reproduction minimale dans l’issue et comparez les types inférés par mypy avec les cas explicitement paramétrés. Étudiez la manière dont l’inférence des constructeurs génériques gère Sequence[type[T]] lorsque l’argument contient plusieurs types. Le travail est terminé lorsque les assertions de Agent([Foo, Bar]) et Agent([int, str]) non paramétrés passent sans entraîner de régression dans les cas existants.