reflex-dev/reflex · error · TypeError

Unsupported type {var_type} for guess_type.

Error message

Unsupported type {var_type} for guess_type.

What it means

Var.guess_type() inspects a Var's _var_type to pick the best Var subclass (number, string, etc.). After resolving typing.Literal and generic aliases it must end up with an actual class; if the annotation is something unresolvable (a string forward-ref, a TypeVar, a parametrized special form) it raises this TypeError.

Source

Thrown at packages/reflex-base/src/reflex_base/vars/base.py:1116

                for inner_type in non_optional_inner_types
            ]

            union_entry = _var_subclass_matching_python_types(tuple(fixed_inner_types))
            if union_entry is not None:
                return self.to(union_entry.var_subclass, self._var_type)

            if can_use_in_object_var(var_type):
                return self.to(ObjectVar, self._var_type)

            return self

        if fixed_type is Literal:
            args = get_args(var_type)
            fixed_type = unionize(*(type(arg) for arg in args))

        if not isinstance(fixed_type, type):
            msg = f"Unsupported type {var_type} for guess_type."
            raise TypeError(msg)

        if fixed_type is None:
            return self.to(None)

        guessed_entry = _var_subclass_matching_python_types((fixed_type,))
        if guessed_entry is not None:
            return self.to(guessed_entry.var_subclass, self._var_type)

        if can_use_in_object_var(fixed_type):
            return self.to(ObjectVar, self._var_type)

        return self

    @staticmethod
    def _get_setter_name_for_name(
        name: str,
    ) -> str:
        """Get the name of the var's generated setter function.

View on GitHub (pinned to 45b8ed5ab7)

Solutions

1. Simplify the annotation to a concrete type or Optional[concrete] and re-run
2. Resolve forward references: ensure the referenced types are imported/defined where the annotation is evaluated
3. If you need a specific behavior, cast explicitly with var.to(DesiredType) instead of guess_type
4. Report upstream if a legitimate builtin annotation triggers it

Example fix

# before
class State(rx.State):
    items: list  # bare generic trips guess_type
# after
class State(rx.State):
    items: list[str]

import typing
t = State.__annotations__['field']
assert isinstance(typing.get_origin(t) or t, type), f'guess_type cannot handle {t}'

def is_guessable(anno: object) -> bool:
    import typing
    t = anno
    if typing.get_origin(t) is typing.Literal:
        args = typing.get_args(t)
        t = type(args[0]) if args else None
    return isinstance(t, type)

try:
    v = var.guess_type()
except TypeError:
    v = var.to(dict)  # explicit cast fallback

When it happens

Trigger: Calling var.guess_type() when _var_type is a non-class annotation such as a TypeVar, unparameterized generic ('list' without args in some contexts), a forward reference string, or NoneType edge cases that bypass the Literal/generic handling.

Common situations: Annotating state fields with unusual generics or custom classes after a reflex upgrade; TypeVars in shared base states; delayed annotations (from __future__ annotations) not yet resolvable at guess time.

Related errors

• Expected _js_expr to be a string, got value {self._js_expr!r
• Var of type {self._var_type} does not support item access.
• Cannot pass a Var to a built-in function. Consider using .le
• Cannot index into a primitive sequence with a Var. Consider
• Cannot pass a Var to a built-in function. Consider moving th

AI-assisted analysis of reflex-dev/reflex@45b8ed5ab7 (2026-08-28). Data as JSON: /api/errors/d36bafb677058290. Report an issue: GitHub.